Skip to content

O
opencv
Commit 4a81be7d authored by Ilya Lavrenov's avatar Ilya Lavrenov
Browse files
Options

refactored all the tests in ocl/test/test_imgproc.cpp

parent 4cbf0cb3
Hide whitespace changes
Inline Side-by-side
Showing with 1069 additions and 1403 deletions
modules/ocl/test/test_imgproc.cpp
View file @ 4a81be7d
......@@ -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<MatType> typeVector(MatType type)
{
vector<MatType> 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<ocl::Info> 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>();
int * const hist_row = hist.ptr<int>();
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> clahe = ocl::createCLAHE(clipLimit, gridSize);
clahe->apply(g_src, g_dst);
Mat dst(g_dst);
Ptr<CLAHE> 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> clahe = ocl::createCLAHE(clipLimit, gridSize);
clahe->apply(gsrc_roi, gdst_roi);
int i, j;
int m, n;
Ptr<CLAHE> 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<float>(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<float>(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<float>(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<float>(0);
const float * sptr = src.ptr<float>(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<float>(y);
float * const dptr = dst.ptr<float>(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<float>(0, j);
float res = dst.at<float>(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<float>(i, j) += src.at<float>(i - 1, j);
float res = dst.at<float>(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
modules/ocl/test/test_mean_shift.cpp 0 → 100644
View file @ 4a81be7d
/*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
modules/ocl/test/test_warp.cpp 0 → 100644
View file @ 4a81be7d
/*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<MatType, MatType>, 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<MatType, MatType>(CV_32FC1, CV_32FC1),
make_pair<MatType, MatType>(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<MatType, MatType>(CV_32FC1, CV_32FC1),
make_pair<MatType, MatType>(CV_32FC2, noType),
make_pair<MatType, MatType>(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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment