From 4a81be7d0b320e176d43d1653993e677657e3868 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Fri, 18 Oct 2013 16:29:10 +0400 Subject: [PATCH] refactored all the tests in ocl/test/test_imgproc.cpp --- modules/ocl/test/test_imgproc.cpp | 1695 ++++++---------------------------- modules/ocl/test/test_mean_shift.cpp | 408 ++++++++ modules/ocl/test/test_warp.cpp | 369 ++++++++ 3 files changed, 1069 insertions(+), 1403 deletions(-) create mode 100644 modules/ocl/test/test_mean_shift.cpp create mode 100644 modules/ocl/test/test_warp.cpp diff --git a/modules/ocl/test/test_imgproc.cpp b/modules/ocl/test/test_imgproc.cpp index bbd9846..fa7a70f 100644 --- a/modules/ocl/test/test_imgproc.cpp +++ b/modules/ocl/test/test_imgproc.cpp @@ -55,1603 +55,492 @@ #ifdef HAVE_OPENCL -using namespace cv; -using namespace std; using namespace testing; +using namespace std; +using namespace cv; -MatType nulltype = -1; - -#define ONE_TYPE(type) testing::ValuesIn(typeVector(type)) -#define NULL_TYPE testing::ValuesIn(typeVector(nulltype)) - -vector typeVector(MatType type) -{ - vector v; - v.push_back(type); - return v; -} - -typedef struct -{ - short x; - short y; -} COOR; +/////////////////////////////////////////////////////////////////////////////// -COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, Size size, int sp, int sr, int maxIter, float eps, int *tab) +PARAM_TEST_CASE(ImgprocTestBase, MatType, + int, // blockSize + int, // border type + bool) // roi or not { + int type, borderType, blockSize; + bool useRoi; - int isr2 = sr * sr; - int c0, c1, c2, c3; - int iter; - uchar *ptr = NULL; - uchar *pstart = NULL; - int revx = 0, revy = 0; - c0 = sptr[0]; - c1 = sptr[1]; - c2 = sptr[2]; - c3 = sptr[3]; - // iterate meanshift procedure - for(iter = 0; iter < maxIter; iter++ ) - { - int count = 0; - int s0 = 0, s1 = 0, s2 = 0, sx = 0, sy = 0; - - //mean shift: process pixels in window (p-sigmaSp)x(p+sigmaSp) - int minx = x0 - sp; - int miny = y0 - sp; - int maxx = x0 + sp; - int maxy = y0 + sp; - - //deal with the image boundary - if(minx < 0) minx = 0; - if(miny < 0) miny = 0; - if(maxx >= size.width) maxx = size.width - 1; - if(maxy >= size.height) maxy = size.height - 1; - if(iter == 0) - { - pstart = sptr; - } - else - { - pstart = pstart + revy * sstep + (revx << 2); //point to the new position - } - ptr = pstart; - ptr = ptr + (miny - y0) * sstep + ((minx - x0) << 2); //point to the start in the row + Mat src, dst_whole, src_roi, dst_roi; + ocl::oclMat gsrc_whole, gsrc_roi, gdst_whole, gdst_roi; - for( int y = miny; y <= maxy; y++, ptr += sstep - ((maxx - minx + 1) << 2)) - { - int rowCount = 0; - int x = minx; -#if CV_ENABLE_UNROLLED - for( ; x + 4 <= maxx; x += 4, ptr += 16) - { - int t0, t1, t2; - t0 = ptr[0], t1 = ptr[1], t2 = ptr[2]; - if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) - { - s0 += t0; - s1 += t1; - s2 += t2; - sx += x; - rowCount++; - } - t0 = ptr[4], t1 = ptr[5], t2 = ptr[6]; - if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) - { - s0 += t0; - s1 += t1; - s2 += t2; - sx += x + 1; - rowCount++; - } - t0 = ptr[8], t1 = ptr[9], t2 = ptr[10]; - if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) - { - s0 += t0; - s1 += t1; - s2 += t2; - sx += x + 2; - rowCount++; - } - t0 = ptr[12], t1 = ptr[13], t2 = ptr[14]; - if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) - { - s0 += t0; - s1 += t1; - s2 += t2; - sx += x + 3; - rowCount++; - } - } -#endif - for(; x <= maxx; x++, ptr += 4) - { - int t0 = ptr[0], t1 = ptr[1], t2 = ptr[2]; - if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) - { - s0 += t0; - s1 += t1; - s2 += t2; - sx += x; - rowCount++; - } - } - if(rowCount == 0) - continue; - count += rowCount; - sy += y * rowCount; - } - - if( count == 0 ) - break; - - int x1 = sx / count; - int y1 = sy / count; - s0 = s0 / count; - s1 = s1 / count; - s2 = s2 / count; - - bool stopFlag = (x0 == x1 && y0 == y1) || (abs(x1 - x0) + abs(y1 - y0) + - tab[s0 - c0 + 255] + tab[s1 - c1 + 255] + tab[s2 - c2 + 255] <= eps); - - //revise the pointer corresponding to the new (y0,x0) - revx = x1 - x0; - revy = y1 - y0; - - x0 = x1; - y0 = y1; - c0 = s0; - c1 = s1; - c2 = s2; - - if( stopFlag ) - break; - } //for iter - - dptr[0] = (uchar)c0; - dptr[1] = (uchar)c1; - dptr[2] = (uchar)c2; - dptr[3] = (uchar)c3; - - COOR coor; - coor.x = (short)x0; - coor.y = (short)y0; - return coor; -} - -void meanShiftFiltering_(const Mat &src_roi, Mat &dst_roi, int sp, int sr, TermCriteria crit) -{ - if( src_roi.empty() ) - CV_Error( CV_StsBadArg, "The input image is empty" ); - - if( src_roi.depth() != CV_8U || src_roi.channels() != 4 ) - CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" ); - - CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) ); - CV_Assert( !(dst_roi.step & 0x3) ); - - if( !(crit.type & TermCriteria::MAX_ITER) ) - crit.maxCount = 5; - int maxIter = std::min(std::max(crit.maxCount, 1), 100); - float eps; - if( !(crit.type & TermCriteria::EPS) ) - eps = 1.f; - eps = (float)std::max(crit.epsilon, 0.0); - - int tab[512]; - for(int i = 0; i < 512; i++) - tab[i] = (i - 255) * (i - 255); - uchar *sptr = src_roi.data; - uchar *dptr = dst_roi.data; - int sstep = (int)src_roi.step; - int dstep = (int)dst_roi.step; - Size size = src_roi.size(); - - for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2), - dptr += dstep - (size.width << 2)) + virtual void SetUp() { - for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4) - { - do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab); - } + type = GET_PARAM(0); + blockSize = GET_PARAM(1); + borderType = GET_PARAM(2); + useRoi = GET_PARAM(3); } -} - -void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, int sr, TermCriteria crit) -{ - if( src_roi.empty() ) - CV_Error( CV_StsBadArg, "The input image is empty" ); - if( src_roi.depth() != CV_8U || src_roi.channels() != 4 ) - CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" ); - CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) && - (src_roi.cols == dstCoor_roi.cols) && (src_roi.rows == dstCoor_roi.rows)); - CV_Assert( !(dstCoor_roi.step & 0x3) ); - - if( !(crit.type & TermCriteria::MAX_ITER) ) - crit.maxCount = 5; - int maxIter = std::min(std::max(crit.maxCount, 1), 100); - float eps; - if( !(crit.type & TermCriteria::EPS) ) - eps = 1.f; - eps = (float)std::max(crit.epsilon, 0.0); - - int tab[512]; - for(int i = 0; i < 512; i++) - tab[i] = (i - 255) * (i - 255); - uchar *sptr = src_roi.data; - uchar *dptr = dst_roi.data; - short *dCoorptr = (short *)dstCoor_roi.data; - int sstep = (int)src_roi.step; - int dstep = (int)dst_roi.step; - int dCoorstep = (int)dstCoor_roi.step >> 1; - Size size = src_roi.size(); - - for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2), - dptr += dstep - (size.width << 2), dCoorptr += dCoorstep - (size.width << 1)) + void random_roi() { - for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4, dCoorptr += 2) - { - *((COOR *)dCoorptr) = do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab); - } - } + Size roiSize = randomSize(1, MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, roiSize, srcBorder, type, 5, 256); -} + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, type, 5, 16); -PARAM_TEST_CASE(ImgprocTestBase, MatType, MatType, MatType, MatType, MatType, bool) -{ - int type1, type2, type3, type4, type5; - Scalar val; - // set up roi - int roicols; - int roirows; - int src1x; - int src1y; - int src2x; - int src2y; - int dstx; - int dsty; - int dst1x; - int dst1y; - int maskx; - int masky; - - //mat - Mat mat1; - Mat mat2; - Mat mask; - Mat dst; - Mat dst1; //bak, for two outputs - - //mat with roi - Mat mat1_roi; - Mat mat2_roi; - Mat mask_roi; - Mat dst_roi; - Mat dst1_roi; //bak - - //ocl mat - ocl::oclMat clmat1; - ocl::oclMat clmat2; - ocl::oclMat clmask; - ocl::oclMat cldst; - ocl::oclMat cldst1; //bak - - //ocl mat with roi - ocl::oclMat clmat1_roi; - ocl::oclMat clmat2_roi; - ocl::oclMat clmask_roi; - ocl::oclMat cldst_roi; - ocl::oclMat cldst1_roi; - - virtual void SetUp() - { - type1 = GET_PARAM(0); - type2 = GET_PARAM(1); - type3 = GET_PARAM(2); - type4 = GET_PARAM(3); - type5 = GET_PARAM(4); - Size size(MWIDTH, MHEIGHT); - double min = 1, max = 20; - - if(type1 != nulltype) - { - mat1 = randomMat(size, type1, min, max, false); - clmat1 = mat1; - } - if(type2 != nulltype) - { - mat2 = randomMat(size, type2, min, max, false); - clmat2 = mat2; - } - if(type3 != nulltype) - { - dst = randomMat(size, type3, min, max, false); - cldst = dst; - } - if(type4 != nulltype) - { - dst1 = randomMat(size, type4, min, max, false); - cldst1 = dst1; - } - if(type5 != nulltype) - { - mask = randomMat(size, CV_8UC1, 0, 2, false); - threshold(mask, mask, 0.5, 255., type5); - clmask = mask; - } - val = 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)); + generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder); + generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder); } - void random_roi() + void Near(double threshold = 0.0) { -#ifdef RANDOMROI - //randomize ROI - roicols = rng.uniform(1, mat1.cols); - roirows = rng.uniform(1, mat1.rows); - src1x = rng.uniform(0, mat1.cols - roicols); - src1y = rng.uniform(0, mat1.rows - roirows); - src2x = rng.uniform(0, mat2.cols - roicols); - src2y = rng.uniform(0, mat2.rows - roirows); - dstx = rng.uniform(0, dst.cols - roicols); - dsty = rng.uniform(0, dst.rows - roirows); - dst1x = rng.uniform(0, dst1.cols - roicols); - dst1y = rng.uniform(0, dst1.rows - roirows); - maskx = rng.uniform(0, mask.cols - roicols); - masky = rng.uniform(0, mask.rows - roirows); -#else - roicols = mat1.cols; - roirows = mat1.rows; - src1x = 0; - src1y = 0; - src2x = 0; - src2y = 0; - dstx = 0; - dsty = 0; - dst1x = 0; - dst1y = 0; - maskx = 0; - masky = 0; -#endif - - - if(type1 != nulltype) - { - mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows)); - clmat1_roi = clmat1(Rect(src1x, src1y, roicols, roirows)); - } - if(type2 != nulltype) - { - mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows)); - clmat2_roi = clmat2(Rect(src2x, src2y, roicols, roirows)); - } - if(type3 != nulltype) - { - dst_roi = dst(Rect(dstx, dsty, roicols, roirows)); - cldst_roi = cldst(Rect(dstx, dsty, roicols, roirows)); - } - if(type4 != nulltype) - { - dst1_roi = dst1(Rect(dst1x, dst1y, roicols, roirows)); - cldst1_roi = cldst1(Rect(dst1x, dst1y, roicols, roirows)); - } - if(type5 != nulltype) - { - mask_roi = mask(Rect(maskx, masky, roicols, roirows)); - clmask_roi = clmask(Rect(maskx, masky, roicols, roirows)); - } - } + Mat whole, roi; + gdst_whole.download(whole); + gdst_roi.download(roi); - void Near(double threshold) - { - Mat cpu_cldst; - cldst.download(cpu_cldst); - EXPECT_MAT_NEAR(dst, cpu_cldst, threshold); + EXPECT_MAT_NEAR(dst_whole, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); } }; -////////////////////////////////equalizeHist////////////////////////////////////////// - -typedef ImgprocTestBase EqualizeHist; - -OCL_TEST_P(EqualizeHist, Mat) -{ - if (mat1.type() != CV_8UC1 || mat1.type() != dst.type()) - { - cout << "Unsupported type" << endl; - EXPECT_DOUBLE_EQ(0.0, 0.0); - } - else - { - for(int j = 0; j < LOOP_TIMES; j++) - { - random_roi(); - equalizeHist(mat1_roi, dst_roi); - ocl::equalizeHist(clmat1_roi, cldst_roi); - Near(1.1); - } - } -} - ////////////////////////////////copyMakeBorder//////////////////////////////////////////// -typedef ImgprocTestBase CopyMakeBorder; - -OCL_TEST_P(CopyMakeBorder, Mat) +PARAM_TEST_CASE(CopyMakeBorder, MatDepth, // depth + Channels, // channels + bool, // isolated or not + Border, // border type + bool) // roi or not { - int bordertype[] = {BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT, BORDER_WRAP, BORDER_REFLECT_101}; - int top = rng.uniform(0, 10); - int bottom = rng.uniform(0, 10); - int left = rng.uniform(0, 10); - int right = rng.uniform(0, 10); - if (mat1.type() != dst.type()) - { - cout << "Unsupported type" << endl; - EXPECT_DOUBLE_EQ(0.0, 0.0); - } - else - { - for(size_t i = 0; i < sizeof(bordertype) / sizeof(int); i++) - for(int j = 0; j < LOOP_TIMES; j++) - { - random_roi(); -#ifdef RANDOMROI - if(((bordertype[i] != BORDER_CONSTANT) && (bordertype[i] != BORDER_REPLICATE)) && (mat1_roi.cols <= left) || (mat1_roi.cols <= right) || (mat1_roi.rows <= top) || (mat1_roi.rows <= bottom)) - { - continue; - } - if((dstx >= left) && (dsty >= top) && (dstx + cldst_roi.cols + right <= cldst_roi.wholecols) && (dsty + cldst_roi.rows + bottom <= cldst_roi.wholerows)) - { - dst_roi.adjustROI(top, bottom, left, right); - cldst_roi.adjustROI(top, bottom, left, right); - } - else - { - continue; - } -#endif - cv::copyMakeBorder(mat1_roi, dst_roi, top, bottom, left, right, bordertype[i] | BORDER_ISOLATED, Scalar(1.0)); - ocl::copyMakeBorder(clmat1_roi, cldst_roi, top, bottom, left, right, bordertype[i] | BORDER_ISOLATED, Scalar(1.0)); - - Mat cpu_cldst; -#ifndef RANDOMROI - cldst_roi.download(cpu_cldst); - EXPECT_MAT_NEAR(dst_roi, cpu_cldst, 0.0); -#else - cldst.download(cpu_cldst); - EXPECT_MAT_NEAR(dst, cpu_cldst, 0.0); -#endif - - } - } -} - + int type, borderType; + bool useRoi; + Border border; + Scalar val; -////////////////////////////////cornerMinEigenVal////////////////////////////////////////// - -struct CornerMinEigenVal : ImgprocTestBase {}; + Mat src, dst_whole, src_roi, dst_roi; + ocl::oclMat gsrc_whole, gsrc_roi, gdst_whole, gdst_roi; -OCL_TEST_P(CornerMinEigenVal, Mat) -{ - for(int j = 0; j < LOOP_TIMES; j++) + virtual void SetUp() { + type = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1)); + borderType = GET_PARAM(3); - random_roi(); - int blockSize = 3, apertureSize = 3;//1 + 2 * (rand() % 4); - //int borderType = BORDER_CONSTANT; - //int borderType = BORDER_REPLICATE; - int borderType = BORDER_REFLECT; - cornerMinEigenVal(mat1_roi, dst_roi, blockSize, apertureSize, borderType); - ocl::cornerMinEigenVal(clmat1_roi, cldst_roi, blockSize, apertureSize, borderType); - Near(1.); - } -} + if (GET_PARAM(2)) + borderType |= BORDER_ISOLATED; - - -////////////////////////////////cornerHarris////////////////////////////////////////// - -typedef ImgprocTestBase CornerHarris; - -OCL_TEST_P(CornerHarris, Mat) -{ - for(int j = 0; j < LOOP_TIMES; j++) - { - - random_roi(); - int blockSize = 3, apertureSize = 3; //1 + 2 * (rand() % 4); - double k = 2; - //int borderType = BORDER_CONSTANT; - //int borderType = BORDER_REPLICATE; - int borderType = BORDER_REFLECT; - cornerHarris(mat1_roi, dst_roi, blockSize, apertureSize, k, borderType); - ocl::cornerHarris(clmat1_roi, cldst_roi, blockSize, apertureSize, k, borderType); - Near(1.); + useRoi = GET_PARAM(4); } -} - -////////////////////////////////integral///////////////////////////////////////////////// - -typedef ImgprocTestBase Integral; - -OCL_TEST_P(Integral, Mat1) -{ - for(int j = 0; j < LOOP_TIMES; j++) + void random_roi() { - random_roi(); + Size roiSize = randomSize(1, MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, roiSize, srcBorder, type, 5, 256); - ocl::integral(clmat1_roi, cldst_roi); - integral(mat1_roi, dst_roi); - Near(0); - } -} - -OCL_TEST_P(Integral, Mat2) -{ - for(int j = 0; j < LOOP_TIMES; j++) - { - random_roi(); + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, type, 5, 16); - ocl::integral(clmat1_roi, cldst_roi, cldst1_roi); - integral(mat1_roi, dst_roi, dst1_roi); - Near(0); + generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder); + generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder); - Mat cpu_cldst1; - cldst1.download(cpu_cldst1); - EXPECT_MAT_NEAR(dst1, cpu_cldst1, 0.0); + border = randomBorder(0, 10); + val = randomScalar(-MAX_VALUE, MAX_VALUE); } -} - - -///////////////////////////////////////////////////////////////////////////////////////////////// -// warpAffine & warpPerspective - -PARAM_TEST_CASE(WarpTestBase, MatType, int) -{ - int type; - Size size; - int interpolation; - - //src mat - Mat mat1; - Mat dst; - // set up roi - int src_roicols; - int src_roirows; - int dst_roicols; - int dst_roirows; - int src1x; - int src1y; - int dstx; - int dsty; - - - //src mat with roi - Mat mat1_roi; - Mat dst_roi; - - //ocl dst mat for testing - ocl::oclMat gdst_whole; - - //ocl mat with roi - ocl::oclMat gmat1; - ocl::oclMat gdst; - - virtual void SetUp() + void Near(double threshold = 0.0) { - type = GET_PARAM(0); - interpolation = GET_PARAM(1); - size = Size(MWIDTH, MHEIGHT); - - mat1 = randomMat(size, type, 5, 16, false); - dst = randomMat(size, type, 5, 16, false); - } + Mat whole, roi; + gdst_whole.download(whole); + gdst_roi.download(roi); - void random_roi() - { -#ifdef RANDOMROI - //randomize ROI - src_roicols = rng.uniform(1, mat1.cols); - src_roirows = rng.uniform(1, mat1.rows); - dst_roicols = rng.uniform(1, dst.cols); - dst_roirows = rng.uniform(1, dst.rows); - src1x = rng.uniform(0, mat1.cols - src_roicols); - src1y = rng.uniform(0, mat1.rows - src_roirows); - dstx = rng.uniform(0, dst.cols - dst_roicols); - dsty = rng.uniform(0, dst.rows - dst_roirows); -#else - src_roicols = mat1.cols; - src_roirows = mat1.rows; - dst_roicols = dst.cols; - dst_roirows = dst.rows; - src1x = 0; - src1y = 0; - dstx = 0; - dsty = 0; -#endif - - - mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows)); - dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows)); - - gdst_whole = dst; - gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows)); - - - gmat1 = mat1_roi; + EXPECT_MAT_NEAR(dst_whole, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); } - }; -/////warpAffine - -typedef WarpTestBase WarpAffine; - -OCL_TEST_P(WarpAffine, Mat) +OCL_TEST_P(CopyMakeBorder, Mat) { - static const double coeffs[2][3] = - { - {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0}, - {sin(CV_PI / 6), cos(CV_PI / 6), -100.0} - }; - Mat M(2, 3, CV_64F, (void *)coeffs); - - for(int j = 0; j < LOOP_TIMES; j++) + for (int i = 0; i < LOOP_TIMES; ++i) { random_roi(); - warpAffine(mat1_roi, dst_roi, M, size, interpolation); - ocl::warpAffine(gmat1, gdst, M, size, interpolation); + cv::copyMakeBorder(src_roi, dst_roi, border.top, border.bot, border.lef, border.rig, borderType, val); + ocl::copyMakeBorder(gsrc_roi, gdst_roi, border.top, border.bot, border.lef, border.rig, borderType, val); - Mat cpu_dst; - gdst_whole.download(cpu_dst); - EXPECT_MAT_NEAR(dst, cpu_dst, 1.0); + Near(); } - } +////////////////////////////////equalizeHist////////////////////////////////////////////// -// warpPerspective - -typedef WarpTestBase WarpPerspective; +typedef ImgprocTestBase EqualizeHist; -OCL_TEST_P(WarpPerspective, Mat) +OCL_TEST_P(EqualizeHist, Mat) { - static const double coeffs[3][3] = - { - {cos(3.14 / 6), -sin(3.14 / 6), 100.0}, - {sin(3.14 / 6), cos(3.14 / 6), -100.0}, - {0.0, 0.0, 1.0} - }; - Mat M(3, 3, CV_64F, (void *)coeffs); - - for(int j = 0; j < LOOP_TIMES; j++) + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - warpPerspective(mat1_roi, dst_roi, M, size, interpolation); - ocl::warpPerspective(gmat1, gdst, M, size, interpolation); + equalizeHist(src_roi, dst_roi); + ocl::equalizeHist(gsrc_roi, gdst_roi); - Mat cpu_dst; - gdst_whole.download(cpu_dst); - EXPECT_MAT_NEAR(dst, cpu_dst, 1.0); + Near(1.1); } - } -///////////////////////////////////////////////////////////////////////////////////////////////// -// remap -////////////////////////////////////////////////////////////////////////////////////////////////// - -PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int) -{ - int srcType; - int map1Type; - int map2Type; - Scalar val; - - int interpolation; - int bordertype; - - Mat src; - Mat dst; - Mat map1; - Mat map2; - - //std::vector oclinfo; - - int src_roicols; - int src_roirows; - int dst_roicols; - int dst_roirows; - int map1_roicols; - int map1_roirows; - int map2_roicols; - int map2_roirows; - int srcx; - int srcy; - int dstx; - int dsty; - int map1x; - int map1y; - int map2x; - int map2y; - - Mat src_roi; - Mat dst_roi; - Mat map1_roi; - Mat map2_roi; - - //ocl mat for testing - ocl::oclMat gdst; - - //ocl mat with roi - ocl::oclMat gsrc_roi; - ocl::oclMat gdst_roi; - ocl::oclMat gmap1_roi; - ocl::oclMat gmap2_roi; - - virtual void SetUp() - { - srcType = GET_PARAM(0); - map1Type = GET_PARAM(1); - map2Type = GET_PARAM(2); - interpolation = GET_PARAM(3); - bordertype = GET_PARAM(4); - - Size srcSize = Size(MWIDTH, MHEIGHT); - Size map1Size = Size(MWIDTH, MHEIGHT); - double min = 5, max = 16; - - if(srcType != nulltype) - { - src = randomMat(srcSize, srcType, min, max, false); - } - if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype)) - { - map1 = randomMat(map1Size, map1Type, min, max, false); - } - else if (map1Type == CV_32FC1 && map2Type == CV_32FC1) - { - map1 = randomMat(map1Size, map1Type, min, max, false); - map2 = randomMat(map1Size, map1Type, min, max, false); - } - - else - { - cout << "The wrong input type" << endl; - return; - } +////////////////////////////////cornerMinEigenVal////////////////////////////////////////// - dst = randomMat(map1Size, srcType, min, max, false); - switch (src.channels()) - { - case 1: - val = Scalar(rng.uniform(0.0, 10.0), 0, 0, 0); - break; - case 2: - val = Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0, 0); - break; - case 3: - val = Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0); - break; - case 4: - val = Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0)); - break; - } +typedef ImgprocTestBase CornerMinEigenVal; - } - void random_roi() +OCL_TEST_P(CornerMinEigenVal, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) { - dst_roicols = rng.uniform(1, dst.cols); - dst_roirows = rng.uniform(1, dst.rows); - - src_roicols = rng.uniform(1, src.cols); - src_roirows = rng.uniform(1, src.rows); - - - srcx = rng.uniform(0, src.cols - src_roicols); - srcy = rng.uniform(0, src.rows - src_roirows); - dstx = rng.uniform(0, dst.cols - dst_roicols); - dsty = rng.uniform(0, dst.rows - dst_roirows); - map1_roicols = dst_roicols; - map1_roirows = dst_roirows; - map2_roicols = dst_roicols; - map2_roirows = dst_roirows; - map1x = dstx; - map1y = dsty; - map2x = dstx; - map2y = dsty; - - if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype)) - { - map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows)); - gmap1_roi = map1_roi; - } + random_roi(); - else if (map1Type == CV_32FC1 && map2Type == CV_32FC1) - { - map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows)); - gmap1_roi = map1_roi; - map2_roi = map2(Rect(map2x, map2y, map2_roicols, map2_roirows)); - gmap2_roi = map2_roi; - } - src_roi = src(Rect(srcx, srcy, src_roicols, src_roirows)); - dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows)); - gsrc_roi = src_roi; - gdst = dst; - gdst_roi = gdst(Rect(dstx, dsty, dst_roicols, dst_roirows)); - } -}; + int apertureSize = 3; -OCL_TEST_P(Remap, Mat) -{ - if((interpolation == 1 && map1Type == CV_16SC2) || (map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1)) - { - cout << "Don't support the dataType" << endl; - return; - } - int bordertype[] = {BORDER_CONSTANT, BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/}; + cornerMinEigenVal(src_roi, dst_roi, blockSize, apertureSize, borderType); + ocl::cornerMinEigenVal(gsrc_roi, gdst_roi, blockSize, apertureSize, borderType); - for(int j = 0; j < LOOP_TIMES; j++) - { - random_roi(); - remap(src_roi, dst_roi, map1_roi, map2_roi, interpolation, bordertype[0], val); - ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val); - Mat cpu_dst; - gdst.download(cpu_dst); - - if(interpolation == 0) - EXPECT_MAT_NEAR(dst, cpu_dst, 1.0); - EXPECT_MAT_NEAR(dst, cpu_dst, 2.0); + Near(1.0); } } +////////////////////////////////cornerHarris////////////////////////////////////////// +typedef ImgprocTestBase CornerHarris; -///////////////////////////////////////////////////////////////////////////////////////////////// -// resize - -PARAM_TEST_CASE(Resize, MatType, Size, double, double, int) +OCL_TEST_P(CornerHarris, Mat) { - int type; - Size dsize; - double fx, fy; - int interpolation; - - //src mat - Mat mat1; - Mat dst; - - // set up roi - int src_roicols; - int src_roirows; - int dst_roicols; - int dst_roirows; - int src1x; - int src1y; - int dstx; - int dsty; - - //src mat with roi - Mat mat1_roi; - Mat dst_roi; - - //ocl dst mat for testing - ocl::oclMat gdst_whole; - - //ocl mat with roi - ocl::oclMat gmat1; - ocl::oclMat gdst; - - virtual void SetUp() + for (int j = 0; j < LOOP_TIMES; j++) { - type = GET_PARAM(0); - dsize = GET_PARAM(1); - fx = GET_PARAM(2); - fy = GET_PARAM(3); - interpolation = GET_PARAM(4); - - Size size(MWIDTH, MHEIGHT); - - if(dsize == Size() && !(fx > 0 && fy > 0)) - { - cout << "invalid dsize and fx fy" << endl; - return; - } + random_roi(); - if(dsize == Size()) - { - dsize.width = (int)(size.width * fx); - dsize.height = (int)(size.height * fy); - } + int apertureSize = 3; + double k = 2.0; - mat1 = randomMat(size, type, 5, 16, false); - dst = randomMat(dsize, type, 5, 16, false); + cornerHarris(src_roi, dst_roi, blockSize, apertureSize, k, borderType); + ocl::cornerHarris(gsrc_roi, gdst_roi, blockSize, apertureSize, k, borderType); + Near(1.0); } +} - void random_roi() - { -#ifdef RANDOMROI - //randomize ROI - src_roicols = rng.uniform(1, mat1.cols); - src_roirows = rng.uniform(1, mat1.rows); - dst_roicols = (int)(src_roicols * fx); - dst_roirows = (int)(src_roirows * fy); - src1x = rng.uniform(0, mat1.cols - src_roicols); - src1y = rng.uniform(0, mat1.rows - src_roirows); - dstx = rng.uniform(0, dst.cols - dst_roicols); - dsty = rng.uniform(0, dst.rows - dst_roirows); -#else - src_roicols = mat1.cols; - src_roirows = mat1.rows; - dst_roicols = dst.cols; - dst_roirows = dst.rows; - src1x = 0; - src1y = 0; - dstx = 0; - dsty = 0; -#endif - dsize.width = dst_roicols; - dsize.height = dst_roirows; - mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows)); - dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows)); - - gdst_whole = dst; - gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows)); - - dsize.width = (int)(mat1_roi.size().width * fx); - dsize.height = (int)(mat1_roi.size().height * fy); - - gmat1 = mat1_roi; - } +//////////////////////////////////integral///////////////////////////////////////////////// -}; +typedef ImgprocTestBase Integral; -OCL_TEST_P(Resize, Mat) +OCL_TEST_P(Integral, Mat1) { - for(int j = 0; j < LOOP_TIMES; j++) + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - // resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation); - // ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation); - if(dst_roicols < 1 || dst_roirows < 1) continue; - resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation); - ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation); + ocl::integral(gsrc_roi, gdst_roi); + integral(src_roi, dst_roi); - Mat cpu_dst; - gdst_whole.download(cpu_dst); - EXPECT_MAT_NEAR(dst, cpu_dst, 1.0); + Near(); } - } - -///////////////////////////////////////////////////////////////////////////////////////////////// -//threshold - -PARAM_TEST_CASE(Threshold, MatType, ThreshOp) +// TODO wrong output type +OCL_TEST_P(Integral, DISABLED_Mat2) { - int type; - int threshOp; - - //src mat - Mat mat1; - Mat dst; - - // set up roi - int roicols; - int roirows; - int src1x; - int src1y; - int dstx; - int dsty; + Mat dst1; + ocl::oclMat gdst1; - //src mat with roi - Mat mat1_roi; - Mat dst_roi; - - //ocl dst mat for testing - ocl::oclMat gdst_whole; - - //ocl mat with roi - ocl::oclMat gmat1; - ocl::oclMat gdst; - - virtual void SetUp() - { - type = GET_PARAM(0); - threshOp = GET_PARAM(1); - - Size size(MWIDTH, MHEIGHT); - - mat1 = randomMat(size, type, 5, 16, false); - dst = randomMat(size, type, 5, 16, false); - } - - void random_roi() - { -#ifdef RANDOMROI - //randomize ROI - roicols = rng.uniform(1, mat1.cols); - roirows = rng.uniform(1, mat1.rows); - src1x = rng.uniform(0, mat1.cols - roicols); - src1y = rng.uniform(0, mat1.rows - roirows); - dstx = rng.uniform(0, dst.cols - roicols); - dsty = rng.uniform(0, dst.rows - roirows); -#else - roicols = mat1.cols; - roirows = mat1.rows; - src1x = 0; - src1y = 0; - dstx = 0; - dsty = 0; -#endif - - mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows)); - dst_roi = dst(Rect(dstx, dsty, roicols, roirows)); - - gdst_whole = dst; - gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows)); - - - gmat1 = mat1_roi; - } - -}; - -OCL_TEST_P(Threshold, Mat) -{ - for(int j = 0; j < LOOP_TIMES; j++) + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - double maxVal = randomDouble(20.0, 127.0); - double thresh = randomDouble(0.0, maxVal); - threshold(mat1_roi, dst_roi, thresh, maxVal, threshOp); - ocl::threshold(gmat1, gdst, thresh, maxVal, threshOp); + integral(src_roi, dst1, dst_roi); + ocl::integral(gsrc_roi, gdst1, gdst_roi); - Mat cpu_dst; - gdst_whole.download(cpu_dst); - EXPECT_MAT_NEAR(dst, cpu_dst, 1); + Near(); } - } -PARAM_TEST_CASE(MeanShiftTestBase, MatType, MatType, int, int, TermCriteria) +/////////////////////////////////////////////////////////////////////////////////////////////////// +//// threshold + +struct Threshold : + public ImgprocTestBase { - int type, typeCoor; - int sp, sr; - TermCriteria crit; - //src mat - Mat src; - Mat dst; - Mat dstCoor; - - //set up roi - int roicols; - int roirows; - int srcx; - int srcy; - int dstx; - int dsty; - - //src mat with roi - Mat src_roi; - Mat dst_roi; - Mat dstCoor_roi; - - //ocl dst mat - ocl::oclMat gdst; - ocl::oclMat gdstCoor; - - //ocl mat with roi - ocl::oclMat gsrc_roi; - ocl::oclMat gdst_roi; - ocl::oclMat gdstCoor_roi; + int thresholdType; virtual void SetUp() { - type = GET_PARAM(0); - typeCoor = GET_PARAM(1); - sp = GET_PARAM(2); - sr = GET_PARAM(3); - crit = GET_PARAM(4); - - // MWIDTH=256, MHEIGHT=256. defined in utility.hpp - Size size = Size(MWIDTH, MHEIGHT); - - src = randomMat(size, type, 5, 16, false); - dst = randomMat(size, type, 5, 16, false); - dstCoor = randomMat(size, typeCoor, 5, 16, false); - - } - - void random_roi() - { -#ifdef RANDOMROI - //randomize ROI - roicols = rng.uniform(1, src.cols); - roirows = rng.uniform(1, src.rows); - srcx = rng.uniform(0, src.cols - roicols); - srcy = rng.uniform(0, src.rows - roirows); - dstx = rng.uniform(0, dst.cols - roicols); - dsty = rng.uniform(0, dst.rows - roirows); -#else - roicols = src.cols; - roirows = src.rows; - srcx = 0; - srcy = 0; - dstx = 0; - dsty = 0; -#endif - src_roi = src(Rect(srcx, srcy, roicols, roirows)); - dst_roi = dst(Rect(dstx, dsty, roicols, roirows)); - dstCoor_roi = dstCoor(Rect(dstx, dsty, roicols, roirows)); - - gdst = dst; - gdstCoor = dstCoor; - - gsrc_roi = src_roi; - gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows)); //gdst_roi - gdstCoor_roi = gdstCoor(Rect(dstx, dsty, roicols, roirows)); + type = GET_PARAM(0); + blockSize = GET_PARAM(1); + thresholdType = GET_PARAM(2); + useRoi = GET_PARAM(3); } }; -/////////////////////////meanShiftFiltering///////////////////////////// - -typedef MeanShiftTestBase MeanShiftFiltering; - -OCL_TEST_P(MeanShiftFiltering, Mat) -{ - - for(int j = 0; j < LOOP_TIMES; j++) - { - random_roi(); - - Mat cpu_gdst; - gdst.download(cpu_gdst); - - ::meanShiftFiltering_(src_roi, dst_roi, sp, sr, crit); - ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit); - - gdst.download(cpu_gdst); - EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0); - } -} - -///////////////////////////meanShiftProc////////////////////////////////// - -typedef MeanShiftTestBase MeanShiftProc; - -OCL_TEST_P(MeanShiftProc, Mat) +OCL_TEST_P(Threshold, Mat) { - - for(int j = 0; j < LOOP_TIMES; j++) + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - Mat cpu_gdst; - Mat cpu_gdstCoor; + double maxVal = randomDouble(20.0, 127.0); + double thresh = randomDouble(0.0, maxVal); - meanShiftProc_(src_roi, dst_roi, dstCoor_roi, sp, sr, crit); - ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit); + threshold(src_roi, dst_roi, thresh, maxVal, thresholdType); + ocl::threshold(gsrc_roi, gdst_roi, thresh, maxVal, thresholdType); - gdst.download(cpu_gdst); - gdstCoor.download(cpu_gdstCoor); - EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0); - EXPECT_MAT_NEAR(dstCoor, cpu_gdstCoor, 0.0); + Near(1); } } -/////////////////////////////////////////////////////////////////////////////////////// -//hist +///////////////////////////////////////////////////////////////////////////////////////// +// calcHist -void calcHistGold(const Mat &src, Mat &hist) +static void calcHistGold(const Mat &src, Mat &hist) { - hist.create(1, 256, CV_32SC1); - hist.setTo(Scalar::all(0)); + hist = Mat(1, 256, CV_32SC1, Scalar::all(0)); - int *hist_row = hist.ptr(); + int * const hist_row = hist.ptr(); for (int y = 0; y < src.rows; ++y) { - const uchar *src_row = src.ptr(y); + const uchar * const src_row = src.ptr(y); for (int x = 0; x < src.cols; ++x) ++hist_row[src_row[x]]; } } -PARAM_TEST_CASE(HistTestBase, MatType, MatType) -{ - int type_src; - - //src mat - Mat src; - Mat dst_hist; - //set up roi - int roicols; - int roirows; - int srcx; - int srcy; - //src mat with roi - Mat src_roi; - //ocl dst mat, dst_hist and gdst_hist don't have roi - ocl::oclMat gdst_hist; - //ocl mat with roi - ocl::oclMat gsrc_roi; - - virtual void SetUp() - { - type_src = GET_PARAM(0); - - Size size = Size(MWIDTH, MHEIGHT); - - src = randomMat(size, type_src, 0, 256, false); - - } - - void random_roi() - { -#ifdef RANDOMROI - //randomize ROI - roicols = rng.uniform(1, src.cols); - roirows = rng.uniform(1, src.rows); - srcx = rng.uniform(0, src.cols - roicols); - srcy = rng.uniform(0, src.rows - roirows); -#else - roicols = src.cols; - roirows = src.rows; - srcx = 0; - srcy = 0; -#endif - src_roi = src(Rect(srcx, srcy, roicols, roirows)); - - gsrc_roi = src_roi; - } -}; - -///////////////////////////calcHist/////////////////////////////////////// - -typedef HistTestBase CalcHist; +typedef ImgprocTestBase CalcHist; OCL_TEST_P(CalcHist, Mat) { - for(int j = 0; j < LOOP_TIMES; j++) + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - Mat cpu_hist; - - calcHistGold(src_roi, dst_hist); - ocl::calcHist(gsrc_roi, gdst_hist); + calcHistGold(src_roi, dst_roi); + ocl::calcHist(gsrc_roi, gdst_roi); - gdst_hist.download(cpu_hist); - EXPECT_MAT_NEAR(dst_hist, cpu_hist, 0.0); + Near(); } } -/////////////////////////////////////////////////////////////////////////////////////////////////////// -// CLAHE +///////////////////////////////////////////////////////////////////////////////////////////////////////// +//// CLAHE -PARAM_TEST_CASE(CLAHE_Test, Size, double) +PARAM_TEST_CASE(CLAHETest, Size, double, bool) { Size gridSize; double clipLimit; + bool useRoi; - Mat src; - Mat dst_gold; - - ocl::oclMat g_src; - ocl::oclMat g_dst; + Mat src, dst_whole, src_roi, dst_roi; + ocl::oclMat gsrc_whole, gsrc_roi, gdst_whole, gdst_roi; virtual void SetUp() { gridSize = GET_PARAM(0); clipLimit = GET_PARAM(1); - - src = randomMat(Size(MWIDTH, MHEIGHT), CV_8UC1, 0, 256, false); - g_src.upload(src); + useRoi = GET_PARAM(2); } -}; - -OCL_TEST_P(CLAHE_Test, Accuracy) -{ - Ptr clahe = ocl::createCLAHE(clipLimit, gridSize); - clahe->apply(g_src, g_dst); - Mat dst(g_dst); - - Ptr clahe_gold = createCLAHE(clipLimit, gridSize); - clahe_gold->apply(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 1.0); -} - -///////////////////////////Convolve////////////////////////////////// - -PARAM_TEST_CASE(ConvolveTestBase, MatType, bool) -{ - int type; - //src mat - Mat mat1; - Mat mat2; - Mat dst; - Mat dst1; //bak, for two outputs - // set up roi - int roicols; - int roirows; - int src1x; - int src1y; - int src2x; - int src2y; - int dstx; - int dsty; - //src mat with roi - Mat mat1_roi; - Mat mat2_roi; - Mat dst_roi; - Mat dst1_roi; //bak - //ocl dst mat for testing - ocl::oclMat gdst_whole; - ocl::oclMat gdst1_whole; //bak - //ocl mat with roi - ocl::oclMat gmat1; - ocl::oclMat gmat2; - ocl::oclMat gdst; - ocl::oclMat gdst1; //bak - virtual void SetUp() + void random_roi() { - type = GET_PARAM(0); + Size roiSize = randomSize(std::max(gridSize.height, gridSize.width), MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, roiSize, srcBorder, CV_8UC1, 5, 256); - Size size(MWIDTH, MHEIGHT); + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, CV_8UC1, 5, 16); - mat1 = randomMat(size, type, 5, 16, false); - mat2 = randomMat(size, type, 5, 16, false); - dst = randomMat(size, type, 5, 16, false); - dst1 = randomMat(size, type, 5, 16, false); + generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder); + generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder); } - void random_roi() + + void Near(double threshold = 0.0) { -#ifdef RANDOMROI - //randomize ROI - roicols = rng.uniform(1, mat1.cols); - roirows = rng.uniform(1, mat1.rows); - src1x = rng.uniform(0, mat1.cols - roicols); - src1y = rng.uniform(0, mat1.rows - roirows); - dstx = rng.uniform(0, dst.cols - roicols); - dsty = rng.uniform(0, dst.rows - roirows); -#else - roicols = mat1.cols; - roirows = mat1.rows; - src1x = 0; - src1y = 0; - dstx = 0; - dsty = 0; -#endif - src2x = rng.uniform(0, mat2.cols - roicols); - src2y = rng.uniform(0, mat2.rows - roirows); - mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows)); - mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows)); - dst_roi = dst(Rect(dstx, dsty, roicols, roirows)); - dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows)); - - gdst_whole = dst; - gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows)); - - gdst1_whole = dst1; - gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows)); - - gmat1 = mat1_roi; - gmat2 = mat2_roi; - //end - } + Mat whole, roi; + gdst_whole.download(whole); + gdst_roi.download(roi); + EXPECT_MAT_NEAR(dst_whole, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); + } }; -typedef ConvolveTestBase Convolve; - -void conv2( Mat x, Mat y, Mat z) +OCL_TEST_P(CLAHETest, Accuracy) { - int N1 = x.rows; - int M1 = x.cols; - int N2 = y.rows; - int M2 = y.cols; + for (int i = 0; i < LOOP_TIMES; ++i) + { + random_roi(); + + Ptr clahe = ocl::createCLAHE(clipLimit, gridSize); + clahe->apply(gsrc_roi, gdst_roi); - int i, j; - int m, n; + Ptr clahe_gold = createCLAHE(clipLimit, gridSize); + clahe_gold->apply(src_roi, dst_roi); + Near(1.0); + } +} - float *kerneldata = (float *)(x.data); - float *srcdata = (float *)(y.data); - float *dstdata = (float *)(z.data); +/////////////////////////////Convolve////////////////////////////////// - for(i = 0; i < N2; i++) - for(j = 0; j < M2; j++) +static void convolve_gold(const Mat & src, const Mat & kernel, Mat & dst) +{ + for (int i = 0; i < src.rows; i++) + { + float * const dstptr = dst.ptr(i); + + for (int j = 0; j < src.cols; j++) { float temp = 0; - for(m = 0; m < N1; m++) - for(n = 0; n < M1; n++) + + for (int m = 0; m < kernel.rows; m++) + { + const float * const kptr = kernel.ptr(m); + for (int n = 0; n < kernel.cols; n++) { - int r, c; - r = min(max((i - N1 / 2 + m), 0), N2 - 1); - c = min(max((j - M1 / 2 + n), 0), M2 - 1); - temp += kerneldata[m * (x.step >> 2) + n] * srcdata[r * (y.step >> 2) + c]; + int r = clipInt(i - kernel.rows / 2 + m, 0, src.rows - 1); + int c = clipInt(j - kernel.cols / 2 + n, 0, src.cols - 1); + + temp += src.ptr(r)[c] * kptr[n]; } - dstdata[i * (z.step >> 2) + j] = temp; + } + + dstptr[j] = temp; } + } } +typedef ImgprocTestBase Convolve; + OCL_TEST_P(Convolve, Mat) { - if(mat1.type() != CV_32FC1) - { - cout << "\tUnsupported type\t\n"; - } - for(int j = 0; j < LOOP_TIMES; j++) + Mat kernel, kernel_roi; + ocl::oclMat gkernel, gkernel_roi; + const Size roiSize(7, 7); + + for (int j = 0; j < LOOP_TIMES; j++) { random_roi(); - ocl::oclMat temp1; - Mat kernel_cpu = mat2(Rect(0, 0, 7, 7)); - temp1 = kernel_cpu; - conv2(kernel_cpu, mat1_roi, dst_roi); - ocl::convolve(gmat1, temp1, gdst); + Border kernelBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(kernel, kernel_roi, roiSize, kernelBorder, type, 5, 16); + generateOclMat(gkernel, gkernel_roi, kernel, roiSize, kernelBorder); - Mat cpu_dst; - gdst_whole.download(cpu_dst); - EXPECT_MAT_NEAR(dst, cpu_dst, .1); + convolve_gold(src_roi, kernel_roi, dst_roi); + ocl::convolve(gsrc_roi, gkernel_roi, gdst_roi); + Near(1); } } -//////////////////////////////// ColumnSum ////////////////////////////////////// +////////////////////////////////// ColumnSum ////////////////////////////////////// -PARAM_TEST_CASE(ColumnSum, Size) +static void columnSum_gold(const Mat & src, Mat & dst) { - Size size; - Mat src; + float * prevdptr = dst.ptr(0); + const float * sptr = src.ptr(0); - virtual void SetUp() + for (int x = 0; x < src.cols; ++x) + prevdptr[x] = sptr[x]; + + for (int y = 1; y < src.rows; ++y) { - size = GET_PARAM(0); - } -}; + sptr = src.ptr(y); + float * const dptr = dst.ptr(y); -OCL_TEST_P(ColumnSum, Accuracy) -{ - Mat src = randomMat(size, CV_32FC1, 0, 255); - ocl::oclMat d_dst; - ocl::oclMat d_src(src); + for (int x = 0; x < src.cols; ++x) + dptr[x] = prevdptr[x] + sptr[x]; - ocl::columnSum(d_src, d_dst); + prevdptr = dptr; + } +} - Mat dst(d_dst); +typedef ImgprocTestBase ColumnSum; - for (int j = 0; j < src.cols; ++j) +OCL_TEST_P(ColumnSum, Accuracy) +{ + for (int i = 0; i < LOOP_TIMES; ++i) { - float gold = src.at(0, j); - float res = dst.at(0, j); - ASSERT_NEAR(res, gold, 1e-5); - } + random_roi(); - for (int i = 1; i < src.rows; ++i) - { - for (int j = 0; j < src.cols; ++j) - { - float gold = src.at(i, j) += src.at(i - 1, j); - float res = dst.at(i, j); - ASSERT_NEAR(res, gold, 1e-5); - } + columnSum_gold(src_roi, dst_roi); + ocl::columnSum(gsrc_roi, gdst_roi); + + Near(1e-5); } } ///////////////////////////////////////////////////////////////////////////////////// -INSTANTIATE_TEST_CASE_P(ImgprocTestBase, EqualizeHist, Combine( - ONE_TYPE(CV_8UC1), - NULL_TYPE, - ONE_TYPE(CV_8UC1), - NULL_TYPE, - NULL_TYPE, - Values(false))); // Values(false) is the reserved parameter - - -INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CopyMakeBorder, Combine( - Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4), - NULL_TYPE, - Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4), - NULL_TYPE, - NULL_TYPE, - Values(false))); // Values(false) is the reserved parameter - -INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CornerMinEigenVal, Combine( - Values(CV_8UC1, CV_32FC1), - NULL_TYPE, - ONE_TYPE(CV_32FC1), - NULL_TYPE, - NULL_TYPE, - Values(false))); // Values(false) is the reserved parameter +INSTANTIATE_TEST_CASE_P(Imgproc, EqualizeHist, Combine( + Values((MatType)CV_8UC1), + Values(0), // not used + Values(0), // not used + Bool())); -INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CornerHarris, Combine( +INSTANTIATE_TEST_CASE_P(Imgproc, CornerMinEigenVal, Combine( Values(CV_8UC1, CV_32FC1), - NULL_TYPE, - ONE_TYPE(CV_32FC1), - NULL_TYPE, - NULL_TYPE, - Values(false))); // Values(false) is the reserved parameter - - -INSTANTIATE_TEST_CASE_P(ImgprocTestBase, Integral, Combine( - ONE_TYPE(CV_8UC1), - NULL_TYPE, - ONE_TYPE(CV_32SC1), - ONE_TYPE(CV_32FC1), - NULL_TYPE, - Values(false))); // Values(false) is the reserved parameter - -INSTANTIATE_TEST_CASE_P(Imgproc, WarpAffine, Combine( - Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), - Values((MatType)INTER_NEAREST, (MatType)INTER_LINEAR, - (MatType)INTER_CUBIC, (MatType)(INTER_NEAREST | WARP_INVERSE_MAP), - (MatType)(INTER_LINEAR | WARP_INVERSE_MAP), (MatType)(INTER_CUBIC | WARP_INVERSE_MAP)))); - - -INSTANTIATE_TEST_CASE_P(Imgproc, WarpPerspective, Combine - (Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), - Values((MatType)INTER_NEAREST, (MatType)INTER_LINEAR, - (MatType)INTER_CUBIC, (MatType)(INTER_NEAREST | WARP_INVERSE_MAP), - (MatType)(INTER_LINEAR | WARP_INVERSE_MAP), (MatType)(INTER_CUBIC | WARP_INVERSE_MAP)))); - - -INSTANTIATE_TEST_CASE_P(Imgproc, Resize, Combine( - Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(Size()), - Values(0.5, 1.5, 2), Values(0.5, 1.5, 2), Values((MatType)INTER_NEAREST, (MatType)INTER_LINEAR))); - + Values(3), // TODO some fails when blockSize != 3 (for example 5) + Values((int)BORDER_REFLECT, (int)BORDER_CONSTANT, (int)BORDER_REPLICATE), // TODO does not work with (int)BORDER_REFLECT101 + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, CornerHarris, Combine( + Values((MatType)CV_8UC1), // TODO does not work properly with CV_32FC1 + Values(3, 5), + Values((int)BORDER_REFLECT101, (int)BORDER_REFLECT, (int)BORDER_CONSTANT, (int)BORDER_REPLICATE), + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, Integral, Combine( + Values((MatType)CV_8UC1), // TODO does work with CV_32F, CV_64F + Values(0), // not used + Values(0), // not used + Bool())); INSTANTIATE_TEST_CASE_P(Imgproc, Threshold, Combine( - Values(CV_8UC1, CV_32FC1), Values(ThreshOp(THRESH_BINARY), - ThreshOp(THRESH_BINARY_INV), ThreshOp(THRESH_TRUNC), - ThreshOp(THRESH_TOZERO), ThreshOp(THRESH_TOZERO_INV)))); - - -INSTANTIATE_TEST_CASE_P(Imgproc, MeanShiftFiltering, Combine( - ONE_TYPE(CV_8UC4), - ONE_TYPE(CV_16SC2), - Values(5), - Values(6), - Values(TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 5, 1)) - )); - - -INSTANTIATE_TEST_CASE_P(Imgproc, MeanShiftProc, Combine( - ONE_TYPE(CV_8UC4), - ONE_TYPE(CV_16SC2), - Values(5), - Values(6), - Values(TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 5, 1)) - )); - -INSTANTIATE_TEST_CASE_P(Imgproc, Remap, Combine( - Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), - Values(CV_32FC1, CV_16SC2, CV_32FC2), Values(-1, CV_32FC1), - Values((int)INTER_NEAREST, (int)INTER_LINEAR), - Values((int)BORDER_CONSTANT))); - - -INSTANTIATE_TEST_CASE_P(histTestBase, CalcHist, Combine( - ONE_TYPE(CV_8UC1), - ONE_TYPE(CV_32SC1) //no use - )); - -INSTANTIATE_TEST_CASE_P(Imgproc, CLAHE_Test, Combine( - Values(Size(4, 4), Size(32, 8), Size(8, 64)), - Values(0.0, 10.0, 62.0, 300.0))); + Values(CV_8UC1, CV_32FC1), + Values(0), + Values(ThreshOp(THRESH_BINARY), + ThreshOp(THRESH_BINARY_INV), ThreshOp(THRESH_TRUNC), + ThreshOp(THRESH_TOZERO), ThreshOp(THRESH_TOZERO_INV)), + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, CalcHist, Combine( + Values((MatType)CV_8UC1), + Values(0), // not used + Values(0), // not used + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, CLAHETest, Combine( + Values(Size(4, 4), Size(32, 8), Size(8, 64)), + Values(0.0, 10.0, 62.0, 300.0), + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, Convolve, Combine( + Values((MatType)CV_32FC1), + Values(0), // not used + Values(0), // not used + Bool())); + +INSTANTIATE_TEST_CASE_P(Imgproc, ColumnSum, Combine( + Values(MatType(CV_32FC1)), + Values(0), // not used + Values(0), // not used + Bool())); -INSTANTIATE_TEST_CASE_P(Imgproc, ColumnSum, DIFFERENT_SIZES); +INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CopyMakeBorder, Combine( + testing::Range((MatDepth)CV_8U, (MatDepth)CV_USRTYPE1), + testing::Values((Channels)1, (Channels)4), + Bool(), // border isolated or not + Values((Border)BORDER_CONSTANT, + (Border)BORDER_REPLICATE, + (Border)BORDER_REFLECT, + (Border)BORDER_WRAP, + (Border)BORDER_REFLECT_101), + Bool())); #endif // HAVE_OPENCL diff --git a/modules/ocl/test/test_mean_shift.cpp b/modules/ocl/test/test_mean_shift.cpp new file mode 100644 index 0000000..684a2a9 --- /dev/null +++ b/modules/ocl/test/test_mean_shift.cpp @@ -0,0 +1,408 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Niko Li, newlife20080214@gmail.com +// Jia Haipeng, jiahaipeng95@gmail.com +// Shengen Yan, yanshengen@gmail.com +// Jiang Liyuan, lyuan001.good@163.com +// Rock Li, Rock.Li@amd.com +// Wu Zailong, bullet@yeah.net +// Xu Pang, pangxu010@163.com +// Sen Liu, swjtuls1987@126.com +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other oclMaterials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" + +#ifdef HAVE_OPENCL + +using namespace testing; +using namespace std; +using namespace cv; + +typedef struct +{ + short x; + short y; +} COOR; + +COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, Size size, int sp, int sr, int maxIter, float eps, int *tab) +{ + + int isr2 = sr * sr; + int c0, c1, c2, c3; + int iter; + uchar *ptr = NULL; + uchar *pstart = NULL; + int revx = 0, revy = 0; + c0 = sptr[0]; + c1 = sptr[1]; + c2 = sptr[2]; + c3 = sptr[3]; + // iterate meanshift procedure + for(iter = 0; iter < maxIter; iter++ ) + { + int count = 0; + int s0 = 0, s1 = 0, s2 = 0, sx = 0, sy = 0; + + //mean shift: process pixels in window (p-sigmaSp)x(p+sigmaSp) + int minx = x0 - sp; + int miny = y0 - sp; + int maxx = x0 + sp; + int maxy = y0 + sp; + + //deal with the image boundary + if(minx < 0) minx = 0; + if(miny < 0) miny = 0; + if(maxx >= size.width) maxx = size.width - 1; + if(maxy >= size.height) maxy = size.height - 1; + if(iter == 0) + { + pstart = sptr; + } + else + { + pstart = pstart + revy * sstep + (revx << 2); //point to the new position + } + ptr = pstart; + ptr = ptr + (miny - y0) * sstep + ((minx - x0) << 2); //point to the start in the row + + for( int y = miny; y <= maxy; y++, ptr += sstep - ((maxx - minx + 1) << 2)) + { + int rowCount = 0; + int x = minx; +#if CV_ENABLE_UNROLLED + for( ; x + 4 <= maxx; x += 4, ptr += 16) + { + int t0, t1, t2; + t0 = ptr[0], t1 = ptr[1], t2 = ptr[2]; + if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) + { + s0 += t0; + s1 += t1; + s2 += t2; + sx += x; + rowCount++; + } + t0 = ptr[4], t1 = ptr[5], t2 = ptr[6]; + if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) + { + s0 += t0; + s1 += t1; + s2 += t2; + sx += x + 1; + rowCount++; + } + t0 = ptr[8], t1 = ptr[9], t2 = ptr[10]; + if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) + { + s0 += t0; + s1 += t1; + s2 += t2; + sx += x + 2; + rowCount++; + } + t0 = ptr[12], t1 = ptr[13], t2 = ptr[14]; + if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) + { + s0 += t0; + s1 += t1; + s2 += t2; + sx += x + 3; + rowCount++; + } + } +#endif + for(; x <= maxx; x++, ptr += 4) + { + int t0 = ptr[0], t1 = ptr[1], t2 = ptr[2]; + if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2) + { + s0 += t0; + s1 += t1; + s2 += t2; + sx += x; + rowCount++; + } + } + if(rowCount == 0) + continue; + count += rowCount; + sy += y * rowCount; + } + + if( count == 0 ) + break; + + int x1 = sx / count; + int y1 = sy / count; + s0 = s0 / count; + s1 = s1 / count; + s2 = s2 / count; + + bool stopFlag = (x0 == x1 && y0 == y1) || (abs(x1 - x0) + abs(y1 - y0) + + tab[s0 - c0 + 255] + tab[s1 - c1 + 255] + tab[s2 - c2 + 255] <= eps); + + //revise the pointer corresponding to the new (y0,x0) + revx = x1 - x0; + revy = y1 - y0; + + x0 = x1; + y0 = y1; + c0 = s0; + c1 = s1; + c2 = s2; + + if( stopFlag ) + break; + } //for iter + + dptr[0] = (uchar)c0; + dptr[1] = (uchar)c1; + dptr[2] = (uchar)c2; + dptr[3] = (uchar)c3; + + COOR coor; + coor.x = (short)x0; + coor.y = (short)y0; + return coor; +} + +void meanShiftFiltering_(const Mat &src_roi, Mat &dst_roi, int sp, int sr, TermCriteria crit) +{ + if( src_roi.empty() ) + CV_Error( CV_StsBadArg, "The input image is empty" ); + + if( src_roi.depth() != CV_8U || src_roi.channels() != 4 ) + CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" ); + + CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) ); + CV_Assert( !(dst_roi.step & 0x3) ); + + if( !(crit.type & TermCriteria::MAX_ITER) ) + crit.maxCount = 5; + int maxIter = std::min(std::max(crit.maxCount, 1), 100); + float eps; + if( !(crit.type & TermCriteria::EPS) ) + eps = 1.f; + eps = (float)std::max(crit.epsilon, 0.0); + + int tab[512]; + for(int i = 0; i < 512; i++) + tab[i] = (i - 255) * (i - 255); + uchar *sptr = src_roi.data; + uchar *dptr = dst_roi.data; + int sstep = (int)src_roi.step; + int dstep = (int)dst_roi.step; + Size size = src_roi.size(); + + for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2), + dptr += dstep - (size.width << 2)) + { + for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4) + { + do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab); + } + } +} + +void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, int sr, TermCriteria crit) +{ + if( src_roi.empty() ) + CV_Error( CV_StsBadArg, "The input image is empty" ); + if( src_roi.depth() != CV_8U || src_roi.channels() != 4 ) + CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" ); + CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) && + (src_roi.cols == dstCoor_roi.cols) && (src_roi.rows == dstCoor_roi.rows)); + CV_Assert( !(dstCoor_roi.step & 0x3) ); + + if( !(crit.type & TermCriteria::MAX_ITER) ) + crit.maxCount = 5; + int maxIter = std::min(std::max(crit.maxCount, 1), 100); + float eps; + if( !(crit.type & TermCriteria::EPS) ) + eps = 1.f; + eps = (float)std::max(crit.epsilon, 0.0); + + int tab[512]; + for(int i = 0; i < 512; i++) + tab[i] = (i - 255) * (i - 255); + uchar *sptr = src_roi.data; + uchar *dptr = dst_roi.data; + short *dCoorptr = (short *)dstCoor_roi.data; + int sstep = (int)src_roi.step; + int dstep = (int)dst_roi.step; + int dCoorstep = (int)dstCoor_roi.step >> 1; + Size size = src_roi.size(); + + for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2), + dptr += dstep - (size.width << 2), dCoorptr += dCoorstep - (size.width << 1)) + { + for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4, dCoorptr += 2) + { + *((COOR *)dCoorptr) = do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab); + } + } + +} + +//////////////////////////////// meanShift ////////////////////////////////////////// + +PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, TermCriteria, bool) +{ + int type, typeCoor; + int sp, sr; + TermCriteria crit; + bool useRoi; + + // src mat + Mat src, src_roi; + Mat dst, dst_roi; + Mat dstCoor, dstCoor_roi; + + // ocl dst mat + ocl::oclMat gsrc, gsrc_roi; + ocl::oclMat gdst, gdst_roi; + ocl::oclMat gdstCoor, gdstCoor_roi; + + virtual void SetUp() + { + type = GET_PARAM(0); + typeCoor = GET_PARAM(1); + sp = GET_PARAM(2); + sr = GET_PARAM(3); + crit = GET_PARAM(4); + useRoi = GET_PARAM(5); + } + + void random_roi() + { + Size roiSize = randomSize(1, MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, roiSize, srcBorder, type, 5, 256); + generateOclMat(gsrc, gsrc_roi, src, roiSize, srcBorder); + + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst, dst_roi, roiSize, dstBorder, type, 5, 256); + generateOclMat(gdst, gdst_roi, dst, roiSize, dstBorder); + + randomSubMat(dstCoor, dstCoor_roi, roiSize, dstBorder, typeCoor, 5, 256); + generateOclMat(gdstCoor, gdstCoor_roi, dstCoor, roiSize, dstBorder); + } + + void Near(double threshold = 0.0) + { + Mat whole, roi; + gdst.download(whole); + gdst_roi.download(roi); + + EXPECT_MAT_NEAR(dst, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); + } + + void Near1(double threshold = 0.0) + { + Mat whole, roi; + gdstCoor.download(whole); + gdstCoor_roi.download(roi); + + EXPECT_MAT_NEAR(dstCoor, whole, threshold); + EXPECT_MAT_NEAR(dstCoor_roi, roi, threshold); + } +}; + +/////////////////////////meanShiftFiltering///////////////////////////// + +typedef meanShiftTestBase meanShiftFiltering; + +OCL_TEST_P(meanShiftFiltering, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + meanShiftFiltering_(src_roi, dst_roi, sp, sr, crit); + ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit); + + Near(); + } +} + +///////////////////////////meanShiftProc////////////////////////////////// + +typedef meanShiftTestBase meanShiftProc; + +OCL_TEST_P(meanShiftProc, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + meanShiftProc_(src_roi, dst_roi, dstCoor_roi, sp, sr, crit); + ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit); + + Near(); + Near1(); + } +} + +///////////////////////////////////////////////////////////////////////////////////// + +INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftFiltering, Combine( + Values((MatType)CV_8UC4), + Values((MatType)CV_16SC2), + Values(5), + Values(6), + Values(TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 5, 1)), + Bool() + )); + +INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftProc, Combine( + Values((MatType)CV_8UC4), + Values((MatType)CV_16SC2), + Values(5), + Values(6), + Values(TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 5, 1)), + Bool() + )); + +#endif // HAVE_OPENCL diff --git a/modules/ocl/test/test_warp.cpp b/modules/ocl/test/test_warp.cpp new file mode 100644 index 0000000..dda6837 --- /dev/null +++ b/modules/ocl/test/test_warp.cpp @@ -0,0 +1,369 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Niko Li, newlife20080214@gmail.com +// Jia Haipeng, jiahaipeng95@gmail.com +// Shengen Yan, yanshengen@gmail.com +// Jiang Liyuan, lyuan001.good@163.com +// Rock Li, Rock.Li@amd.com +// Wu Zailong, bullet@yeah.net +// Xu Pang, pangxu010@163.com +// Sen Liu, swjtuls1987@126.com +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other oclMaterials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" + +#ifdef HAVE_OPENCL + +using namespace cv; +using namespace testing; +using namespace std; + +static MatType noType = -1; + +///////////////////////////////////////////////////////////////////////////////////////////////// +// warpAffine & warpPerspective + +PARAM_TEST_CASE(WarpTestBase, MatType, int, bool, bool) +{ + int type, interpolation; + Size dsize; + bool useRoi, mapInverse; + + Mat src, dst_whole, src_roi, dst_roi; + ocl::oclMat gsrc_whole, gsrc_roi, gdst_whole, gdst_roi; + + virtual void SetUp() + { + type = GET_PARAM(0); + interpolation = GET_PARAM(1); + mapInverse = GET_PARAM(2); + useRoi = GET_PARAM(3); + + if (mapInverse) + interpolation |= WARP_INVERSE_MAP; + } + + void random_roi() + { + Size roiSize = randomSize(1, MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, roiSize, srcBorder, type, -MAX_VALUE, MAX_VALUE); + + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, type, -MAX_VALUE, MAX_VALUE); + + generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder); + generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder); + + dsize = randomSize(1, MAX_VALUE); + } + + void Near(double threshold = 0.0) + { + Mat whole, roi, diff; + gdst_whole.download(whole); + gdst_roi.download(roi); + + imshow("OpenCV", dst_whole); + imshow("OpenCL", whole); + + cv::absdiff(whole, dst_whole, diff); + imshow("Diff", diff); + cv::waitKey(); + + EXPECT_MAT_NEAR(dst_whole, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); + } +}; + +/////warpAffine + +typedef WarpTestBase WarpAffine; + +OCL_TEST_P(WarpAffine, Mat) +{ + static const double coeffs[2][3] = + { + { cos(CV_PI / 6), -sin(CV_PI / 6), 100.0 }, + { sin(CV_PI / 6), cos(CV_PI / 6), -100.0 } + }; + + static Mat M(2, 3, CV_64FC1, (void *)coeffs); + + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + warpAffine(src_roi, dst_roi, M, dsize, interpolation); + ocl::warpAffine(gsrc_roi, gdst_roi, M, dsize, interpolation); + + Near(1.0); + } +} + +// warpPerspective + +typedef WarpTestBase WarpPerspective; + +OCL_TEST_P(WarpPerspective, Mat) +{ + static const double coeffs[3][3] = + { + { cos(CV_PI / 6), -sin(CV_PI / 6), 100.0 }, + { sin(CV_PI / 6), cos(CV_PI / 6), -100.0 }, + { 0.0, 0.0, 1.0 } + }; + + static Mat M(3, 3, CV_64FC1, (void *)coeffs); + + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + warpPerspective(src_roi, dst_roi, M, dsize, interpolation); + ocl::warpPerspective(gsrc_roi, gdst_roi, M, dsize, interpolation); + + Near(1.0); + } +} + +///////////////////////////////////////////////////////////////////////////////////////////////// +// remap + +PARAM_TEST_CASE(Remap, int, int, pair, int, bool) +{ + int srcType, map1Type, map2Type; + int borderType; + bool useRoi; + + Scalar val; + + Mat src, src_roi; + Mat dst, dst_roi; + Mat map1, map1_roi; + Mat map2, map2_roi; + + // ocl mat with roi + ocl::oclMat gsrc, gsrc_roi; + ocl::oclMat gdst, gdst_roi; + ocl::oclMat gmap1, gmap1_roi; + ocl::oclMat gmap2, gmap2_roi; + + virtual void SetUp() + { + srcType = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1)); + map1Type = GET_PARAM(2).first; + map2Type = GET_PARAM(2).second; + borderType = GET_PARAM(3); + useRoi = GET_PARAM(4); + } + + void random_roi() + { + val = randomScalar(-MAX_VALUE, MAX_VALUE); + Size srcROISize = randomSize(1, MAX_VALUE); + Size dstROISize = randomSize(1, MAX_VALUE); + + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, srcROISize, srcBorder, srcType, 5, 256); + + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst, dst_roi, dstROISize, dstBorder, srcType, -MAX_VALUE, MAX_VALUE << 1); + + Border map1Border = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(map1, map1_roi, dstROISize, map1Border, map1Type, -MAX_VALUE, MAX_VALUE << 1); + + Border map2Border = randomBorder(0, useRoi ? MAX_VALUE : 0); + if (map2Type != noType) + randomSubMat(map2, map2_roi, dstROISize, map2Border, map2Type, -MAX_VALUE, MAX_VALUE << 1); + + generateOclMat(gsrc, gsrc_roi, src, srcROISize, srcBorder); + generateOclMat(gdst, gdst_roi, dst, dstROISize, dstBorder); + generateOclMat(gmap1, gmap1_roi, map1, dstROISize, map1Border); + if (noType != map2Type) + generateOclMat(gmap2, gmap2_roi, map2, dstROISize, map2Border); + } + + void Near(double threshold = 0.0) + { + Mat whole, roi; + gdst.download(whole); + gdst_roi.download(roi); + + EXPECT_MAT_NEAR(dst, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); + } +}; + +typedef Remap Remap_INTER_NEAREST; + +OCL_TEST_P(Remap_INTER_NEAREST, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + remap(src_roi, dst_roi, map1_roi, map2_roi, INTER_NEAREST, borderType, val); + ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, INTER_NEAREST, borderType, val); + + Near(1.0); + } +} + +typedef Remap Remap_INTER_LINEAR; + +OCL_TEST_P(Remap_INTER_LINEAR, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + cv::remap(src_roi, dst_roi, map1_roi, map2_roi, INTER_LINEAR, borderType, val); + ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, INTER_LINEAR, borderType, val); + + Near(2.0); + } +} + +///////////////////////////////////////////////////////////////////////////////////////////////// +// resize + +PARAM_TEST_CASE(Resize, MatType, double, double, int, bool) +{ + int type, interpolation; + double fx, fy; + bool useRoi; + + Mat src, dst_whole, src_roi, dst_roi; + ocl::oclMat gsrc_whole, gsrc_roi, gdst_whole, gdst_roi; + + virtual void SetUp() + { + type = GET_PARAM(0); + fx = GET_PARAM(1); + fy = GET_PARAM(2); + interpolation = GET_PARAM(3); + useRoi = GET_PARAM(4); + } + + void random_roi() + { + Size srcRoiSize = randomSize(1, MAX_VALUE); + Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(src, src_roi, srcRoiSize, srcBorder, type, -MAX_VALUE, MAX_VALUE); + + Size dstRoiSize; + dstRoiSize.width = cvRound(srcRoiSize.width * fx); + dstRoiSize.height = cvRound(srcRoiSize.height * fy); + + Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); + randomSubMat(dst_whole, dst_roi, dstRoiSize, dstBorder, type, -MAX_VALUE, MAX_VALUE); + + generateOclMat(gsrc_whole, gsrc_roi, src, srcRoiSize, srcBorder); + generateOclMat(gdst_whole, gdst_roi, dst_whole, dstRoiSize, dstBorder); + } + + void Near(double threshold = 0.0) + { + Mat whole, roi; + gdst_whole.download(whole); + gdst_roi.download(roi); + + EXPECT_MAT_NEAR(dst_whole, whole, threshold); + EXPECT_MAT_NEAR(dst_roi, roi, threshold); + } +}; + +OCL_TEST_P(Resize, Mat) +{ + for (int j = 0; j < LOOP_TIMES; j++) + { + random_roi(); + + resize(src_roi, dst_roi, Size(), fx, fy, interpolation); + ocl::resize(gsrc_roi, gdst_roi, Size(), fx, fy, interpolation); + + Near(1.0); + } +} + +///////////////////////////////////////////////////////////////////////////////////// + +INSTANTIATE_TEST_CASE_P(ImgprocWarp, WarpAffine, Combine( + Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), + Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC), + Bool(), + Bool())); + +INSTANTIATE_TEST_CASE_P(ImgprocWarp, WarpPerspective, Combine( + Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), + Values((int)INTER_NEAREST, (int)INTER_LINEAR, (int)INTER_CUBIC), + Bool(), + Bool())); + +INSTANTIATE_TEST_CASE_P(ImgprocWarp, Remap_INTER_LINEAR, Combine( + testing::Values(CV_8U, CV_16U, CV_16S, CV_32F, CV_64F), + testing::Range(1, 5), + Values(make_pair(CV_32FC1, CV_32FC1), + make_pair(CV_32FC2, noType)), + Values((int)BORDER_CONSTANT), + Bool())); + +INSTANTIATE_TEST_CASE_P(ImgprocWarp, Remap_INTER_NEAREST, Combine( + testing::Values(CV_8U, CV_16U, CV_16S, CV_32F, CV_64F), + testing::Range(1, 5), + Values(make_pair(CV_32FC1, CV_32FC1), + make_pair(CV_32FC2, noType), + make_pair(CV_16SC2, noType)), + Values((int)BORDER_CONSTANT), + Bool())); + +INSTANTIATE_TEST_CASE_P(ImgprocWarp, Resize, Combine( + Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), + Values(0.5, 1.5, 2.0), + Values(0.5, 1.5, 2.0), + Values((int)INTER_NEAREST, (int)INTER_LINEAR), + Bool())); + +#endif // HAVE_OPENCL -- 2.7.4