1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
11 // For Open Source Computer Vision Library
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.
18 // Fangfang Bai, fangfang@multicorewareinc.com
19 // Jin Ma, jin@multicorewareinc.com
21 // Redistribution and use in source and binary forms, with or without modification,
22 // are permitted provided that the following conditions are met:
24 // * Redistribution's of source code must retain the above copyright notice,
25 // this list of conditions and the following disclaimer.
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.
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.
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.
47 #include "perf_precomp.hpp"
48 ///////////// Lut ////////////////////////
51 Mat src, lut, dst, ocl_dst;
52 ocl::oclMat d_src, d_lut, d_dst;
54 int all_type[] = {CV_8UC1, CV_8UC3};
55 std::string type_name[] = {"CV_8UC1", "CV_8UC3"};
57 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
59 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
61 SUBTEST << size << 'x' << size << "; " << type_name[j];
63 gen(src, size, size, all_type[j], 0, 256);
64 gen(lut, 1, 256, CV_8UC1, 0, 1);
76 ocl::LUT(d_src, d_lut, d_dst);
80 ocl::LUT(d_src, d_lut, d_dst);
86 ocl::LUT(d_src, d_lut, d_dst);
87 d_dst.download(ocl_dst);
90 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0);
96 ///////////// Exp ////////////////////////
99 Mat src, dst, ocl_dst;
100 ocl::oclMat d_src, d_dst;
102 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
104 SUBTEST << size << 'x' << size << "; CV_32FC1";
106 gen(src, size, size, CV_32FC1, 5, 16);
116 ocl::exp(d_src, d_dst);
120 ocl::exp(d_src, d_dst);
125 ocl::exp(d_src, d_dst);
126 d_dst.download(ocl_dst);
129 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 2);
133 ///////////// LOG ////////////////////////
136 Mat src, dst, ocl_dst;
137 ocl::oclMat d_src, d_dst;
139 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
141 SUBTEST << size << 'x' << size << "; 32F";
143 gen(src, size, size, CV_32F, 1, 10);
153 ocl::log(d_src, d_dst);
157 ocl::log(d_src, d_dst);
162 ocl::log(d_src, d_dst);
163 d_dst.download(ocl_dst);
166 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
170 ///////////// Add ////////////////////////
173 Mat src1, src2, dst, ocl_dst;
174 ocl::oclMat d_src1, d_src2, d_dst;
176 int all_type[] = {CV_8UC1, CV_32FC1};
177 std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
179 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
181 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
183 SUBTEST << size << 'x' << size << "; " << type_name[j];
185 gen(src1, size, size, all_type[j], 0, 1);
186 gen(src2, size, size, all_type[j], 0, 1);
188 add(src1, src2, dst);
191 add(src1, src2, dst);
198 ocl::add(d_src1, d_src2, d_dst);
202 ocl::add(d_src1, d_src2, d_dst);
208 ocl::add(d_src1, d_src2, d_dst);
209 d_dst.download(ocl_dst);
212 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
218 ///////////// Mul ////////////////////////
221 Mat src1, src2, dst, ocl_dst;
222 ocl::oclMat d_src1, d_src2, d_dst;
224 int all_type[] = {CV_8UC1, CV_8UC4};
225 std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
227 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
229 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
231 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
233 gen(src1, size, size, all_type[j], 0, 256);
234 gen(src2, size, size, all_type[j], 0, 256);
236 multiply(src1, src2, dst);
239 multiply(src1, src2, dst);
245 ocl::multiply(d_src1, d_src2, d_dst);
249 ocl::multiply(d_src1, d_src2, d_dst);
255 ocl::multiply(d_src1, d_src2, d_dst);
256 d_dst.download(ocl_dst);
259 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
265 ///////////// Div ////////////////////////
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"};
273 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
275 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
277 SUBTEST << size << 'x' << size << "; " << type_name[j];
279 gen(src1, size, size, all_type[j], 0, 256);
280 gen(src2, size, size, all_type[j], 0, 256);
282 divide(src1, src2, dst);
285 divide(src1, src2, dst);
292 ocl::divide(d_src1, d_src2, d_dst);
296 ocl::divide(d_src1, d_src2, d_dst);
302 ocl::divide(d_src1, d_src2, d_dst);
303 d_dst.download(ocl_dst);
306 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
312 ///////////// Absdiff ////////////////////////
315 Mat src1, src2, dst, ocl_dst;
316 ocl::oclMat d_src1, d_src2, d_dst;
318 int all_type[] = {CV_8UC1, CV_8UC4};
319 std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
321 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
323 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
325 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
331 absdiff(src1, src2, dst);
334 absdiff(src1, src2, dst);
341 ocl::absdiff(d_src1, d_src2, d_dst);
345 ocl::absdiff(d_src1, d_src2, d_dst);
351 ocl::absdiff(d_src1, d_src2, d_dst);
352 d_dst.download(ocl_dst);
355 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
361 ///////////// CartToPolar ////////////////////////
362 PERFTEST(CartToPolar)
364 Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
365 ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
367 int all_type[] = {CV_32FC1};
368 std::string type_name[] = {"CV_32FC1"};
370 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
372 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
374 SUBTEST << size << 'x' << size << "; " << type_name[j];
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);
382 cartToPolar(src1, src2, dst, dst1, 1);
385 cartToPolar(src1, src2, dst, dst1, 1);
392 ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
396 ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
402 ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
403 d_dst.download(ocl_dst);
404 d_dst1.download(ocl_dst1);
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);
417 ///////////// PolarToCart ////////////////////////
418 PERFTEST(PolarToCart)
420 Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
421 ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
423 int all_type[] = {CV_32FC1};
424 std::string type_name[] = {"CV_32FC1"};
426 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
428 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
430 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
438 polarToCart(src1, src2, dst, dst1, 1);
441 polarToCart(src1, src2, dst, dst1, 1);
447 ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
451 ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
457 ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
458 d_dst.download(ocl_dst);
459 d_dst1.download(ocl_dst1);
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);
472 ///////////// Magnitude ////////////////////////
475 Mat x, y, mag, ocl_mag;
476 ocl::oclMat d_x, d_y, d_mag;
478 int all_type[] = {CV_32FC1};
479 std::string type_name[] = {"CV_32FC1"};
481 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
483 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
485 SUBTEST << size << 'x' << size << "; " << type_name[j];
487 gen(x, size, size, all_type[j], 0, 1);
488 gen(y, size, size, all_type[j], 0, 1);
490 magnitude(x, y, mag);
493 magnitude(x, y, mag);
499 ocl::magnitude(d_x, d_y, d_mag);
503 ocl::magnitude(d_x, d_y, d_mag);
509 ocl::magnitude(d_x, d_y, d_mag);
510 d_mag.download(ocl_mag);
513 TestSystem::instance().ExpectedMatNear(ocl_mag, mag, 1e-5);
519 ///////////// Transpose ////////////////////////
522 Mat src, dst, ocl_dst;
523 ocl::oclMat d_src, d_dst;
525 int all_type[] = {CV_8UC1, CV_8UC4};
526 std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
528 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
530 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
532 SUBTEST << size << 'x' << size << "; " << type_name[j];
534 gen(src, size, size, all_type[j], 0, 256);
535 gen(dst, size, size, all_type[j], 0, 256);
545 ocl::transpose(d_src, d_dst);
549 ocl::transpose(d_src, d_dst);
554 ocl::transpose(d_src, d_dst);
555 d_dst.download(ocl_dst);
558 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
564 ///////////// Flip ////////////////////////
567 Mat src, dst, ocl_dst;
568 ocl::oclMat d_src, d_dst;
570 int all_type[] = {CV_8UC1, CV_8UC4};
571 std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
573 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
575 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
577 SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; FLIP_BOTH";
579 gen(src, size, size, all_type[j], 0, 256);
580 gen(dst, size, size, all_type[j], 0, 256);
590 ocl::flip(d_src, d_dst, 0);
594 ocl::flip(d_src, d_dst, 0);
599 ocl::flip(d_src, d_dst, 0);
600 d_dst.download(ocl_dst);
603 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
609 ///////////// minMax ////////////////////////
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"};
621 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
623 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
625 SUBTEST << size << 'x' << size << "; " << type_name[j];
627 gen(src, size, size, all_type[j], 0, 256);
630 minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
635 ocl::minMax(d_src, &min_val_, &max_val_);
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)));
641 TestSystem::instance().setAccurate(0, max(fabs(max_val_-max_val), fabs(min_val_-min_val)));
644 ocl::minMax(d_src, &min_val, &max_val);
649 ocl::minMax(d_src, &min_val, &max_val);
657 ///////////// minMaxLoc ////////////////////////
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"};
670 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
672 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
674 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
676 gen(src, size, size, all_type[j], 0, 1);
679 minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc);
684 ocl::minMaxLoc(d_src, &min_val_, &max_val_, &min_loc_, &max_loc_);
687 double error0 = 0., error1 = 0., minlocVal = 0., minlocVal_ = 0., maxlocVal = 0., maxlocVal_ = 0.;
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_);
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_);
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_);
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_);
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_);
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_);
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_);
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.);
745 TestSystem::instance().setAccurate(0, max(error0, error1));
748 ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
753 ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
760 ///////////// Sum ////////////////////////
764 Scalar cpures, gpures;
767 int all_type[] = {CV_8UC1, CV_32SC1};
768 std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
770 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
772 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
774 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
776 gen(src, size, size, all_type[j], 0, 60);
786 gpures = ocl::sum(d_src);
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);
798 gpures = ocl::sum(d_src);
803 gpures = ocl::sum(d_src);
810 ///////////// countNonZero ////////////////////////
811 PERFTEST(countNonZero)
816 int all_type[] = {CV_8UC1, CV_32FC1};
817 std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
819 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
821 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
823 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
825 gen(src, size, size, all_type[j], 0, 256);
829 int cpures = 0, gpures = 0;
831 cpures = countNonZero(src);
836 gpures = ocl::countNonZero(d_src);
839 int diff = abs(cpures - gpures);
841 TestSystem::instance().setAccurate(1, 0);
843 TestSystem::instance().setAccurate(0, diff);
846 ocl::countNonZero(d_src);
851 ocl::countNonZero(d_src);
858 ///////////// Phase ////////////////////////
861 Mat src1, src2, dst, ocl_dst;
862 ocl::oclMat d_src1, d_src2, d_dst;
864 int all_type[] = {CV_32FC1};
865 std::string type_name[] = {"CV_32FC1"};
867 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
869 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
871 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
877 phase(src1, src2, dst, 1);
880 phase(src1, src2, dst, 1);
887 ocl::phase(d_src1, d_src2, d_dst, 1);
891 ocl::phase(d_src1, d_src2, d_dst, 1);
897 ocl::phase(d_src1, d_src2, d_dst, 1);
898 d_dst.download(ocl_dst);
901 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-2);
907 ///////////// bitwise_and////////////////////////
908 PERFTEST(bitwise_and)
910 Mat src1, src2, dst, ocl_dst;
911 ocl::oclMat d_src1, d_src2, d_dst;
913 int all_type[] = {CV_8UC1, CV_32SC1};
914 std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
916 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
918 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
920 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
926 bitwise_and(src1, src2, dst);
929 bitwise_and(src1, src2, dst);
935 ocl::bitwise_and(d_src1, d_src2, d_dst);
939 ocl::bitwise_and(d_src1, d_src2, d_dst);
945 ocl::bitwise_and(d_src1, d_src2, d_dst);
946 d_dst.download(ocl_dst);
949 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
955 ///////////// bitwise_not////////////////////////
956 PERFTEST(bitwise_not)
958 Mat src1, dst, ocl_dst;
959 ocl::oclMat d_src1, d_dst;
961 int all_type[] = {CV_8UC1, CV_32SC1};
962 std::string type_name[] = {"CV_8UC1", "CV_32SC1"};
964 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
966 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
968 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
970 gen(src1, size, size, all_type[j], 0, 256);
971 gen(dst, size, size, all_type[j], 0, 256);
973 bitwise_not(src1, dst);
976 bitwise_not(src1, dst);
981 ocl::bitwise_not(d_src1, d_dst);
985 ocl::bitwise_not(d_src1, d_dst);
990 ocl::bitwise_not(d_src1, d_dst);
991 d_dst.download(ocl_dst);
994 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
1000 ///////////// compare////////////////////////
1003 Mat src1, src2, dst, ocl_dst;
1004 ocl::oclMat d_src1, d_src2, d_dst;
1007 int all_type[] = {CV_8UC1, CV_32FC1};
1008 std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
1010 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1012 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1014 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
1020 compare(src1, src2, dst, CMP_EQ);
1023 compare(src1, src2, dst, CMP_EQ);
1026 d_src1.upload(src1);
1027 d_src2.upload(src2);
1030 ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
1034 ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
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);
1044 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
1050 ///////////// pow ////////////////////////
1053 Mat src, dst, ocl_dst;
1054 ocl::oclMat d_src, d_dst;
1056 int all_type[] = {CV_32FC1};
1057 std::string type_name[] = {"CV_32FC1"};
1059 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1061 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1063 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
1065 gen(src, size, size, all_type[j], 5, 16);
1067 pow(src, -2.0, dst);
1070 pow(src, -2.0, dst);
1076 ocl::pow(d_src, -2.0, d_dst);
1080 ocl::pow(d_src, -2.0, d_dst);
1085 ocl::pow(d_src, -2.0, d_dst);
1086 d_dst.download(ocl_dst);
1089 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
1095 ///////////// MagnitudeSqr////////////////////////
1096 PERFTEST(MagnitudeSqr)
1098 Mat src1, src2, dst, ocl_dst;
1099 ocl::oclMat d_src1, d_src2, d_dst;
1101 int all_type[] = {CV_32FC1};
1102 std::string type_name[] = {"CV_32FC1"};
1104 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1106 for (size_t t = 0; t < sizeof(all_type) / sizeof(int); t++)
1108 SUBTEST << size << 'x' << size << "; " << type_name[t];
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);
1115 for (int i = 0; i < src1.rows; ++i)
1116 for (int j = 0; j < src1.cols; ++j)
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;
1125 d_src1.upload(src1);
1126 d_src2.upload(src2);
1129 ocl::magnitudeSqr(d_src1, d_src2, d_dst);
1133 ocl::magnitudeSqr(d_src1, d_src2, d_dst);
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);
1143 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
1149 ///////////// AddWeighted////////////////////////
1150 PERFTEST(AddWeighted)
1152 Mat src1, src2, dst, ocl_dst;
1153 ocl::oclMat d_src1, d_src2, d_dst;
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"};
1159 for (int size = Min_Size; size <= Max_Size; size *= Multiple)
1161 for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
1163 SUBTEST << size << 'x' << size << "; " << type_name[j] ;
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);
1170 addWeighted(src1, alpha, src2, beta, gama, dst);
1173 addWeighted(src1, alpha, src2, beta, gama, dst);
1175 d_src1.upload(src1);
1176 d_src2.upload(src2);
1179 ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
1183 ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
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);
1193 TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);