modules/ocl/perf/perf_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-2012, Multicoreware, Inc., 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 //    Fangfang Bai, fangfang@multicorewareinc.com
  19 //    Jin Ma,       jin@multicorewareinc.com
  20 //
  21 // Redistribution and use in source and binary forms, with or without modification,
  22 // are permitted provided that the following conditions are met:
  23 //
  24 //   * Redistribution's of source code must retain the above copyright notice,
  25 //     this list of conditions and the following disclaimer.
  26 //
  27 //   * Redistribution's in binary form must reproduce the above copyright notice,
  28 //     this list of conditions and the following disclaimer in the documentation
  29 //     and/or other oclMaterials provided with the distribution.
  30 //
  31 //   * The name of the copyright holders may not be used to endorse or promote products
  32 //     derived from this software without specific prior written permission.
  33 //
  34 // This software is provided by the copyright holders and contributors as is and
  35 // any express or implied warranties, including, but not limited to, the implied
  36 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  37 // In no event shall the Intel Corporation or contributors be liable for any direct,
  38 // indirect, incidental, special, exemplary, or consequential damages
  39 // (including, but not limited to, procurement of substitute goods or services;
  40 // loss of use, data, or profits; or business interruption) however caused
  41 // and on any theory of liability, whether in contract, strict liability,
  42 // or tort (including negligence or otherwise) arising in any way out of
  43 // the use of this software, even if advised of the possibility of such damage.
  44 //
  45 //M*/
  46
  47 #include "precomp.hpp"
  48 ///////////// Lut ////////////////////////
  49 PERFTEST(lut)
  50 {
  51     Mat src, lut, dst, ocl_dst;
  52     ocl::oclMat d_src, d_lut, d_dst;
  53
  54     int all_type[] = {CV_8UC1, CV_8UC3};
  55     std::string type_name[] = {"CV_8UC1", "CV_8UC3"};
  56
  57     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
  58     {
  59         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
  60         {
  61             SUBTEST << size << 'x' << size << "; " << type_name[j];
  62
  63             gen(src, size, size, all_type[j], 0, 256);
  64             gen(lut, 1, 256, CV_8UC1, 0, 1);
  65
  66             LUT(src, lut, dst);
  67
  68             CPU_ON;
  69             LUT(src, lut, dst);
  70             CPU_OFF;
  71
  72             d_src.upload(src);
  73             d_lut.upload(lut);
  74
  75             WARMUP_ON;
  76             ocl::LUT(d_src, d_lut, d_dst);
  77             WARMUP_OFF;
  78
  79             GPU_ON;
  80             ocl::LUT(d_src, d_lut, d_dst);
  81             GPU_OFF;
  82
  83             GPU_FULL_ON;
  84             d_src.upload(src);
  85             d_lut.upload(lut);
  86             ocl::LUT(d_src, d_lut, d_dst);
  87             d_dst.download(ocl_dst);
  88             GPU_FULL_OFF;
  89
  90             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0);
  91         }
  92
  93     }
  94 }
  95
  96 ///////////// Exp ////////////////////////
  97 PERFTEST(Exp)
  98 {
  99     Mat src, dst, ocl_dst;
 100     ocl::oclMat d_src, d_dst;
 101
 102     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 103     {
 104         SUBTEST << size << 'x' << size << "; CV_32FC1";
 105
 106         gen(src, size, size, CV_32FC1, 5, 16);
 107
 108         exp(src, dst);
 109
 110         CPU_ON;
 111         exp(src, dst);
 112         CPU_OFF;
 113         d_src.upload(src);
 114
 115         WARMUP_ON;
 116         ocl::exp(d_src, d_dst);
 117         WARMUP_OFF;
 118
 119         GPU_ON;
 120         ocl::exp(d_src, d_dst);
 121         GPU_OFF;
 122
 123         GPU_FULL_ON;
 124         d_src.upload(src);
 125         ocl::exp(d_src, d_dst);
 126         d_dst.download(ocl_dst);
 127         GPU_FULL_OFF;
 128
 129         TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 2);
 130     }
 131 }
 132
 133 ///////////// LOG ////////////////////////
 134 PERFTEST(Log)
 135 {
 136     Mat src, dst, ocl_dst;
 137     ocl::oclMat d_src, d_dst;
 138
 139     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 140     {
 141         SUBTEST << size << 'x' << size << "; 32F";
 142
 143         gen(src, size, size, CV_32F, 1, 10);
 144
 145         log(src, dst);
 146
 147         CPU_ON;
 148         log(src, dst);
 149         CPU_OFF;
 150         d_src.upload(src);
 151
 152         WARMUP_ON;
 153         ocl::log(d_src, d_dst);
 154         WARMUP_OFF;
 155
 156         GPU_ON;
 157         ocl::log(d_src, d_dst);
 158         GPU_OFF;
 159
 160         GPU_FULL_ON;
 161         d_src.upload(src);
 162         ocl::log(d_src, d_dst);
 163         d_dst.download(ocl_dst);
 164         GPU_FULL_OFF;
 165
 166         TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
 167     }
 168 }
 169
 170 ///////////// Add ////////////////////////
 171 PERFTEST(Add)
 172 {
 173     Mat src1, src2, dst, ocl_dst;
 174     ocl::oclMat d_src1, d_src2, d_dst;
 175
 176     int all_type[] = {CV_8UC1, CV_32FC1};
 177     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
 178
 179     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 180     {
 181         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 182         {
 183             SUBTEST << size << 'x' << size << "; " << type_name[j];
 184
 185             gen(src1, size, size, all_type[j], 0, 1);
 186             gen(src2, size, size, all_type[j], 0, 1);
 187
 188             add(src1, src2, dst);
 189
 190             CPU_ON;
 191             add(src1, src2, dst);
 192             CPU_OFF;
 193
 194             d_src1.upload(src1);
 195             d_src2.upload(src2);
 196
 197             WARMUP_ON;
 198             ocl::add(d_src1, d_src2, d_dst);
 199             WARMUP_OFF;
 200
 201             GPU_ON;
 202             ocl::add(d_src1, d_src2, d_dst);
 203             GPU_OFF;
 204
 205             GPU_FULL_ON;
 206             d_src1.upload(src1);
 207             d_src2.upload(src2);
 208             ocl::add(d_src1, d_src2, d_dst);
 209             d_dst.download(ocl_dst);
 210             GPU_FULL_OFF;
 211
 212             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
 213         }
 214
 215     }
 216 }
 217
 218 ///////////// Mul ////////////////////////
 219 PERFTEST(Mul)
 220 {
 221     Mat src1, src2, dst, ocl_dst;
 222     ocl::oclMat d_src1, d_src2, d_dst;
 223
 224     int all_type[] = {CV_8UC1, CV_8UC4};
 225     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 226
 227     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 228     {
 229         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 230         {
 231             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 232
 233             gen(src1, size, size, all_type[j], 0, 256);
 234             gen(src2, size, size, all_type[j], 0, 256);
 235
 236             multiply(src1, src2, dst);
 237
 238             CPU_ON;
 239             multiply(src1, src2, dst);
 240             CPU_OFF;
 241             d_src1.upload(src1);
 242             d_src2.upload(src2);
 243
 244             WARMUP_ON;
 245             ocl::multiply(d_src1, d_src2, d_dst);
 246             WARMUP_OFF;
 247
 248             GPU_ON;
 249             ocl::multiply(d_src1, d_src2, d_dst);
 250             GPU_OFF;
 251
 252             GPU_FULL_ON;
 253             d_src1.upload(src1);
 254             d_src2.upload(src2);
 255             ocl::multiply(d_src1, d_src2, d_dst);
 256             d_dst.download(ocl_dst);
 257             GPU_FULL_OFF;
 258
 259             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
 260         }
 261
 262     }
 263 }
 264
 265 ///////////// Div ////////////////////////
 266 PERFTEST(Div)
 267 {
 268     Mat src1, src2, dst, ocl_dst;
 269     ocl::oclMat d_src1, d_src2, d_dst;
 270     int all_type[] = {CV_8UC1, CV_8UC4};
 271     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 272
 273     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 274     {
 275         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 276         {
 277             SUBTEST << size << 'x' << size << "; " << type_name[j];
 278
 279             gen(src1, size, size, all_type[j], 0, 256);
 280             gen(src2, size, size, all_type[j], 0, 256);
 281
 282             divide(src1, src2, dst);
 283
 284             CPU_ON;
 285             divide(src1, src2, dst);
 286             CPU_OFF;
 287
 288             d_src1.upload(src1);
 289             d_src2.upload(src2);
 290
 291             WARMUP_ON;
 292             ocl::divide(d_src1, d_src2, d_dst);
 293             WARMUP_OFF;
 294
 295             GPU_ON;
 296             ocl::divide(d_src1, d_src2, d_dst);
 297             GPU_OFF;
 298
 299             GPU_FULL_ON;
 300             d_src1.upload(src1);
 301             d_src2.upload(src2);
 302             ocl::divide(d_src1, d_src2, d_dst);
 303             d_dst.download(ocl_dst);
 304             GPU_FULL_OFF;
 305
 306             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
 307         }
 308
 309     }
 310 }
 311
 312 ///////////// Absdiff ////////////////////////
 313 PERFTEST(Absdiff)
 314 {
 315     Mat src1, src2, dst, ocl_dst;
 316     ocl::oclMat d_src1, d_src2, d_dst;
 317
 318     int all_type[] = {CV_8UC1, CV_8UC4};
 319     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 320
 321     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 322     {
 323         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 324         {
 325             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 326
 327             gen(src1, size, size, all_type[j], 0, 256);
 328             gen(src2, size, size, all_type[j], 0, 256);
 329             gen(dst, size, size, all_type[j], 0, 256);
 330
 331             absdiff(src1, src2, dst);
 332
 333             CPU_ON;
 334             absdiff(src1, src2, dst);
 335             CPU_OFF;
 336
 337             d_src1.upload(src1);
 338             d_src2.upload(src2);
 339
 340             WARMUP_ON;
 341             ocl::absdiff(d_src1, d_src2, d_dst);
 342             WARMUP_OFF;
 343
 344             GPU_ON;
 345             ocl::absdiff(d_src1, d_src2, d_dst);
 346             GPU_OFF;
 347
 348             GPU_FULL_ON;
 349             d_src1.upload(src1);
 350             d_src2.upload(src2);
 351             ocl::absdiff(d_src1, d_src2, d_dst);
 352             d_dst.download(ocl_dst);
 353             GPU_FULL_OFF;
 354
 355             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
 356         }
 357
 358     }
 359 }
 360
 361 ///////////// CartToPolar ////////////////////////
 362 PERFTEST(CartToPolar)
 363 {
 364     Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
 365     ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
 366
 367     int all_type[] = {CV_32FC1};
 368     std::string type_name[] = {"CV_32FC1"};
 369
 370     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 371     {
 372         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 373         {
 374             SUBTEST << size << 'x' << size << "; " << type_name[j];
 375
 376             gen(src1, size, size, all_type[j], 0, 256);
 377             gen(src2, size, size, all_type[j], 0, 256);
 378             gen(dst, size, size, all_type[j], 0, 256);
 379             gen(dst1, size, size, all_type[j], 0, 256);
 380
 381
 382             cartToPolar(src1, src2, dst, dst1, 1);
 383
 384             CPU_ON;
 385             cartToPolar(src1, src2, dst, dst1, 1);
 386             CPU_OFF;
 387
 388             d_src1.upload(src1);
 389             d_src2.upload(src2);
 390
 391             WARMUP_ON;
 392             ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
 393             WARMUP_OFF;
 394
 395             GPU_ON;
 396             ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
 397             GPU_OFF;
 398
 399             GPU_FULL_ON;
 400             d_src1.upload(src1);
 401             d_src2.upload(src2);
 402             ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
 403             d_dst.download(ocl_dst);
 404             d_dst1.download(ocl_dst1);
 405             GPU_FULL_OFF;
 406
 407             double diff1 = checkNorm(ocl_dst1, dst1);
 408             double diff2 = checkNorm(ocl_dst, dst);
 409             double max_diff = max(diff1, diff2);
 410             TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff);
 411
 412         }
 413
 414     }
 415 }
 416
 417 ///////////// PolarToCart ////////////////////////
 418 PERFTEST(PolarToCart)
 419 {
 420     Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
 421     ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
 422
 423     int all_type[] = {CV_32FC1};
 424     std::string type_name[] = {"CV_32FC1"};
 425
 426     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 427     {
 428         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 429         {
 430             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 431
 432             gen(src1, size, size, all_type[j], 0, 256);
 433             gen(src2, size, size, all_type[j], 0, 256);
 434             gen(dst, size, size, all_type[j], 0, 256);
 435             gen(dst1, size, size, all_type[j], 0, 256);
 436
 437
 438             polarToCart(src1, src2, dst, dst1, 1);
 439
 440             CPU_ON;
 441             polarToCart(src1, src2, dst, dst1, 1);
 442             CPU_OFF;
 443             d_src1.upload(src1);
 444             d_src2.upload(src2);
 445
 446             WARMUP_ON;
 447             ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
 448             WARMUP_OFF;
 449
 450             GPU_ON;
 451             ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
 452             GPU_OFF;
 453
 454             GPU_FULL_ON;
 455             d_src1.upload(src1);
 456             d_src2.upload(src2);
 457             ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
 458             d_dst.download(ocl_dst);
 459             d_dst1.download(ocl_dst1);
 460             GPU_FULL_OFF;
 461
 462             double diff1 = checkNorm(ocl_dst1, dst1);
 463             double diff2 = checkNorm(ocl_dst, dst);
 464             double max_diff = max(diff1, diff2);
 465             TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff);
 466
 467         }
 468
 469     }
 470 }
 471
 472 ///////////// Magnitude ////////////////////////
 473 PERFTEST(magnitude)
 474 {
 475     Mat x, y, mag, ocl_mag;
 476     ocl::oclMat d_x, d_y, d_mag;
 477
 478     int all_type[] = {CV_32FC1};
 479     std::string type_name[] = {"CV_32FC1"};
 480
 481     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 482     {
 483         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 484         {
 485             SUBTEST << size << 'x' << size << "; " << type_name[j];
 486
 487             gen(x, size, size, all_type[j], 0, 1);
 488             gen(y, size, size, all_type[j], 0, 1);
 489
 490             magnitude(x, y, mag);
 491
 492             CPU_ON;
 493             magnitude(x, y, mag);
 494             CPU_OFF;
 495             d_x.upload(x);
 496             d_y.upload(y);
 497
 498             WARMUP_ON;
 499             ocl::magnitude(d_x, d_y, d_mag);
 500             WARMUP_OFF;
 501
 502             GPU_ON;
 503             ocl::magnitude(d_x, d_y, d_mag);
 504             GPU_OFF;
 505
 506             GPU_FULL_ON;
 507             d_x.upload(x);
 508             d_y.upload(y);
 509             ocl::magnitude(d_x, d_y, d_mag);
 510             d_mag.download(ocl_mag);
 511             GPU_FULL_OFF;
 512
 513             TestSystem::instance().ExpectedMatNear(ocl_mag, mag, 1e-5);
 514         }
 515
 516     }
 517 }
 518
 519 ///////////// Transpose ////////////////////////
 520 PERFTEST(Transpose)
 521 {
 522     Mat src, dst, ocl_dst;
 523     ocl::oclMat d_src, d_dst;
 524
 525     int all_type[] = {CV_8UC1, CV_8UC4};
 526     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 527
 528     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 529     {
 530         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 531         {
 532             SUBTEST << size << 'x' << size << "; " << type_name[j];
 533
 534             gen(src, size, size, all_type[j], 0, 256);
 535             gen(dst, size, size, all_type[j], 0, 256);
 536
 537             transpose(src, dst);
 538
 539             CPU_ON;
 540             transpose(src, dst);
 541             CPU_OFF;
 542             d_src.upload(src);
 543
 544             WARMUP_ON;
 545             ocl::transpose(d_src, d_dst);
 546             WARMUP_OFF;
 547
 548             GPU_ON;
 549             ocl::transpose(d_src, d_dst);
 550             GPU_OFF;
 551
 552             GPU_FULL_ON;
 553             d_src.upload(src);
 554             ocl::transpose(d_src, d_dst);
 555             d_dst.download(ocl_dst);
 556             GPU_FULL_OFF;
 557
 558             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
 559         }
 560
 561     }
 562 }
 563
 564 ///////////// Flip ////////////////////////
 565 PERFTEST(Flip)
 566 {
 567     Mat src, dst, ocl_dst;
 568     ocl::oclMat d_src, d_dst;
 569
 570     int all_type[] = {CV_8UC1, CV_8UC4};
 571     std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 572
 573     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 574     {
 575         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 576         {
 577             SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; FLIP_BOTH";
 578
 579             gen(src, size, size, all_type[j], 0, 256);
 580             gen(dst, size, size, all_type[j], 0, 256);
 581
 582             flip(src, dst, 0);
 583
 584             CPU_ON;
 585             flip(src, dst, 0);
 586             CPU_OFF;
 587             d_src.upload(src);
 588
 589             WARMUP_ON;
 590             ocl::flip(d_src, d_dst, 0);
 591             WARMUP_OFF;
 592
 593             GPU_ON;
 594             ocl::flip(d_src, d_dst, 0);
 595             GPU_OFF;
 596
 597             GPU_FULL_ON;
 598             d_src.upload(src);
 599             ocl::flip(d_src, d_dst, 0);
 600             d_dst.download(ocl_dst);
 601             GPU_FULL_OFF;
 602
 603             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
 604         }
 605
 606     }
 607 }
 608
 609 ///////////// minMax ////////////////////////
 610 PERFTEST(minMax)
 611 {
 612     Mat src;
 613     ocl::oclMat d_src;
 614
 615     double min_val = 0.0, max_val = 0.0;
 616     double min_val_ = 0.0, max_val_ = 0.0;
 617     Point min_loc, max_loc;
 618     int all_type[] = {CV_8UC1, CV_32FC1};
 619     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
 620
 621     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 622     {
 623         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 624         {
 625             SUBTEST << size << 'x' << size << "; " << type_name[j];
 626
 627             gen(src, size, size, all_type[j], 0, 256);
 628
 629             CPU_ON;
 630             minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
 631             CPU_OFF;
 632             d_src.upload(src);
 633
 634             WARMUP_ON;
 635             ocl::minMax(d_src, &min_val_, &max_val_);
 636             WARMUP_OFF;
 637
 638             if(EeceptDoubleEQ<double>(max_val_, max_val) && EeceptDoubleEQ<double>(min_val_, min_val))
 639                 TestSystem::instance().setAccurate(1, max(fabs(max_val_-max_val), fabs(min_val_-min_val)));
 640             else
 641                 TestSystem::instance().setAccurate(0, max(fabs(max_val_-max_val), fabs(min_val_-min_val)));
 642
 643             GPU_ON;
 644             ocl::minMax(d_src, &min_val, &max_val);
 645             GPU_OFF;
 646
 647             GPU_FULL_ON;
 648             d_src.upload(src);
 649             ocl::minMax(d_src, &min_val, &max_val);
 650             GPU_FULL_OFF;
 651
 652         }
 653
 654     }
 655 }
 656
 657 ///////////// minMaxLoc ////////////////////////
 658 PERFTEST(minMaxLoc)
 659 {
 660     Mat src;
 661     ocl::oclMat d_src;
 662
 663     double min_val = 0.0, max_val = 0.0;
 664     double min_val_ = 0.0, max_val_ = 0.0;
 665     Point min_loc, max_loc;
 666     Point min_loc_, max_loc_;
 667     int all_type[] = {CV_8UC1, CV_32FC1};
 668     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
 669
 670     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 671     {
 672         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 673         {
 674             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 675
 676             gen(src, size, size, all_type[j], 0, 1);
 677
 678             CPU_ON;
 679             minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
 680             CPU_OFF;
 681             d_src.upload(src);
 682
 683             WARMUP_ON;
 684             ocl::minMaxLoc(d_src, &min_val_, &max_val_, &min_loc_, &max_loc_);
 685             WARMUP_OFF;
 686
 687             double error0 = 0., error1 = 0., minlocVal = 0., minlocVal_ = 0., maxlocVal = 0., maxlocVal_ = 0.;
 688             if(src.depth() == 0)
 689             {
 690                 minlocVal = src.at<unsigned char>(min_loc);
 691                 minlocVal_ = src.at<unsigned char>(min_loc_);
 692                 maxlocVal = src.at<unsigned char>(max_loc);
 693                 maxlocVal_ = src.at<unsigned char>(max_loc_);
 694             }
 695             if(src.depth() == 1)
 696             {
 697                 minlocVal = src.at<signed char>(min_loc);
 698                 minlocVal_ = src.at<signed char>(min_loc_);
 699                 maxlocVal = src.at<signed char>(max_loc);
 700                 maxlocVal_ = src.at<signed char>(max_loc_);
 701             }
 702             if(src.depth() == 2)
 703             {
 704                 minlocVal = src.at<unsigned short>(min_loc);
 705                 minlocVal_ = src.at<unsigned short>(min_loc_);
 706                 maxlocVal = src.at<unsigned short>(max_loc);
 707                 maxlocVal_ = src.at<unsigned short>(max_loc_);
 708             }
 709             if(src.depth() == 3)
 710             {
 711                 minlocVal = src.at<signed short>(min_loc);
 712                 minlocVal_ = src.at<signed short>(min_loc_);
 713                 maxlocVal = src.at<signed short>(max_loc);
 714                 maxlocVal_ = src.at<signed short>(max_loc_);
 715             }
 716             if(src.depth() == 4)
 717             {
 718                 minlocVal = src.at<int>(min_loc);
 719                 minlocVal_ = src.at<int>(min_loc_);
 720                 maxlocVal = src.at<int>(max_loc);
 721                 maxlocVal_ = src.at<int>(max_loc_);
 722             }
 723             if(src.depth() == 5)
 724             {
 725                 minlocVal = src.at<float>(min_loc);
 726                 minlocVal_ = src.at<float>(min_loc_);
 727                 maxlocVal = src.at<float>(max_loc);
 728                 maxlocVal_ = src.at<float>(max_loc_);
 729             }
 730             if(src.depth() == 6)
 731             {
 732                 minlocVal = src.at<double>(min_loc);
 733                 minlocVal_ = src.at<double>(min_loc_);
 734                 maxlocVal = src.at<double>(max_loc);
 735                 maxlocVal_ = src.at<double>(max_loc_);
 736             }
 737             error0 = ::abs(minlocVal_ - minlocVal);
 738             error1 = ::abs(maxlocVal_ - maxlocVal);
 739             if( EeceptDoubleEQ<double>(maxlocVal_, maxlocVal)
 740                 &&EeceptDoubleEQ<double>(minlocVal_, minlocVal)
 741                 &&EeceptDoubleEQ<double>(max_val_, max_val)
 742                 &&EeceptDoubleEQ<double>(min_val_, min_val))
 743                 TestSystem::instance().setAccurate(1, 0.);
 744             else
 745                 TestSystem::instance().setAccurate(0, max(error0, error1));
 746
 747             GPU_ON;
 748             ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
 749             GPU_OFF;
 750
 751             GPU_FULL_ON;
 752             d_src.upload(src);
 753             ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
 754             GPU_FULL_OFF;
 755         }
 756
 757     }
 758 }
 759
 760 ///////////// Sum ////////////////////////
 761 PERFTEST(Sum)
 762 {
 763     Mat src;
 764     Scalar cpures, gpures;
 765     ocl::oclMat d_src;
 766
 767     int all_type[] = {CV_8UC1, CV_32SC1};
 768     std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
 769
 770     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 771     {
 772         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 773         {
 774             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 775
 776             gen(src, size, size, all_type[j], 0, 60);
 777
 778             cpures = sum(src);
 779
 780             CPU_ON;
 781             cpures = sum(src);
 782             CPU_OFF;
 783             d_src.upload(src);
 784
 785             WARMUP_ON;
 786             gpures = ocl::sum(d_src);
 787             WARMUP_OFF;
 788
 789             vector<double> diffs(4);
 790             diffs[3] = fabs(cpures[3] - gpures[3]);
 791             diffs[2] = fabs(cpures[2] - gpures[2]);
 792             diffs[1] = fabs(cpures[1] - gpures[1]);
 793             diffs[0] = fabs(cpures[0] - gpures[0]);
 794             double max_diff = *max_element(diffs.begin(), diffs.end());
 795             TestSystem::instance().setAccurate(max_diff<0.1?1:0, max_diff);
 796
 797             GPU_ON;
 798             gpures = ocl::sum(d_src);
 799             GPU_OFF;
 800
 801             GPU_FULL_ON;
 802             d_src.upload(src);
 803             gpures = ocl::sum(d_src);
 804             GPU_FULL_OFF;
 805         }
 806
 807     }
 808 }
 809
 810 ///////////// countNonZero ////////////////////////
 811 PERFTEST(countNonZero)
 812 {
 813     Mat src;
 814     ocl::oclMat d_src;
 815
 816     int all_type[] = {CV_8UC1, CV_32FC1};
 817     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
 818
 819     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 820     {
 821         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 822         {
 823             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 824
 825             gen(src, size, size, all_type[j], 0, 256);
 826
 827             countNonZero(src);
 828
 829             int cpures = 0, gpures = 0;
 830             CPU_ON;
 831             cpures = countNonZero(src);
 832             CPU_OFF;
 833             d_src.upload(src);
 834
 835             WARMUP_ON;
 836             gpures = ocl::countNonZero(d_src);
 837             WARMUP_OFF;
 838
 839             int diff = abs(cpures - gpures);
 840             if(diff == 0)
 841                 TestSystem::instance().setAccurate(1, 0);
 842             else
 843                 TestSystem::instance().setAccurate(0, diff);
 844
 845             GPU_ON;
 846             ocl::countNonZero(d_src);
 847             GPU_OFF;
 848
 849             GPU_FULL_ON;
 850             d_src.upload(src);
 851             ocl::countNonZero(d_src);
 852             GPU_FULL_OFF;
 853         }
 854
 855     }
 856 }
 857
 858 ///////////// Phase ////////////////////////
 859 PERFTEST(Phase)
 860 {
 861     Mat src1, src2, dst, ocl_dst;
 862     ocl::oclMat d_src1, d_src2, d_dst;
 863
 864     int all_type[] = {CV_32FC1};
 865     std::string type_name[] = {"CV_32FC1"};
 866
 867     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 868     {
 869         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 870         {
 871             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 872
 873             gen(src1, size, size, all_type[j], 0, 256);
 874             gen(src2, size, size, all_type[j], 0, 256);
 875             gen(dst, size, size, all_type[j], 0, 256);
 876
 877             phase(src1, src2, dst, 1);
 878
 879             CPU_ON;
 880             phase(src1, src2, dst, 1);
 881             CPU_OFF;
 882
 883             d_src1.upload(src1);
 884             d_src2.upload(src2);
 885
 886             WARMUP_ON;
 887             ocl::phase(d_src1, d_src2, d_dst, 1);
 888             WARMUP_OFF;
 889
 890             GPU_ON;
 891             ocl::phase(d_src1, d_src2, d_dst, 1);
 892             GPU_OFF;
 893
 894             GPU_FULL_ON;
 895             d_src1.upload(src1);
 896             d_src2.upload(src2);
 897             ocl::phase(d_src1, d_src2, d_dst, 1);
 898             d_dst.download(ocl_dst);
 899             GPU_FULL_OFF;
 900
 901             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-2);
 902         }
 903
 904     }
 905 }
 906
 907 ///////////// bitwise_and////////////////////////
 908 PERFTEST(bitwise_and)
 909 {
 910     Mat src1, src2, dst, ocl_dst;
 911     ocl::oclMat d_src1, d_src2, d_dst;
 912
 913     int all_type[] = {CV_8UC1, CV_32SC1};
 914     std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
 915
 916     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 917     {
 918         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 919         {
 920             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 921
 922             gen(src1, size, size, all_type[j], 0, 256);
 923             gen(src2, size, size, all_type[j], 0, 256);
 924             gen(dst, size, size, all_type[j], 0, 256);
 925
 926             bitwise_and(src1, src2, dst);
 927
 928             CPU_ON;
 929             bitwise_and(src1, src2, dst);
 930             CPU_OFF;
 931             d_src1.upload(src1);
 932             d_src2.upload(src2);
 933
 934             WARMUP_ON;
 935             ocl::bitwise_and(d_src1, d_src2, d_dst);
 936             WARMUP_OFF;
 937
 938             GPU_ON;
 939             ocl::bitwise_and(d_src1, d_src2, d_dst);
 940             GPU_OFF;
 941
 942             GPU_FULL_ON;
 943             d_src1.upload(src1);
 944             d_src2.upload(src2);
 945             ocl::bitwise_and(d_src1, d_src2, d_dst);
 946             d_dst.download(ocl_dst);
 947             GPU_FULL_OFF;
 948
 949             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
 950         }
 951
 952     }
 953 }
 954
 955 ///////////// bitwise_not////////////////////////
 956 PERFTEST(bitwise_not)
 957 {
 958     Mat src1, dst, ocl_dst;
 959     ocl::oclMat d_src1, d_dst;
 960
 961     int all_type[] = {CV_8UC1, CV_32SC1};
 962     std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
 963
 964     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
 965     {
 966         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
 967         {
 968             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 969
 970             gen(src1, size, size, all_type[j], 0, 256);
 971             gen(dst, size, size, all_type[j], 0, 256);
 972
 973             bitwise_not(src1, dst);
 974
 975             CPU_ON;
 976             bitwise_not(src1, dst);
 977             CPU_OFF;
 978             d_src1.upload(src1);
 979
 980             WARMUP_ON;
 981             ocl::bitwise_not(d_src1, d_dst);
 982             WARMUP_OFF;
 983
 984             GPU_ON;
 985             ocl::bitwise_not(d_src1, d_dst);
 986             GPU_OFF;
 987
 988             GPU_FULL_ON;
 989             d_src1.upload(src1);
 990             ocl::bitwise_not(d_src1, d_dst);
 991             d_dst.download(ocl_dst);
 992             GPU_FULL_OFF;
 993
 994             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
 995         }
 996
 997     }
 998 }
 999
1000 ///////////// compare////////////////////////
1001 PERFTEST(compare)
1002 {
1003     Mat src1, src2, dst, ocl_dst;
1004     ocl::oclMat d_src1, d_src2, d_dst;
1005
1006     int CMP_EQ = 0;
1007     int all_type[] = {CV_8UC1, CV_32FC1};
1008     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
1009
1010     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1011     {
1012         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1013         {
1014             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
1015
1016             gen(src1, size, size, all_type[j], 0, 256);
1017             gen(src2, size, size, all_type[j], 0, 256);
1018             gen(dst, size, size, all_type[j], 0, 256);
1019
1020             compare(src1, src2, dst, CMP_EQ);
1021
1022             CPU_ON;
1023             compare(src1, src2, dst, CMP_EQ);
1024             CPU_OFF;
1025
1026             d_src1.upload(src1);
1027             d_src2.upload(src2);
1028
1029             WARMUP_ON;
1030             ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
1031             WARMUP_OFF;
1032
1033             GPU_ON;
1034             ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
1035             GPU_OFF;
1036
1037             GPU_FULL_ON;
1038             d_src1.upload(src1);
1039             d_src2.upload(src2);
1040             ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
1041             d_dst.download(ocl_dst);
1042             GPU_FULL_OFF;
1043
1044             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
1045         }
1046
1047     }
1048 }
1049
1050 ///////////// pow ////////////////////////
1051 PERFTEST(pow)
1052 {
1053     Mat src, dst, ocl_dst;
1054     ocl::oclMat d_src, d_dst;
1055
1056     int all_type[] = {CV_32FC1};
1057     std::string type_name[] = {"CV_32FC1"};
1058
1059     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1060     {
1061         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1062         {
1063             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
1064
1065             gen(src, size, size, all_type[j], 5, 16);
1066
1067             pow(src, -2.0, dst);
1068
1069             CPU_ON;
1070             pow(src, -2.0, dst);
1071             CPU_OFF;
1072             d_src.upload(src);
1073             d_dst.upload(dst);
1074
1075             WARMUP_ON;
1076             ocl::pow(d_src, -2.0, d_dst);
1077             WARMUP_OFF;
1078
1079             GPU_ON;
1080             ocl::pow(d_src, -2.0, d_dst);
1081             GPU_OFF;
1082
1083             GPU_FULL_ON;
1084             d_src.upload(src);
1085             ocl::pow(d_src, -2.0, d_dst);
1086             d_dst.download(ocl_dst);
1087             GPU_FULL_OFF;
1088
1089             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
1090         }
1091
1092     }
1093 }
1094
1095 ///////////// MagnitudeSqr////////////////////////
1096 PERFTEST(MagnitudeSqr)
1097 {
1098     Mat src1, src2, dst, ocl_dst;
1099     ocl::oclMat d_src1, d_src2, d_dst;
1100
1101     int all_type[] = {CV_32FC1};
1102     std::string type_name[] = {"CV_32FC1"};
1103
1104     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1105     {
1106         for (size_t t = 0; t < sizeof(all_type) / sizeof(int); t++)
1107         {
1108             SUBTEST << size << 'x' << size << "; " << type_name[t];
1109
1110             gen(src1, size, size, all_type[t], 0, 256);
1111             gen(src2, size, size, all_type[t], 0, 256);
1112             gen(dst, size, size, all_type[t], 0, 256);
1113
1114             CPU_ON;
1115             for (int i = 0; i < src1.rows; ++i)
1116                 for (int j = 0; j < src1.cols; ++j)
1117                 {
1118                     float val1 = src1.at<float>(i, j);
1119                     float val2 = src2.at<float>(i, j);
1120                     ((float *)(dst.data))[i * dst.step / 4 + j] = val1 * val1 + val2 * val2;
1121
1122                 }
1123             CPU_OFF;
1124
1125             d_src1.upload(src1);
1126             d_src2.upload(src2);
1127
1128             WARMUP_ON;
1129             ocl::magnitudeSqr(d_src1, d_src2, d_dst);
1130             WARMUP_OFF;
1131
1132             GPU_ON;
1133             ocl::magnitudeSqr(d_src1, d_src2, d_dst);
1134             GPU_OFF;
1135
1136             GPU_FULL_ON;
1137             d_src1.upload(src1);
1138             d_src2.upload(src2);
1139             ocl::magnitudeSqr(d_src1, d_src2, d_dst);
1140             d_dst.download(ocl_dst);
1141             GPU_FULL_OFF;
1142
1143             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
1144         }
1145
1146     }
1147 }
1148
1149 ///////////// AddWeighted////////////////////////
1150 PERFTEST(AddWeighted)
1151 {
1152     Mat src1, src2, dst, ocl_dst;
1153     ocl::oclMat d_src1, d_src2, d_dst;
1154
1155     double alpha = 2.0, beta = 1.0, gama = 3.0;
1156     int all_type[] = {CV_8UC1, CV_32FC1};
1157     std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
1158
1159     for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1160     {
1161         for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1162         {
1163             SUBTEST << size << 'x' << size << "; " << type_name[j] ;
1164
1165             gen(src1, size, size, all_type[j], 0, 256);
1166             gen(src2, size, size, all_type[j], 0, 256);
1167             gen(dst, size, size, all_type[j], 0, 256);
1168
1169
1170             addWeighted(src1, alpha, src2, beta, gama, dst);
1171
1172             CPU_ON;
1173             addWeighted(src1, alpha, src2, beta, gama, dst);
1174             CPU_OFF;
1175             d_src1.upload(src1);
1176             d_src2.upload(src2);
1177
1178             WARMUP_ON;
1179             ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
1180             WARMUP_OFF;
1181
1182             GPU_ON;
1183             ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
1184             GPU_OFF;
1185
1186             GPU_FULL_ON;
1187             d_src1.upload(src1);
1188             d_src2.upload(src2);
1189             ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
1190             d_dst.download(ocl_dst);
1191             GPU_FULL_OFF;
1192
1193             TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
1194         }
1195
1196     }
1197 }