1 ///////////////////////////////////////////////////////////////////////////////////////
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, Institute Of Software Chinese Academy Of Science, all rights reserved.
14 // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
15 // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
16 // Third party copyrights are property of their respective owners.
19 // Niko Li, newlife20080214@gmail.com
20 // Jia Haipeng, jiahaipeng95@gmail.com
21 // Shengen Yan, yanshengen@gmail.com
22 // Jiang Liyuan,jlyuan001.good@163.com
23 // Rock Li, Rock.Li@amd.com
24 // Zailong Wu, bullet@yeah.net
25 // Yao Wang, bitwangyaoyao@gmail.com
27 // Redistribution and use in source and binary forms, with or without modification,
28 // are permitted provided that the following conditions are met:
30 // * Redistribution's of source code must retain the above copyright notice,
31 // this list of conditions and the following disclaimer.
33 // * Redistribution's in binary form must reproduce the above copyright notice,
34 // this list of conditions and the following disclaimer in the documentation
35 // and/or other oclMaterials provided with the distribution.
37 // * The name of the copyright holders may not be used to endorse or promote products
38 // derived from this software without specific prior written permission.
40 // This software is provided by the copyright holders and contributors "as is" and
41 // any express or implied warranties, including, but not limited to, the implied
42 // warranties of merchantability and fitness for a particular purpose are disclaimed.
43 // In no event shall the Intel Corporation or contributors be liable for any direct,
44 // indirect, incidental, special, exemplary, or consequential damages
45 // (including, but not limited to, procurement of substitute goods or services;
46 // loss of use, data, or profits; or business interruption) however caused
47 // and on any theory of liability, whether in contract, strict liability,
48 // or tort (including negligence or otherwise) arising in any way out of
49 // the use of this software, even if advised of the possibility of such damage.
53 //#define PRINT_CPU_TIME 1000
57 #include "precomp.hpp"
63 using namespace cv::ocl;
64 using namespace cvtest;
65 using namespace testing;
68 PARAM_TEST_CASE(ArithmTestBase, MatType, bool)
78 cv::Mat dst1; //bak, for two outputs
97 cv::Mat dst1_roi; //bak
99 //ocl dst mat for testing
100 cv::ocl::oclMat gdst_whole;
101 cv::ocl::oclMat gdst1_whole; //bak
104 cv::ocl::oclMat gmat1;
105 cv::ocl::oclMat gmat2;
106 cv::ocl::oclMat gdst;
107 cv::ocl::oclMat gdst1; //bak
108 cv::ocl::oclMat gmask;
114 cv::RNG &rng = TS::ptr()->get_rng();
116 cv::Size size(MWIDTH, MHEIGHT);
118 mat1 = randomMat(rng, size, type, 5, 16, false);
119 //mat2 = randomMat(rng, size, type, 5, 16, false);
120 mat2 = randomMat(rng, size, type, 5, 16, false);
121 dst = randomMat(rng, size, type, 5, 16, false);
122 dst1 = randomMat(rng, size, type, 5, 16, false);
123 mask = randomMat(rng, size, CV_8UC1, 0, 2, false);
125 cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
127 val = cv::Scalar(rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0));
135 cv::RNG &rng = TS::ptr()->get_rng();
136 roicols = rng.uniform(1, mat1.cols);
137 roirows = rng.uniform(1, mat1.rows);
138 src1x = rng.uniform(0, mat1.cols - roicols);
139 src1y = rng.uniform(0, mat1.rows - roirows);
140 dstx = rng.uniform(0, dst.cols - roicols);
141 dsty = rng.uniform(0, dst.rows - roirows);
142 maskx = rng.uniform(0, mask.cols - roicols);
143 masky = rng.uniform(0, mask.rows - roirows);
144 src2x = rng.uniform(0, mat2.cols - roicols);
145 src2y = rng.uniform(0, mat2.rows - roirows);
158 mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
159 mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
160 mask_roi = mask(Rect(maskx, masky, roicols, roirows));
161 dst_roi = dst(Rect(dstx, dsty, roicols, roirows));
162 dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows));
165 gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
168 gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows));
172 gmask = mask_roi; //end
175 void Near(double threshold = 0.)
177 EXPECT_MAT_NEAR(dst, Mat(gdst_whole), threshold);
180 void Near1(double threshold = 0.)
182 EXPECT_MAT_NEAR(dst1, Mat(gdst1_whole), threshold);
186 ////////////////////////////////lut/////////////////////////////////////////////////
187 struct Lut : ArithmTestBase {};
188 #define VARNAME(A) string(#A);
194 cv::Mat mat2(3, 512, CV_8UC1);
195 cv::RNG &rng = TS::ptr()->get_rng();
196 rng.fill(mat2, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(256));
198 for(int j = 0; j < LOOP_TIMES; j ++)
202 src2x = rng.uniform( 0, mat2.cols - 256);
203 src2y = rng.uniform (0, mat2.rows - 1);
205 cv::Mat mat2_roi = mat2(Rect(src2x, src2y, 256, 1));
207 cv::ocl::oclMat gmat2(mat2_roi);
209 cv::LUT(mat1_roi, mat2_roi, dst_roi);
210 cv::ocl::LUT(gmat1, gmat2, gdst);
216 ////////////////////////////////exp/////////////////////////////////////////////////
217 struct Exp : ArithmTestBase {};
221 for(int j = 0; j < LOOP_TIMES; j++)
225 cv::exp(mat1_roi, dst_roi);
226 cv::ocl::exp(gmat1, gdst);
232 ////////////////////////////////log/////////////////////////////////////////////////
233 struct Log : ArithmTestBase {};
237 for(int j = 0; j < LOOP_TIMES; j++)
241 cv::log(mat1_roi, dst_roi);
242 cv::ocl::log(gmat1, gdst);
248 ////////////////////////////////add/////////////////////////////////////////////////
249 struct Add : ArithmTestBase {};
253 for(int j = 0; j < LOOP_TIMES; j++)
257 cv::add(mat1_roi, mat2_roi, dst_roi);
258 cv::ocl::add(gmat1, gmat2, gdst);
263 TEST_P(Add, Mat_Mask)
265 for(int j = 0; j < LOOP_TIMES; j++)
269 cv::add(mat1_roi, mat2_roi, dst_roi, mask_roi);
270 cv::ocl::add(gmat1, gmat2, gdst, gmask);
277 for(int j = 0; j < LOOP_TIMES; j++)
281 cv::add(mat1_roi, val, dst_roi);
282 cv::ocl::add(gmat1, val, gdst);
287 TEST_P(Add, Scalar_Mask)
289 for(int j = 0; j < LOOP_TIMES; j++)
293 cv::add(mat1_roi, val, dst_roi, mask_roi);
294 cv::ocl::add(gmat1, val, gdst, gmask);
301 ////////////////////////////////sub/////////////////////////////////////////////////
302 struct Sub : ArithmTestBase {};
306 for(int j = 0; j < LOOP_TIMES; j++)
310 cv::subtract(mat1_roi, mat2_roi, dst_roi);
311 cv::ocl::subtract(gmat1, gmat2, gdst);
316 TEST_P(Sub, Mat_Mask)
318 for(int j = 0; j < LOOP_TIMES; j++)
322 cv::subtract(mat1_roi, mat2_roi, dst_roi, mask_roi);
323 cv::ocl::subtract(gmat1, gmat2, gdst, gmask);
330 for(int j = 0; j < LOOP_TIMES; j++)
334 cv::subtract(mat1_roi, val, dst_roi);
335 cv::ocl::subtract(gmat1, val, gdst);
340 TEST_P(Sub, Scalar_Mask)
342 for(int j = 0; j < LOOP_TIMES; j++)
346 cv::subtract(mat1_roi, val, dst_roi, mask_roi);
347 cv::ocl::subtract(gmat1, val, gdst, gmask);
354 ////////////////////////////////Mul/////////////////////////////////////////////////
355 struct Mul : ArithmTestBase {};
359 for(int j = 0; j < LOOP_TIMES; j++)
363 cv::multiply(mat1_roi, mat2_roi, dst_roi);
364 cv::ocl::multiply(gmat1, gmat2, gdst);
369 TEST_P(Mul, Mat_Scalar)
371 for(int j = 0; j < LOOP_TIMES; j++)
375 cv::RNG &rng = TS::ptr()->get_rng();
376 double s = rng.uniform(-10.0, 10.0);
378 cv::multiply(mat1_roi, mat2_roi, dst_roi, s);
379 cv::ocl::multiply(gmat1, gmat2, gdst, s);
386 struct Div : ArithmTestBase {};
390 for(int j = 0; j < LOOP_TIMES; j++)
394 cv::divide(mat1_roi, mat2_roi, dst_roi);
395 cv::ocl::divide(gmat1, gmat2, gdst);
400 TEST_P(Div, Mat_Scalar)
402 for(int j = 0; j < LOOP_TIMES; j++)
406 cv::RNG &rng = TS::ptr()->get_rng();
407 double s = rng.uniform(-10.0, 10.0);
409 cv::divide(mat1_roi, mat2_roi, dst_roi, s);
410 cv::ocl::divide(gmat1, gmat2, gdst, s);
416 struct Absdiff : ArithmTestBase {};
420 for(int j = 0; j < LOOP_TIMES; j++)
424 cv::absdiff(mat1_roi, mat2_roi, dst_roi);
425 cv::ocl::absdiff(gmat1, gmat2, gdst);
430 TEST_P(Absdiff, Mat_Scalar)
432 for(int j = 0; j < LOOP_TIMES; j++)
436 cv::absdiff(mat1_roi, val, dst_roi);
437 cv::ocl::absdiff(gmat1, val, gdst);
444 struct CartToPolar : ArithmTestBase {};
446 TEST_P(CartToPolar, angleInDegree)
448 for(int j = 0; j < LOOP_TIMES; j++)
452 cv::cartToPolar(mat1_roi, mat2_roi, dst_roi, dst1_roi, 1);
453 cv::ocl::cartToPolar(gmat1, gmat2, gdst, gdst1, 1);
459 TEST_P(CartToPolar, angleInRadians)
461 for(int j = 0; j < LOOP_TIMES; j++)
465 cv::cartToPolar(mat1_roi, mat2_roi, dst_roi, dst1_roi, 0);
466 cv::ocl::cartToPolar(gmat1, gmat2, gdst, gdst1, 0);
473 struct PolarToCart : ArithmTestBase {};
475 TEST_P(PolarToCart, angleInDegree)
477 for(int j = 0; j < LOOP_TIMES; j++)
481 cv::polarToCart(mat1_roi, mat2_roi, dst_roi, dst1_roi, 1);
482 cv::ocl::polarToCart(gmat1, gmat2, gdst, gdst1, 1);
488 TEST_P(PolarToCart, angleInRadians)
490 for(int j = 0; j < LOOP_TIMES; j++)
494 cv::polarToCart(mat1_roi, mat2_roi, dst_roi, dst1_roi, 0);
495 cv::ocl::polarToCart(gmat1, gmat2, gdst, gdst1, 0);
504 struct Magnitude : ArithmTestBase {};
506 TEST_P(Magnitude, Mat)
508 for(int j = 0; j < LOOP_TIMES; j++)
512 cv::magnitude(mat1_roi, mat2_roi, dst_roi);
513 cv::ocl::magnitude(gmat1, gmat2, gdst);
519 struct Transpose : ArithmTestBase {};
521 TEST_P(Transpose, Mat)
523 for(int j = 0; j < LOOP_TIMES; j++)
527 cv::transpose(mat1_roi, dst_roi);
528 cv::ocl::transpose(gmat1, gdst);
534 struct Flip : ArithmTestBase {};
538 for(int j = 0; j < LOOP_TIMES; j++)
542 cv::flip(mat1_roi, dst_roi, 0);
543 cv::ocl::flip(gmat1, gdst, 0);
550 for(int j = 0; j < LOOP_TIMES; j++)
554 cv::flip(mat1_roi, dst_roi, 1);
555 cv::ocl::flip(gmat1, gdst, 1);
562 for(int j = 0; j < LOOP_TIMES; j++)
566 cv::flip(mat1_roi, dst_roi, -1);
567 cv::ocl::flip(gmat1, gdst, -1);
573 struct MinMax : ArithmTestBase {};
577 for(int j = 0; j < LOOP_TIMES; j++)
580 double minVal, maxVal;
581 cv::Point minLoc, maxLoc;
583 if (mat1.depth() != CV_8S)
585 cv::minMaxLoc(mat1_roi, &minVal, &maxVal, &minLoc, &maxLoc);
589 minVal = std::numeric_limits<double>::max();
590 maxVal = -std::numeric_limits<double>::max();
591 for (int i = 0; i < mat1_roi.rows; ++i)
592 for (int j = 0; j < mat1_roi.cols; ++j)
594 signed char val = mat1_roi.at<signed char>(i, j);
595 if (val < minVal) minVal = val;
596 if (val > maxVal) maxVal = val;
600 double minVal_, maxVal_;
601 cv::ocl::minMax(gmat1, &minVal_, &maxVal_);
603 EXPECT_DOUBLE_EQ(minVal_, minVal);
604 EXPECT_DOUBLE_EQ(maxVal_, maxVal);
610 for(int j = 0; j < LOOP_TIMES; j++)
613 double minVal, maxVal;
614 cv::Point minLoc, maxLoc;
616 if (mat1.depth() != CV_8S)
618 cv::minMaxLoc(mat1_roi, &minVal, &maxVal, &minLoc, &maxLoc, mask_roi);
622 minVal = std::numeric_limits<double>::max();
623 maxVal = -std::numeric_limits<double>::max();
624 for (int i = 0; i < mat1_roi.rows; ++i)
625 for (int j = 0; j < mat1_roi.cols; ++j)
627 signed char val = mat1_roi.at<signed char>(i, j);
628 unsigned char m = mask_roi.at<unsigned char>(i, j);
629 if (val < minVal && m) minVal = val;
630 if (val > maxVal && m) maxVal = val;
634 double minVal_, maxVal_;
635 cv::ocl::minMax(gmat1, &minVal_, &maxVal_, gmask);
637 EXPECT_DOUBLE_EQ(minVal_, minVal);
638 EXPECT_DOUBLE_EQ(maxVal_, maxVal);
643 struct MinMaxLoc : ArithmTestBase {};
645 TEST_P(MinMaxLoc, MAT)
647 for(int j = 0; j < LOOP_TIMES; j++)
650 double minVal, maxVal;
651 cv::Point minLoc, maxLoc;
652 int depth = mat1.depth();
655 cv::minMaxLoc(mat1_roi, &minVal, &maxVal, &minLoc, &maxLoc);
659 minVal = std::numeric_limits<double>::max();
660 maxVal = -std::numeric_limits<double>::max();
661 for (int i = 0; i < mat1_roi.rows; ++i)
662 for (int j = 0; j < mat1_roi.cols; ++j)
664 signed char val = mat1_roi.at<signed char>(i, j);
680 double minVal_, maxVal_;
681 cv::Point minLoc_, maxLoc_;
682 cv::ocl::minMaxLoc(gmat1, &minVal_, &maxVal_, &minLoc_, &maxLoc_, cv::ocl::oclMat());
684 double error0 = 0., error1 = 0., minlocVal = 0., minlocVal_ = 0., maxlocVal = 0., maxlocVal_ = 0.;
687 minlocVal = mat1_roi.at<unsigned char>(minLoc);
688 minlocVal_ = mat1_roi.at<unsigned char>(minLoc_);
689 maxlocVal = mat1_roi.at<unsigned char>(maxLoc);
690 maxlocVal_ = mat1_roi.at<unsigned char>(maxLoc_);
691 error0 = ::abs(mat1_roi.at<unsigned char>(minLoc_) - mat1_roi.at<unsigned char>(minLoc));
692 error1 = ::abs(mat1_roi.at<unsigned char>(maxLoc_) - mat1_roi.at<unsigned char>(maxLoc));
696 minlocVal = mat1_roi.at<signed char>(minLoc);
697 minlocVal_ = mat1_roi.at<signed char>(minLoc_);
698 maxlocVal = mat1_roi.at<signed char>(maxLoc);
699 maxlocVal_ = mat1_roi.at<signed char>(maxLoc_);
700 error0 = ::abs(mat1_roi.at<signed char>(minLoc_) - mat1_roi.at<signed char>(minLoc));
701 error1 = ::abs(mat1_roi.at<signed char>(maxLoc_) - mat1_roi.at<signed char>(maxLoc));
705 minlocVal = mat1_roi.at<unsigned short>(minLoc);
706 minlocVal_ = mat1_roi.at<unsigned short>(minLoc_);
707 maxlocVal = mat1_roi.at<unsigned short>(maxLoc);
708 maxlocVal_ = mat1_roi.at<unsigned short>(maxLoc_);
709 error0 = ::abs(mat1_roi.at<unsigned short>(minLoc_) - mat1_roi.at<unsigned short>(minLoc));
710 error1 = ::abs(mat1_roi.at<unsigned short>(maxLoc_) - mat1_roi.at<unsigned short>(maxLoc));
714 minlocVal = mat1_roi.at<signed short>(minLoc);
715 minlocVal_ = mat1_roi.at<signed short>(minLoc_);
716 maxlocVal = mat1_roi.at<signed short>(maxLoc);
717 maxlocVal_ = mat1_roi.at<signed short>(maxLoc_);
718 error0 = ::abs(mat1_roi.at<signed short>(minLoc_) - mat1_roi.at<signed short>(minLoc));
719 error1 = ::abs(mat1_roi.at<signed short>(maxLoc_) - mat1_roi.at<signed short>(maxLoc));
723 minlocVal = mat1_roi.at<int>(minLoc);
724 minlocVal_ = mat1_roi.at<int>(minLoc_);
725 maxlocVal = mat1_roi.at<int>(maxLoc);
726 maxlocVal_ = mat1_roi.at<int>(maxLoc_);
727 error0 = ::abs(mat1_roi.at<int>(minLoc_) - mat1_roi.at<int>(minLoc));
728 error1 = ::abs(mat1_roi.at<int>(maxLoc_) - mat1_roi.at<int>(maxLoc));
732 minlocVal = mat1_roi.at<float>(minLoc);
733 minlocVal_ = mat1_roi.at<float>(minLoc_);
734 maxlocVal = mat1_roi.at<float>(maxLoc);
735 maxlocVal_ = mat1_roi.at<float>(maxLoc_);
736 error0 = ::abs(mat1_roi.at<float>(minLoc_) - mat1_roi.at<float>(minLoc));
737 error1 = ::abs(mat1_roi.at<float>(maxLoc_) - mat1_roi.at<float>(maxLoc));
741 minlocVal = mat1_roi.at<double>(minLoc);
742 minlocVal_ = mat1_roi.at<double>(minLoc_);
743 maxlocVal = mat1_roi.at<double>(maxLoc);
744 maxlocVal_ = mat1_roi.at<double>(maxLoc_);
745 error0 = ::abs(mat1_roi.at<double>(minLoc_) - mat1_roi.at<double>(minLoc));
746 error1 = ::abs(mat1_roi.at<double>(maxLoc_) - mat1_roi.at<double>(maxLoc));
749 EXPECT_DOUBLE_EQ(minVal_, minVal);
750 EXPECT_DOUBLE_EQ(maxVal_, maxVal);
751 EXPECT_DOUBLE_EQ(minlocVal_, minlocVal);
752 EXPECT_DOUBLE_EQ(maxlocVal_, maxlocVal);
754 EXPECT_DOUBLE_EQ(error0, 0.0);
755 EXPECT_DOUBLE_EQ(error1, 0.0);
760 TEST_P(MinMaxLoc, MASK)
762 for(int j = 0; j < LOOP_TIMES; j++)
765 double minVal, maxVal;
766 cv::Point minLoc, maxLoc;
767 int depth = mat1.depth();
770 cv::minMaxLoc(mat1_roi, &minVal, &maxVal, &minLoc, &maxLoc, mask_roi);
774 minVal = std::numeric_limits<double>::max();
775 maxVal = -std::numeric_limits<double>::max();
776 for (int i = 0; i < mat1_roi.rows; ++i)
777 for (int j = 0; j < mat1_roi.cols; ++j)
779 signed char val = mat1_roi.at<signed char>(i, j);
780 unsigned char m = mask_roi.at<unsigned char>(i , j);
781 if (val < minVal && m)
787 if (val > maxVal && m)
796 double minVal_, maxVal_;
797 cv::Point minLoc_, maxLoc_;
798 cv::ocl::minMaxLoc(gmat1, &minVal_, &maxVal_, &minLoc_, &maxLoc_, gmask);
800 double error0 = 0., error1 = 0., minlocVal = 0., minlocVal_ = 0., maxlocVal = 0., maxlocVal_ = 0.;
801 if(minLoc_.x == -1 || minLoc_.y == -1 || maxLoc_.x == -1 || maxLoc_.y == -1) continue;
804 minlocVal = mat1_roi.at<unsigned char>(minLoc);
805 minlocVal_ = mat1_roi.at<unsigned char>(minLoc_);
806 maxlocVal = mat1_roi.at<unsigned char>(maxLoc);
807 maxlocVal_ = mat1_roi.at<unsigned char>(maxLoc_);
808 error0 = ::abs(mat1_roi.at<unsigned char>(minLoc_) - mat1_roi.at<unsigned char>(minLoc));
809 error1 = ::abs(mat1_roi.at<unsigned char>(maxLoc_) - mat1_roi.at<unsigned char>(maxLoc));
813 minlocVal = mat1_roi.at<signed char>(minLoc);
814 minlocVal_ = mat1_roi.at<signed char>(minLoc_);
815 maxlocVal = mat1_roi.at<signed char>(maxLoc);
816 maxlocVal_ = mat1_roi.at<signed char>(maxLoc_);
817 error0 = ::abs(mat1_roi.at<signed char>(minLoc_) - mat1_roi.at<signed char>(minLoc));
818 error1 = ::abs(mat1_roi.at<signed char>(maxLoc_) - mat1_roi.at<signed char>(maxLoc));
822 minlocVal = mat1_roi.at<unsigned short>(minLoc);
823 minlocVal_ = mat1_roi.at<unsigned short>(minLoc_);
824 maxlocVal = mat1_roi.at<unsigned short>(maxLoc);
825 maxlocVal_ = mat1_roi.at<unsigned short>(maxLoc_);
826 error0 = ::abs(mat1_roi.at<unsigned short>(minLoc_) - mat1_roi.at<unsigned short>(minLoc));
827 error1 = ::abs(mat1_roi.at<unsigned short>(maxLoc_) - mat1_roi.at<unsigned short>(maxLoc));
831 minlocVal = mat1_roi.at<signed short>(minLoc);
832 minlocVal_ = mat1_roi.at<signed short>(minLoc_);
833 maxlocVal = mat1_roi.at<signed short>(maxLoc);
834 maxlocVal_ = mat1_roi.at<signed short>(maxLoc_);
835 error0 = ::abs(mat1_roi.at<signed short>(minLoc_) - mat1_roi.at<signed short>(minLoc));
836 error1 = ::abs(mat1_roi.at<signed short>(maxLoc_) - mat1_roi.at<signed short>(maxLoc));
840 minlocVal = mat1_roi.at<int>(minLoc);
841 minlocVal_ = mat1_roi.at<int>(minLoc_);
842 maxlocVal = mat1_roi.at<int>(maxLoc);
843 maxlocVal_ = mat1_roi.at<int>(maxLoc_);
844 error0 = ::abs(mat1_roi.at<int>(minLoc_) - mat1_roi.at<int>(minLoc));
845 error1 = ::abs(mat1_roi.at<int>(maxLoc_) - mat1_roi.at<int>(maxLoc));
849 minlocVal = mat1_roi.at<float>(minLoc);
850 minlocVal_ = mat1_roi.at<float>(minLoc_);
851 maxlocVal = mat1_roi.at<float>(maxLoc);
852 maxlocVal_ = mat1_roi.at<float>(maxLoc_);
853 error0 = ::abs(mat1_roi.at<float>(minLoc_) - mat1_roi.at<float>(minLoc));
854 error1 = ::abs(mat1_roi.at<float>(maxLoc_) - mat1_roi.at<float>(maxLoc));
858 minlocVal = mat1_roi.at<double>(minLoc);
859 minlocVal_ = mat1_roi.at<double>(minLoc_);
860 maxlocVal = mat1_roi.at<double>(maxLoc);
861 maxlocVal_ = mat1_roi.at<double>(maxLoc_);
862 error0 = ::abs(mat1_roi.at<double>(minLoc_) - mat1_roi.at<double>(minLoc));
863 error1 = ::abs(mat1_roi.at<double>(maxLoc_) - mat1_roi.at<double>(maxLoc));
866 EXPECT_DOUBLE_EQ(minVal_, minVal);
867 EXPECT_DOUBLE_EQ(maxVal_, maxVal);
868 EXPECT_DOUBLE_EQ(minlocVal_, minlocVal);
869 EXPECT_DOUBLE_EQ(maxlocVal_, maxlocVal);
871 EXPECT_DOUBLE_EQ(error0, 0.0);
872 EXPECT_DOUBLE_EQ(error1, 0.0);
877 struct Sum : ArithmTestBase {};
881 for(int j = 0; j < LOOP_TIMES; j++)
884 Scalar cpures = cv::sum(mat1_roi);
885 Scalar gpures = cv::ocl::sum(gmat1);
888 EXPECT_NEAR(cpures[0], gpures[0], 0.1);
889 EXPECT_NEAR(cpures[1], gpures[1], 0.1);
890 EXPECT_NEAR(cpures[2], gpures[2], 0.1);
891 EXPECT_NEAR(cpures[3], gpures[3], 0.1);
896 struct CountNonZero : ArithmTestBase {};
898 TEST_P(CountNonZero, MAT)
900 for(int j = 0; j < LOOP_TIMES; j++)
903 int cpures = cv::countNonZero(mat1_roi);
904 int gpures = cv::ocl::countNonZero(gmat1);
906 EXPECT_DOUBLE_EQ((double)cpures, (double)gpures);
912 ////////////////////////////////phase/////////////////////////////////////////////////
913 struct Phase : ArithmTestBase {};
917 if(mat1.depth() != CV_32F && mat1.depth() != CV_64F)
919 cout << "\tUnsupported type\t\n";
921 for(int angelInDegrees = 0; angelInDegrees < 2; angelInDegrees++)
923 for(int j = 0; j < LOOP_TIMES; j++)
926 cv::phase(mat1_roi, mat2_roi, dst_roi, angelInDegrees ? true : false);
927 cv::ocl::phase(gmat1, gmat2, gdst, angelInDegrees ? true : false);
934 ////////////////////////////////bitwise_and/////////////////////////////////////////////////
935 struct Bitwise_and : ArithmTestBase {};
937 TEST_P(Bitwise_and, Mat)
939 for(int j = 0; j < LOOP_TIMES; j++)
943 cv::bitwise_and(mat1_roi, mat2_roi, dst_roi);
944 cv::ocl::bitwise_and(gmat1, gmat2, gdst);
949 TEST_P(Bitwise_and, Mat_Mask)
951 for(int j = 0; j < LOOP_TIMES; j++)
955 cv::bitwise_and(mat1_roi, mat2_roi, dst_roi, mask_roi);
956 cv::ocl::bitwise_and(gmat1, gmat2, gdst, gmask);
961 TEST_P(Bitwise_and, Scalar)
963 for(int j = 0; j < LOOP_TIMES; j++)
967 cv::bitwise_and(mat1_roi, val, dst_roi);
968 cv::ocl::bitwise_and(gmat1, val, gdst);
973 TEST_P(Bitwise_and, Scalar_Mask)
975 for(int j = 0; j < LOOP_TIMES; j++)
979 cv::bitwise_and(mat1_roi, val, dst_roi, mask_roi);
980 cv::ocl::bitwise_and(gmat1, val, gdst, gmask);
987 ////////////////////////////////bitwise_or/////////////////////////////////////////////////
989 struct Bitwise_or : ArithmTestBase {};
991 TEST_P(Bitwise_or, Mat)
993 for(int j = 0; j < LOOP_TIMES; j++)
997 cv::bitwise_or(mat1_roi, mat2_roi, dst_roi);
998 cv::ocl::bitwise_or(gmat1, gmat2, gdst);
1003 TEST_P(Bitwise_or, Mat_Mask)
1005 for(int j = 0; j < LOOP_TIMES; j++)
1009 cv::bitwise_or(mat1_roi, mat2_roi, dst_roi, mask_roi);
1010 cv::ocl::bitwise_or(gmat1, gmat2, gdst, gmask);
1015 TEST_P(Bitwise_or, Scalar)
1017 for(int j = 0; j < LOOP_TIMES; j++)
1021 cv::bitwise_or(mat1_roi, val, dst_roi);
1022 cv::ocl::bitwise_or(gmat1, val, gdst);
1027 TEST_P(Bitwise_or, Scalar_Mask)
1029 for(int j = 0; j < LOOP_TIMES; j++)
1033 cv::bitwise_or(mat1_roi, val, dst_roi, mask_roi);
1034 cv::ocl::bitwise_or(gmat1, val, gdst, gmask);
1041 ////////////////////////////////bitwise_xor/////////////////////////////////////////////////
1043 struct Bitwise_xor : ArithmTestBase {};
1045 TEST_P(Bitwise_xor, Mat)
1047 for(int j = 0; j < LOOP_TIMES; j++)
1051 cv::bitwise_xor(mat1_roi, mat2_roi, dst_roi);
1052 cv::ocl::bitwise_xor(gmat1, gmat2, gdst);
1057 TEST_P(Bitwise_xor, Mat_Mask)
1059 for(int j = 0; j < LOOP_TIMES; j++)
1063 cv::bitwise_xor(mat1_roi, mat2_roi, dst_roi, mask_roi);
1064 cv::ocl::bitwise_xor(gmat1, gmat2, gdst, gmask);
1069 TEST_P(Bitwise_xor, Scalar)
1071 for(int j = 0; j < LOOP_TIMES; j++)
1075 cv::bitwise_xor(mat1_roi, val, dst_roi);
1076 cv::ocl::bitwise_xor(gmat1, val, gdst);
1081 TEST_P(Bitwise_xor, Scalar_Mask)
1083 for(int j = 0; j < LOOP_TIMES; j++)
1087 cv::bitwise_xor(mat1_roi, val, dst_roi, mask_roi);
1088 cv::ocl::bitwise_xor(gmat1, val, gdst, gmask);
1094 ////////////////////////////////bitwise_not/////////////////////////////////////////////////
1096 struct Bitwise_not : ArithmTestBase {};
1098 TEST_P(Bitwise_not, Mat)
1100 for(int j = 0; j < LOOP_TIMES; j++)
1104 cv::bitwise_not(mat1_roi, dst_roi);
1105 cv::ocl::bitwise_not(gmat1, gdst);
1111 ////////////////////////////////compare/////////////////////////////////////////////////
1112 struct Compare : ArithmTestBase {};
1114 TEST_P(Compare, Mat)
1116 if(mat1.type() == CV_8SC1)
1117 //if(mat1.type() != CV_8UC1 || mat1.type()!= CV_16UC1 || mat1.type()!= CV_16SC1|| mat1.type()!= CV_32SC1 || mat1.type()!= CV_32FC1|| mat1.type()!= CV_64FC1)
1119 cout << "\tUnsupported type\t\n";
1122 int cmp_codes[] = {CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE};
1123 //const char *cmp_str[] = {"CMP_EQ", "CMP_GT", "CMP_GE", "CMP_LT", "CMP_LE", "CMP_NE"};
1124 int cmp_num = sizeof(cmp_codes) / sizeof(int);
1126 for (int i = 0; i < cmp_num; ++i)
1129 for(int j = 0; j < LOOP_TIMES; j++)
1133 cv::compare(mat1_roi, mat2_roi, dst_roi, cmp_codes[i]);
1134 cv::ocl::compare(gmat1, gmat2, gdst, cmp_codes[i]);
1142 struct Pow : ArithmTestBase {};
1146 if(mat1.depth() != CV_32F && mat1.depth() != CV_64F)
1148 cout << "\tUnsupported type\t\n";
1151 for(int j = 0; j < LOOP_TIMES; j++)
1155 cv::pow(mat1_roi, p, dst_roi);
1156 cv::ocl::pow(gmat1, p, gdst);
1162 struct MagnitudeSqr : ArithmTestBase {};
1164 TEST_P(MagnitudeSqr, Mat)
1166 for(int j = 0; j < LOOP_TIMES; j++)
1169 for(int i = 0; i < mat1.rows; ++i)
1170 for(int j = 0; j < mat1.cols; ++j)
1172 float val1 = mat1.at<float>(i, j);
1173 float val2 = mat2.at<float>(i, j);
1174 ((float *)(dst.data))[i * dst.step / 4 + j] = val1 * val1 + val2 * val2;
1177 cv::ocl::oclMat clmat1(mat1), clmat2(mat2);
1178 cv::ocl::magnitudeSqr(clmat1, clmat2, gdst);
1184 struct AddWeighted : ArithmTestBase {};
1186 TEST_P(AddWeighted, Mat)
1188 for(int j = 0; j < LOOP_TIMES; j++)
1191 double alpha = 2.0, beta = 1.0, gama = 3.0;
1194 cv::addWeighted(mat1_roi, alpha, mat2_roi, beta, gama, dst_roi);
1196 // cv::ocl::oclMat clmat1(mat1),clmat2(mat2),cldst;
1198 cv::ocl::addWeighted(gmat1, alpha, gmat2, beta, gama, gdst);
1207 //********test****************
1209 INSTANTIATE_TEST_CASE_P(Arithm, Lut, Combine(
1210 Values(CV_8UC1, CV_8UC3, CV_8UC4),
1211 Values(false))); // Values(false) is the reserved parameter
1213 INSTANTIATE_TEST_CASE_P(Arithm, Exp, Combine(
1214 Values(CV_32FC1, CV_32FC1),
1215 Values(false))); // Values(false) is the reserved parameter
1217 INSTANTIATE_TEST_CASE_P(Arithm, Log, Combine(
1218 Values(CV_32FC1, CV_32FC1),
1219 Values(false))); // Values(false) is the reserved parameter
1221 INSTANTIATE_TEST_CASE_P(Arithm, Add, Combine(
1222 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1225 INSTANTIATE_TEST_CASE_P(Arithm, Sub, Combine(
1226 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1229 INSTANTIATE_TEST_CASE_P(Arithm, Mul, Combine(
1230 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1231 Values(false))); // Values(false) is the reserved parameter
1233 INSTANTIATE_TEST_CASE_P(Arithm, Div, Combine(
1234 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1235 Values(false))); // Values(false) is the reserved parameter
1238 INSTANTIATE_TEST_CASE_P(Arithm, Absdiff, Combine(
1239 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1240 Values(false))); // Values(false) is the reserved parameter
1242 INSTANTIATE_TEST_CASE_P(Arithm, CartToPolar, Combine(
1243 Values(CV_32FC1, CV_32FC3, CV_32FC4),
1244 Values(false))); // Values(false) is the reserved parameter
1246 INSTANTIATE_TEST_CASE_P(Arithm, PolarToCart, Combine(
1247 Values(CV_32FC1, CV_32FC3, CV_32FC4),
1248 Values(false))); // Values(false) is the reserved parameter
1250 INSTANTIATE_TEST_CASE_P(Arithm, Magnitude, Combine(
1251 Values(CV_32FC1, CV_32FC3, CV_32FC4),
1252 Values(false))); // Values(false) is the reserved parameter
1254 INSTANTIATE_TEST_CASE_P(Arithm, Transpose, Combine(
1255 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32FC1),
1256 Values(false))); // Values(false) is the reserved parameter
1258 INSTANTIATE_TEST_CASE_P(Arithm, Flip, Combine(
1259 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1260 Values(false))); // Values(false) is the reserved parameter
1262 INSTANTIATE_TEST_CASE_P(Arithm, MinMax, Combine(
1263 Values(CV_8UC1, CV_32SC1, CV_32FC1),
1266 INSTANTIATE_TEST_CASE_P(Arithm, MinMaxLoc, Combine(
1267 Values(CV_8UC1, CV_32SC1, CV_32FC1),
1270 INSTANTIATE_TEST_CASE_P(Arithm, Sum, Combine(
1271 Values(CV_8U, CV_32S, CV_32F),
1274 INSTANTIATE_TEST_CASE_P(Arithm, CountNonZero, Combine(
1275 Values(CV_8U, CV_32S, CV_32F),
1279 INSTANTIATE_TEST_CASE_P(Arithm, Phase, Combine(Values(CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1280 // Values(false) is the reserved parameter
1283 INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_and, Combine(
1284 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1285 //Values(false) is the reserved parameter
1287 INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_or, Combine(
1288 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1289 //Values(false) is the reserved parameter
1291 INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_xor, Combine(
1292 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1293 //Values(false) is the reserved parameter
1295 INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_not, Combine(
1296 Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1297 //Values(false) is the reserved parameter
1299 INSTANTIATE_TEST_CASE_P(Arithm, Compare, Combine(Values(CV_8UC1, CV_32SC1, CV_32FC1), Values(false)));
1300 // Values(false) is the reserved parameter
1302 INSTANTIATE_TEST_CASE_P(Arithm, Pow, Combine(Values(CV_32FC1, CV_32FC3, CV_32FC4), Values(false)));
1303 // Values(false) is the reserved parameter
1305 INSTANTIATE_TEST_CASE_P(Arithm, MagnitudeSqr, Combine(
1306 Values(CV_32FC1, CV_32FC1),
1307 Values(false))); // Values(false) is the reserved parameter
1309 INSTANTIATE_TEST_CASE_P(Arithm, AddWeighted, Combine(
1310 Values(CV_8UC1, CV_32SC1, CV_32FC1),
1311 Values(false))); // Values(false) is the reserved parameter
1315 #endif // HAVE_OPENCL