///////////// Lut ////////////////////////
PERFTEST(lut)
{
- Mat src, lut, dst;
+ Mat src, lut, dst, ocl_dst;
ocl::oclMat d_src, d_lut, d_dst;
int all_type[] = {CV_8UC1, CV_8UC3};
ocl::LUT(d_src, d_lut, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0));
-
GPU_ON;
ocl::LUT(d_src, d_lut, d_dst);
GPU_OFF;
d_src.upload(src);
d_lut.upload(lut);
ocl::LUT(d_src, d_lut, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0);
}
}
///////////// Exp ////////////////////////
PERFTEST(Exp)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
ocl::exp(d_src, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 2));
-
GPU_ON;
ocl::exp(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::exp(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 2);
}
}
///////////// LOG ////////////////////////
PERFTEST(Log)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
ocl::log(d_src, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1));
-
GPU_ON;
ocl::log(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::log(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
}
///////////// Add ////////////////////////
PERFTEST(Add)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_8UC1, CV_32FC1};
CPU_ON;
add(src1, src2, dst);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::add(d_src1, d_src2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::add(d_src1, d_src2, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::add(d_src1, d_src2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// Mul ////////////////////////
PERFTEST(Mul)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
ocl::multiply(d_src1, d_src2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::multiply(d_src1, d_src2, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::multiply(d_src1, d_src2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// Div ////////////////////////
PERFTEST(Div)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
CPU_ON;
divide(src1, src2, dst);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::divide(d_src1, d_src2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1));
-
GPU_ON;
ocl::divide(d_src1, d_src2, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::divide(d_src1, d_src2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
}
///////////// Absdiff ////////////////////////
PERFTEST(Absdiff)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
CPU_ON;
absdiff(src1, src2, dst);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::absdiff(d_src1, d_src2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::absdiff(d_src1, d_src2, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::absdiff(d_src1, d_src2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// CartToPolar ////////////////////////
PERFTEST(CartToPolar)
{
- Mat src1, src2, dst, dst1;
+ Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
int all_type[] = {CV_32FC1};
CPU_ON;
cartToPolar(src1, src2, dst, dst1, 1);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- cv::Mat ocl_mat_dst1;
- d_dst1.download(ocl_mat_dst1);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst1, dst1, 0.5)&&ExpectedMatNear(ocl_mat_dst, dst, 0.5));
-
GPU_ON;
ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1);
- d_dst.download(dst);
- d_dst1.download(dst1);
+ d_dst.download(ocl_dst);
+ d_dst1.download(ocl_dst1);
GPU_FULL_OFF;
+
+ double diff1 = checkNorm(ocl_dst1, dst1);
+ double diff2 = checkNorm(ocl_dst, dst);
+ double max_diff = max(diff1, diff2);
+ TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff);
+
}
}
///////////// PolarToCart ////////////////////////
PERFTEST(PolarToCart)
{
- Mat src1, src2, dst, dst1;
+ Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1;
ocl::oclMat d_src1, d_src2, d_dst, d_dst1;
int all_type[] = {CV_32FC1};
ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- cv::Mat ocl_mat_dst1;
- d_dst1.download(ocl_mat_dst1);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst1, dst1, 0.5)&&ExpectedMatNear(ocl_mat_dst, dst, 0.5));
-
GPU_ON;
ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1);
- d_dst.download(dst);
- d_dst1.download(dst1);
+ d_dst.download(ocl_dst);
+ d_dst1.download(ocl_dst1);
GPU_FULL_OFF;
+
+ double diff1 = checkNorm(ocl_dst1, dst1);
+ double diff2 = checkNorm(ocl_dst, dst);
+ double max_diff = max(diff1, diff2);
+ TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff);
+
}
}
///////////// Magnitude ////////////////////////
PERFTEST(magnitude)
{
- Mat x, y, mag;
+ Mat x, y, mag, ocl_mag;
ocl::oclMat d_x, d_y, d_mag;
int all_type[] = {CV_32FC1};
ocl::magnitude(d_x, d_y, d_mag);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_mag.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, mag, 1e-5));
-
GPU_ON;
ocl::magnitude(d_x, d_y, d_mag);
GPU_OFF;
d_x.upload(x);
d_y.upload(y);
ocl::magnitude(d_x, d_y, d_mag);
- d_mag.download(mag);
+ d_mag.download(ocl_mag);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_mag, mag, 1e-5);
}
}
///////////// Transpose ////////////////////////
PERFTEST(Transpose)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
ocl::transpose(d_src, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1e-5));
-
GPU_ON;
ocl::transpose(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::transpose(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
///////////// Flip ////////////////////////
PERFTEST(Flip)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
ocl::flip(d_src, d_dst, 0);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1e-5));
-
GPU_ON;
ocl::flip(d_src, d_dst, 0);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::flip(d_src, d_dst, 0);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
ocl::minMax(d_src, &min_val_, &max_val_);
WARMUP_OFF;
- TestSystem::instance().setAccurate(EeceptDoubleEQ<double>(max_val_, max_val)&&EeceptDoubleEQ<double>(min_val_, min_val));
+ if(EeceptDoubleEQ<double>(max_val_, max_val) && EeceptDoubleEQ<double>(min_val_, min_val))
+ TestSystem::instance().setAccurate(1, max(fabs(max_val_-max_val), fabs(min_val_-min_val)));
+ else
+ TestSystem::instance().setAccurate(0, max(fabs(max_val_-max_val), fabs(min_val_-min_val)));
GPU_ON;
ocl::minMax(d_src, &min_val, &max_val);
minlocVal_ = src.at<unsigned char>(min_loc_);
maxlocVal = src.at<unsigned char>(max_loc);
maxlocVal_ = src.at<unsigned char>(max_loc_);
- error0 = ::abs(src.at<unsigned char>(min_loc_) - src.at<unsigned char>(min_loc));
- error1 = ::abs(src.at<unsigned char>(max_loc_) - src.at<unsigned char>(max_loc));
}
if(src.depth() == 1)
{
minlocVal_ = src.at<signed char>(min_loc_);
maxlocVal = src.at<signed char>(max_loc);
maxlocVal_ = src.at<signed char>(max_loc_);
- error0 = ::abs(src.at<signed char>(min_loc_) - src.at<signed char>(min_loc));
- error1 = ::abs(src.at<signed char>(max_loc_) - src.at<signed char>(max_loc));
}
if(src.depth() == 2)
{
minlocVal_ = src.at<unsigned short>(min_loc_);
maxlocVal = src.at<unsigned short>(max_loc);
maxlocVal_ = src.at<unsigned short>(max_loc_);
- error0 = ::abs(src.at<unsigned short>(min_loc_) - src.at<unsigned short>(min_loc));
- error1 = ::abs(src.at<unsigned short>(max_loc_) - src.at<unsigned short>(max_loc));
}
if(src.depth() == 3)
{
minlocVal_ = src.at<signed short>(min_loc_);
maxlocVal = src.at<signed short>(max_loc);
maxlocVal_ = src.at<signed short>(max_loc_);
- error0 = ::abs(src.at<signed short>(min_loc_) - src.at<signed short>(min_loc));
- error1 = ::abs(src.at<signed short>(max_loc_) - src.at<signed short>(max_loc));
}
if(src.depth() == 4)
{
minlocVal_ = src.at<int>(min_loc_);
maxlocVal = src.at<int>(max_loc);
maxlocVal_ = src.at<int>(max_loc_);
- error0 = ::abs(src.at<int>(min_loc_) - src.at<int>(min_loc));
- error1 = ::abs(src.at<int>(max_loc_) - src.at<int>(max_loc));
}
if(src.depth() == 5)
{
minlocVal_ = src.at<float>(min_loc_);
maxlocVal = src.at<float>(max_loc);
maxlocVal_ = src.at<float>(max_loc_);
- error0 = ::abs(src.at<float>(min_loc_) - src.at<float>(min_loc));
- error1 = ::abs(src.at<float>(max_loc_) - src.at<float>(max_loc));
}
if(src.depth() == 6)
{
minlocVal_ = src.at<double>(min_loc_);
maxlocVal = src.at<double>(max_loc);
maxlocVal_ = src.at<double>(max_loc_);
- error0 = ::abs(src.at<double>(min_loc_) - src.at<double>(min_loc));
- error1 = ::abs(src.at<double>(max_loc_) - src.at<double>(max_loc));
}
-
- TestSystem::instance().setAccurate(EeceptDoubleEQ<double>(error1, 0.0)
- &&EeceptDoubleEQ<double>(error0, 0.0)
- &&EeceptDoubleEQ<double>(maxlocVal_, maxlocVal)
+ error0 = ::abs(minlocVal_ - minlocVal);
+ error1 = ::abs(maxlocVal_ - maxlocVal);
+ if( EeceptDoubleEQ<double>(maxlocVal_, maxlocVal)
&&EeceptDoubleEQ<double>(minlocVal_, minlocVal)
&&EeceptDoubleEQ<double>(max_val_, max_val)
- &&EeceptDoubleEQ<double>(min_val_, min_val));
+ &&EeceptDoubleEQ<double>(min_val_, min_val))
+ TestSystem::instance().setAccurate(1, 0.);
+ else
+ TestSystem::instance().setAccurate(0, max(error0, error1));
GPU_ON;
ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
gpures = ocl::sum(d_src);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExceptDoubleNear(cpures[3], gpures[3], 0.1)
- &&ExceptDoubleNear(cpures[2], gpures[2], 0.1)
- &&ExceptDoubleNear(cpures[1], gpures[1], 0.1)
- &&ExceptDoubleNear(cpures[0], gpures[0], 0.1));
-
+ vector<double> diffs(4);
+ diffs[3] = fabs(cpures[3] - gpures[3]);
+ diffs[2] = fabs(cpures[2] - gpures[2]);
+ diffs[1] = fabs(cpures[1] - gpures[1]);
+ diffs[0] = fabs(cpures[0] - gpures[0]);
+ double max_diff = *max_element(diffs.begin(), diffs.end());
+ TestSystem::instance().setAccurate(max_diff<0.1?1:0, max_diff);
GPU_ON;
gpures = ocl::sum(d_src);
gpures = ocl::countNonZero(d_src);
WARMUP_OFF;
- TestSystem::instance().setAccurate((EeceptDoubleEQ<double>((double)cpures, (double)gpures)));
+ int diff = abs(cpures - gpures);
+ if(diff == 0)
+ TestSystem::instance().setAccurate(1, 0);
+ else
+ TestSystem::instance().setAccurate(0, diff);
GPU_ON;
ocl::countNonZero(d_src);
///////////// Phase ////////////////////////
PERFTEST(Phase)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_32FC1};
gen(src2, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
phase(src1, src2, dst, 1);
CPU_ON;
phase(src1, src2, dst, 1);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::phase(d_src1, d_src2, d_dst, 1);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1e-2));
-
GPU_ON;
ocl::phase(d_src1, d_src2, d_dst, 1);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::phase(d_src1, d_src2, d_dst, 1);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-2);
}
}
///////////// bitwise_and////////////////////////
PERFTEST(bitwise_and)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_8UC1, CV_32SC1};
gen(src2, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
bitwise_and(src1, src2, dst);
CPU_ON;
ocl::bitwise_and(d_src1, d_src2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::bitwise_and(d_src1, d_src2, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::bitwise_and(d_src1, d_src2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// bitwise_not////////////////////////
PERFTEST(bitwise_not)
{
- Mat src1, dst;
+ Mat src1, dst, ocl_dst;
ocl::oclMat d_src1, d_dst;
int all_type[] = {CV_8UC1, CV_32SC1};
gen(src1, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
bitwise_not(src1, dst);
CPU_ON;
ocl::bitwise_not(d_src1, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::bitwise_not(d_src1, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src1.upload(src1);
ocl::bitwise_not(d_src1, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// compare////////////////////////
PERFTEST(compare)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int CMP_EQ = 0;
gen(src2, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
compare(src1, src2, dst, CMP_EQ);
CPU_ON;
compare(src1, src2, dst, CMP_EQ);
CPU_OFF;
+
d_src1.upload(src1);
d_src2.upload(src2);
ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 0.0));
-
GPU_ON;
ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::compare(d_src1, d_src2, d_dst, CMP_EQ);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0);
}
}
///////////// pow ////////////////////////
PERFTEST(pow)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_32FC1};
ocl::pow(d_src, -2.0, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1.0));
-
GPU_ON;
ocl::pow(d_src, -2.0, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::pow(d_src, -2.0, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
}
///////////// MagnitudeSqr////////////////////////
PERFTEST(MagnitudeSqr)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
int all_type[] = {CV_32FC1};
gen(src2, size, size, all_type[t], 0, 256);
gen(dst, size, size, all_type[t], 0, 256);
-
+ CPU_ON;
for (int i = 0; i < src1.rows; ++i)
-
for (int j = 0; j < src1.cols; ++j)
{
float val1 = src1.at<float>(i, j);
float val2 = src2.at<float>(i, j);
-
((float *)(dst.data))[i * dst.step / 4 + j] = val1 * val1 + val2 * val2;
}
+ CPU_OFF;
- CPU_ON;
-
- for (int i = 0; i < src1.rows; ++i)
- for (int j = 0; j < src1.cols; ++j)
- {
- float val1 = src1.at<float>(i, j);
- float val2 = src2.at<float>(i, j);
-
- ((float *)(dst.data))[i * dst.step / 4 + j] = val1 * val1 + val2 * val2;
-
- }
-
- CPU_OFF;
- d_src1.upload(src1);
- d_src2.upload(src2);
-
- WARMUP_ON;
- ocl::magnitudeSqr(d_src1, d_src2, d_dst);
- WARMUP_OFF;
+ d_src1.upload(src1);
+ d_src2.upload(src2);
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
+ WARMUP_ON;
+ ocl::magnitudeSqr(d_src1, d_src2, d_dst);
+ WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1.0));
+ GPU_ON;
+ ocl::magnitudeSqr(d_src1, d_src2, d_dst);
+ GPU_OFF;
- GPU_ON;
- ocl::magnitudeSqr(d_src1, d_src2, d_dst);
- GPU_OFF;
+ GPU_FULL_ON;
+ d_src1.upload(src1);
+ d_src2.upload(src2);
+ ocl::magnitudeSqr(d_src1, d_src2, d_dst);
+ d_dst.download(ocl_dst);
+ GPU_FULL_OFF;
- GPU_FULL_ON;
- d_src1.upload(src1);
- d_src2.upload(src2);
- ocl::magnitudeSqr(d_src1, d_src2, d_dst);
- d_dst.download(dst);
- GPU_FULL_OFF;
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
}
///////////// AddWeighted////////////////////////
PERFTEST(AddWeighted)
{
- Mat src1, src2, dst;
+ Mat src1, src2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_dst;
double alpha = 2.0, beta = 1.0, gama = 3.0;
ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat_dst;
- d_dst.download(ocl_mat_dst);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat_dst, dst, 1e-5));
-
GPU_ON;
ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
GPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
}
PERFTEST(blend)
{
- Mat src1, src2, weights1, weights2, dst;
+ Mat src1, src2, weights1, weights2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat;
- d_dst.download(ocl_mat);
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, ocl_mat, 1.f));
-
GPU_ON;
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
GPU_OFF;
d_weights1.upload(weights1);
d_weights2.upload(weights2);
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f);
}
}
}
\ No newline at end of file
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
WARMUP_OFF;
- d_matcher.match(d_query, d_train, d_matches[0]);
- TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
-
GPU_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
GPU_OFF;
d_matcher.match(d_query, d_train, matches[0]);
GPU_FULL_OFF;
+ int diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+ if(diff == 0)
+ TestSystem::instance().setAccurate(1, 0);
+ else
+ TestSystem::instance().setAccurate(0, diff);
+
SUBTEST << size << "; knnMatch";
matcher.knnMatch(query, train, matches, 2);
d_matcher.knnMatch(d_query, d_train, d_matches, 2);
GPU_FULL_OFF;
- TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
+ diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+ if(diff == 0)
+ TestSystem::instance().setAccurate(1, 0);
+ else
+ TestSystem::instance().setAccurate(0, diff);
SUBTEST << size << "; radiusMatch";
d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance);
GPU_FULL_OFF;
- TestSystem::instance().setAccurate(AssertEQ<size_t>(d_matches[0].size(), matches[0].size()));
+ diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+ if(diff == 0)
+ TestSystem::instance().setAccurate(1, 0);
+ else
+ TestSystem::instance().setAccurate(0, diff);
}
}
\ No newline at end of file
SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1";
- Mat edges(img.size(), CV_8UC1);
+ Mat edges(img.size(), CV_8UC1), ocl_edges;
CPU_ON;
Canny(img, edges, 50.0, 100.0);
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExceptedMatSimilar(edges, d_edges, 2e-2));
-
GPU_ON;
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
GPU_OFF;
GPU_FULL_ON;
d_img.upload(img);
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
- d_edges.download(edges);
+ d_edges.download(ocl_edges);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
}
\ No newline at end of file
///////////// cvtColor////////////////////////
PERFTEST(cvtColor)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC4};
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
WARMUP_OFF;
- cv::Mat ocl_mat;
- d_dst.download(ocl_mat);
- TestSystem::instance().setAccurate(ExceptedMatSimilar(dst, ocl_mat, 1e-5));
-
GPU_ON;
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5);
}
///////////// columnSum////////////////////////
PERFTEST(columnSum)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
dst.at<float>(0, j) = src.at<float>(0, j);
for (int i = 1; i < src.rows; ++i)
- {for (int j = 0; j < src.cols; ++j)
- {
+ for (int j = 0; j < src.cols; ++j)
dst.at<float>(i, j) = dst.at<float>(i - 1 , j) + src.at<float>(i , j);
- }
- }
-
CPU_OFF;
d_src.upload(src);
+
WARMUP_ON;
ocl::columnSum(d_src, d_dst);
WARMUP_OFF;
- cv::Mat ocl_mat;
- d_dst.download(ocl_mat);
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, ocl_mat, 5e-1));
-
GPU_ON;
ocl::columnSum(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::columnSum(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 5e-1);
}
}
\ No newline at end of file
///////////// dft ////////////////////////
PERFTEST(dft)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_32FC2};
ocl::dft(d_src, d_dst, Size(size, size));
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), src.size().area() * 1e-4));
-
GPU_ON;
ocl::dft(d_src, d_dst, Size(size, size));
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::dft(d_src, d_dst, Size(size, size));
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4);
}
}
///////////// Blur////////////////////////
PERFTEST(Blur)
{
- Mat src1, dst;
+ Mat src1, dst, ocl_dst;
ocl::oclMat d_src1, d_dst;
Size ksize = Size(3, 3);
gen(src1, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
blur(src1, dst, ksize, Point(-1, -1), bordertype);
CPU_ON;
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1.0));
-
GPU_ON;
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
GPU_OFF;
GPU_FULL_ON;
d_src1.upload(src1);
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
}
///////////// Laplacian////////////////////////
PERFTEST(Laplacian)
{
- Mat src1, dst;
+ Mat src1, dst, ocl_dst;
ocl::oclMat d_src1, d_dst;
int ksize = 3;
gen(src1, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
-
Laplacian(src1, dst, -1, ksize, 1);
CPU_ON;
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));
-
GPU_ON;
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
GPU_OFF;
GPU_FULL_ON;
d_src1.upload(src1);
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
///////////// Erode ////////////////////
PERFTEST(Erode)
{
- Mat src, dst, ker;
+ Mat src, dst, ker, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
ocl::erode(d_src, d_dst, ker);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));
-
GPU_ON;
ocl::erode(d_src, d_dst, ker);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::erode(d_src, d_dst, ker);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
///////////// Sobel ////////////////////////
PERFTEST(Sobel)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int dx = 1;
ocl::Sobel(d_src, d_dst, -1, dx, dy);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1));
-
GPU_ON;
ocl::Sobel(d_src, d_dst, -1, dx, dy);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::Sobel(d_src, d_dst, -1, dx, dy);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
}
///////////// Scharr ////////////////////////
PERFTEST(Scharr)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int dx = 1;
ocl::Scharr(d_src, d_dst, -1, dx, dy);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1));
-
GPU_ON;
ocl::Scharr(d_src, d_dst, -1, dx, dy);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::Scharr(d_src, d_dst, -1, dx, dy);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
}
///////////// GaussianBlur ////////////////////////
PERFTEST(GaussianBlur)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"};
ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1.0));
-
-
GPU_ON;
ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::GaussianBlur(d_src, d_dst, Size(9, 9), 0);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
}
Mat kernel;
gen(kernel, ksize, ksize, CV_32FC1, 0.0, 1.0);
- Mat dst(src);
+ Mat dst, ocl_dst;
dst.setTo(0);
cv::filter2D(src, dst, -1, kernel);
cv::filter2D(src, dst, -1, kernel);
CPU_OFF;
- ocl::oclMat d_src(src);
- ocl::oclMat d_dst(d_src);
- d_dst.setTo(0);
+ ocl::oclMat d_src(src), d_dst;
WARMUP_ON;
ocl::filter2D(d_src, d_dst, -1, kernel);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, 1e-5));
-
-
GPU_ON;
ocl::filter2D(d_src, d_dst, -1, kernel);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::filter2D(d_src, d_dst, -1, kernel);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
}
///////////// gemm ////////////////////////
PERFTEST(gemm)
{
- Mat src1, src2, src3, dst;
+ Mat src1, src2, src3, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_src3, d_dst;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
WARMUP_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(d_dst), dst, src1.cols * src1.rows * 1e-4));
GPU_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
d_src2.upload(src2);
d_src3.upload(src3);
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
}
}
\ No newline at end of file
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
WARMUP_OFF;
- //Testing whether the expected is equal to the actual.
- TestSystem::instance().setAccurate(ExpectedEQ<vector<Rect>::size_type, vector<Rect>::size_type>(faces.size(), oclfaces.size()));
+ if(faces.size() == oclfaces.size())
+ TestSystem::instance().setAccurate(1, 0);
+ else
+ TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
faces.clear();
}
}
- cv::Mat ocl_mat;
- ocl_mat = cv::Mat(d_comp);
- ocl_mat.convertTo(ocl_mat, cv::Mat(comp).type());
- TestSystem::instance().setAccurate(ExpectedMatNear(ocl_mat, cv::Mat(comp), 3));
+ cv::Mat gpu_rst(d_comp), cpu_rst(comp);
+ TestSystem::instance().ExpectedMatNear(gpu_rst, cpu_rst, 3);
GPU_ON;
ocl_hog.detectMultiScale(d_src, found_locations);
///////////// equalizeHist ////////////////////////
PERFTEST(equalizeHist)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1};
std::string type_name[] = {"CV_8UC1"};
ocl::equalizeHist(d_src, d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.1));
-
-
GPU_ON;
ocl::equalizeHist(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::equalizeHist(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.1);
}
}
/////////// CopyMakeBorder //////////////////////
PERFTEST(CopyMakeBorder)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_dst;
int bordertype = BORDER_CONSTANT;
ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0));
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));
-
-
GPU_ON;
ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0));
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0));
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
}
///////////// cornerMinEigenVal ////////////////////////
PERFTEST(cornerMinEigenVal)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_dst;
int blockSize = 7, apertureSize = 1 + 2 * (rand() % 4);
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
-
gen(src, size, size, all_type[j], 0, 256);
cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType);
ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
-
GPU_ON;
ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
///////////// cornerHarris ////////////////////////
PERFTEST(cornerHarris)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_32FC1};
ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
GPU_ON;
ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
///////////// integral ////////////////////////
PERFTEST(integral)
{
- Mat src, sum;
+ Mat src, sum, ocl_sum;
ocl::oclMat d_src, d_sum, d_buf;
int all_type[] = {CV_8UC1};
ocl::integral(d_src, d_sum);
WARMUP_OFF;
- cv::Mat ocl_mat;
- d_sum.download(ocl_mat);
- if(sum.type() == ocl_mat.type()) //we won't test accuracy when cpu function overlow
- TestSystem::instance().setAccurate(ExpectedMatNear(sum, ocl_mat, 0.0));
-
-
GPU_ON;
ocl::integral(d_src, d_sum);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::integral(d_src, d_sum);
- d_sum.download(sum);
+ d_sum.download(ocl_sum);
GPU_FULL_OFF;
+
+ if(sum.type() == ocl_sum.type()) //we won't test accuracy when cpu function overlow
+ TestSystem::instance().ExpectedMatNear(sum, ocl_sum, 0.0);
+
}
}
///////////// WarpAffine ////////////////////////
PERFTEST(WarpAffine)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
static const double coeffs[2][3] =
ocl::warpAffine(d_src, d_dst, M, size1, interpolation);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
GPU_ON;
ocl::warpAffine(d_src, d_dst, M, size1, interpolation);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::warpAffine(d_src, d_dst, M, size1, interpolation);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
///////////// WarpPerspective ////////////////////////
PERFTEST(WarpPerspective)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
static const double coeffs[3][3] =
ocl::warpPerspective(d_src, d_dst, M, size1, interpolation);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
GPU_ON;
ocl::warpPerspective(d_src, d_dst, M, size1, interpolation);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::warpPerspective(d_src, d_dst, M, size1, interpolation);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
///////////// resize ////////////////////////
PERFTEST(resize)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
ocl::resize(d_src, d_dst, Size(), 2.0, 2.0);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
-
GPU_ON;
ocl::resize(d_src, d_dst, Size(), 2.0, 2.0);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::resize(d_src, d_dst, Size(), 2.0, 2.0);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
ocl::resize(d_src, d_dst, Size(), 0.5, 0.5);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
GPU_ON;
ocl::resize(d_src, d_dst, Size(), 0.5, 0.5);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::resize(d_src, d_dst, Size(), 0.5, 0.5);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
///////////// threshold////////////////////////
PERFTEST(threshold)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
-
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size << "; 8UC1; THRESH_BINARY";
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
-
GPU_ON;
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
-
GPU_ON;
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0);
}
}
///////////// meanShiftFiltering////////////////////////
PERFTEST(meanShiftFiltering)
{
int sp = 5, sr = 6;
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
ocl::meanShiftFiltering(d_src, d_dst, sp, sr, crit);
WARMUP_OFF;
- cv::Mat ocl_mat;
- d_dst.download(ocl_mat);
-
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, ocl_mat, 0.0));
-
GPU_ON;
ocl::meanShiftFiltering(d_src, d_dst, sp, sr);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::meanShiftFiltering(d_src, d_dst, sp, sr);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
}
///////////// meanShiftProc////////////////////////
}
PERFTEST(meanShiftProc)
{
- Mat src, dst, dstCoor_roi;
- ocl::oclMat d_src, d_dst, d_dstCoor_roi;
+ Mat src;
+ vector<Mat> dst(2), ocl_dst(2);
+ ocl::oclMat d_src, d_dst, d_dstCoor;
TermCriteria crit(TermCriteria::COUNT + TermCriteria::EPS, 5, 1);
SUBTEST << size << 'x' << size << "; 8UC4 and CV_16SC2 ";
gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
- gen(dst, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
- gen(dstCoor_roi, size, size, CV_16SC2, Scalar::all(0), Scalar::all(256));
+ gen(dst[0], size, size, CV_8UC4, Scalar::all(0), Scalar::all(256));
+ gen(dst[1], size, size, CV_16SC2, Scalar::all(0), Scalar::all(256));
- meanShiftProc_(src, dst, dstCoor_roi, 5, 6, crit);
+ meanShiftProc_(src, dst[0], dst[1], 5, 6, crit);
CPU_ON;
- meanShiftProc_(src, dst, dstCoor_roi, 5, 6, crit);
+ meanShiftProc_(src, dst[0], dst[1], 5, 6, crit);
CPU_OFF;
d_src.upload(src);
WARMUP_ON;
- ocl::meanShiftProc(d_src, d_dst, d_dstCoor_roi, 5, 6, crit);
+ ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dstCoor_roi, cv::Mat(d_dstCoor_roi), 0.0)
- &&ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));
-
GPU_ON;
- ocl::meanShiftProc(d_src, d_dst, d_dstCoor_roi, 5, 6, crit);
+ ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
- ocl::meanShiftProc(d_src, d_dst, d_dstCoor_roi, 5, 6, crit);
- d_dst.download(dst);
- d_dstCoor_roi.download(dstCoor_roi);
+ ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit);
+ d_dst.download(ocl_dst[0]);
+ d_dstCoor.download(ocl_dst[1]);
GPU_FULL_OFF;
+ vector<double> eps(2, 0.);
+ TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps);
}
}
///////////// remap////////////////////////
PERFTEST(remap)
{
- Mat src, dst, xmap, ymap;
+ Mat src, dst, xmap, ymap, ocl_dst;
ocl::oclMat d_src, d_dst, d_xmap, d_ymap;
int all_type[] = {CV_8UC1, CV_8UC4};
}
}
-
remap(src, dst, xmap, ymap, interpolation, borderMode);
CPU_ON;
ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
WARMUP_OFF;
- if(interpolation == 0)
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 1.0));
- else
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 2.0));
-
-
GPU_ON;
ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 2.0);
}
}
PERFTEST(matchTemplate)
{
//InitMatchTemplate();
-
- Mat src, templ, dst;
+ Mat src, templ, dst, ocl_dst;
int templ_size = 5;
-
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
int all_type[] = {CV_32FC1, CV_32FC4};
matchTemplate(src, templ, dst, CV_TM_CCORR);
CPU_OFF;
- ocl::oclMat d_src(src), d_templ, d_dst;
-
- d_templ.upload(templ);
+ ocl::oclMat d_src(src), d_templ(templ), d_dst;
WARMUP_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), templ.rows * templ.cols * 1e-1));
-
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
GPU_OFF;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), templ.rows * templ.cols * 1e-1));
-
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
GPU_OFF;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
}
///////////// ConvertTo////////////////////////
PERFTEST(ConvertTo)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
d_src.convertTo(d_dst, CV_32FC1);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));
-
-
GPU_ON;
d_src.convertTo(d_dst, CV_32FC1);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
d_src.convertTo(d_dst, CV_32FC1);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
}
///////////// copyTo////////////////////////
PERFTEST(copyTo)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
d_src.copyTo(d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), 0.0));
-
-
GPU_ON;
d_src.copyTo(d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
d_src.copyTo(d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
}
///////////// setTo////////////////////////
PERFTEST(setTo)
{
- Mat src, dst;
+ Mat src, ocl_src;
Scalar val(1, 2, 3, 4);
- ocl::oclMat d_src, d_dst;
+ ocl::oclMat d_src;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
d_src.setTo(val);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(src, cv::Mat(d_src), 1.0));
+ d_src.download(ocl_src);
+ TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0);
-
- GPU_ON;
+ GPU_ON;;
d_src.setTo(val);
GPU_OFF;
///////////// norm////////////////////////
PERFTEST(norm)
{
- Mat src, buf;
- ocl::oclMat d_src, d_buf;
-
+ Mat src1, src2, ocl_src1;
+ ocl::oclMat d_src1, d_src2;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size << "; CV_8UC1; NORM_INF";
- gen(src, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
- gen(buf, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
+ gen(src1, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
+ gen(src2, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
- norm(src, NORM_INF);
+ norm(src1, src2, NORM_INF);
CPU_ON;
- norm(src, NORM_INF);
+ norm(src1, src2, NORM_INF);
CPU_OFF;
- d_src.upload(src);
- d_buf.upload(buf);
+ d_src1.upload(src1);
+ d_src2.upload(src2);
WARMUP_ON;
- ocl::norm(d_src, d_buf, NORM_INF);
+ ocl::norm(d_src1, d_src2, NORM_INF);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(src, cv::Mat(d_buf), .5));
+ d_src1.download(ocl_src1);
+ TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5);
GPU_ON;
- ocl::norm(d_src, d_buf, NORM_INF);
+ ocl::norm(d_src1, d_src2, NORM_INF);
GPU_OFF;
GPU_FULL_ON;
- d_src.upload(src);
- ocl::norm(d_src, d_buf, NORM_INF);
+ d_src1.upload(src1);
+ d_src2.upload(src2);
+ ocl::norm(d_src1, d_src2, NORM_INF);
GPU_FULL_OFF;
}
}
\ No newline at end of file
///////////// pyrDown //////////////////////
PERFTEST(pyrDown)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
ocl::pyrDown(d_src, d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), dst.depth() == CV_32F ? 1e-4f : 1.0f));
-
-
GPU_ON;
ocl::pyrDown(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::pyrDown(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, dst.depth() == CV_32F ? 1e-4f : 1.0f);
}
}
}
\ No newline at end of file
SUBTEST << frame0.cols << "x" << frame0.rows << "; color; " << points << " points";
else
SUBTEST << frame0.cols << "x" << frame0.rows << "; gray; " << points << " points";
- Mat nextPts_cpu;
- Mat status_cpu;
+ Mat ocl_nextPts;
+ Mat ocl_status;
vector<Point2f> pts;
goodFeaturesToTrack(i == 0 ? gray_frame : frame0, pts, points, 0.01, 0.0);
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
WARMUP_OFF;
- std::vector<cv::Point2f> ocl_nextPts(d_nextPts.cols);
- std::vector<unsigned char> ocl_status(d_status.cols);
- TestSystem::instance().setAccurate(AssertEQ<size_t>(nextPts.size(), ocl_nextPts.size()));
- TestSystem::instance().setAccurate(AssertEQ<size_t>(status.size(), ocl_status.size()));
-
-
GPU_ON;
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
GPU_OFF;
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
if (!d_nextPts.empty())
- {
- d_nextPts.download(nextPts_cpu);
- }
+ d_nextPts.download(ocl_nextPts);
if (!d_status.empty())
+ d_status.download(ocl_status);
+ GPU_FULL_OFF;
+
+ size_t mismatch = 0;
+ for (int i = 0; i < (int)nextPts.size(); ++i)
{
- d_status.download(status_cpu);
+ if(status[i] != ocl_status.at<unsigned char>(0, i)){
+ mismatch++;
+ continue;
+ }
+ if(status[i]){
+ Point2f gpu_rst = ocl_nextPts.at<Point2f>(0, i);
+ Point2f cpu_rst = nextPts[i];
+ if(fabs(gpu_rst.x - cpu_rst.x) >= 1. || fabs(gpu_rst.y - cpu_rst.y) >= 1.)
+ mismatch++;
+ }
}
-
- GPU_FULL_OFF;
+ double ratio = (double)mismatch / (double)nextPts.size();
+ if(ratio < .02)
+ TestSystem::instance().setAccurate(1, ratio);
+ else
+ TestSystem::instance().setAccurate(0, ratio);
}
}
///////////// pyrUp ////////////////////////
PERFTEST(pyrUp)
{
- Mat src, dst;
+ Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
ocl::pyrUp(d_src, d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(dst, cv::Mat(d_dst), (src.depth() == CV_32F ? 1e-4f : 1.0)));
-
GPU_ON;
ocl::pyrUp(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl::pyrUp(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, (src.depth() == CV_32F ? 1e-4f : 1.0));
}
}
}
\ No newline at end of file
///////////// Merge////////////////////////
PERFTEST(Merge)
{
- Mat dst;
+ Mat dst, ocl_dst;
ocl::oclMat d_dst;
int channels = 4;
ocl::merge(d_src, d_dst);
WARMUP_OFF;
- TestSystem::instance().setAccurate(ExpectedMatNear(cv::Mat(dst), cv::Mat(d_dst), 0.0));
-
GPU_ON;
ocl::merge(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
-
for (int i = 0; i < channels; ++i)
{
- d_src[i] = ocl::oclMat(size1, CV_8U, cv::Scalar::all(i));
+ d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i));
}
-
ocl::merge(d_src, d_dst);
- d_dst.download(dst);
+ d_dst.download(ocl_dst);
GPU_FULL_OFF;
+
+ TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
}
Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4));
- std::vector<cv::Mat> dst;
+ std::vector<cv::Mat> dst, ocl_dst(4);
split(src, dst);
WARMUP_ON;
ocl::split(d_src, d_dst);
- WARMUP_OFF;
-
- if(d_dst.size() == dst.size())
- {
- TestSystem::instance().setAccurate(1);
- for(size_t i = 0; i < dst.size(); i++)
- {
- if(ExpectedMatNear(dst[i], cv::Mat(d_dst[i]), 0.0) == 0)
- {
- TestSystem::instance().setAccurate(0);
- break;
- }
- }
- }else
- TestSystem::instance().setAccurate(0);
-
+ WARMUP_OFF;
GPU_ON;
ocl::split(d_src, d_dst);
GPU_FULL_ON;
d_src.upload(src);
ocl::split(d_src, d_dst);
+ for(size_t i = 0; i < dst.size(); i++)
+ d_dst[i].download(ocl_dst[i]);
GPU_FULL_OFF;
+
+ vector<double> eps(4, 0.);
+ TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps);
}
}
return;
}
- int is_accurate = is_accurate_;
double cpu_time = cpu_elapsed_ / getTickFrequency() * 1000.0;
double gpu_time = gpu_elapsed_ / getTickFrequency() * 1000.0;
double gpu_full_time = gpu_full_elapsed_ / getTickFrequency() * 1000.0;
deviation = std::sqrt(sum / gpu_times_.size());
}
- printMetrics(is_accurate, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup);
- writeMetrics(is_accurate, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation);
+ printMetrics(is_accurate_, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup);
+ writeMetrics(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation);
num_subtests_called_++;
resetCurrentSubtest();
}
}
- fprintf(record_, "NAME,DESCRIPTION,ACCURACY,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
+ fprintf(record_, "NAME,DESCRIPTION,ACCURACY,DIFFERENCE,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
fflush(record_);
}
#endif
}
-void TestSystem::writeMetrics(int is_accurate, double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
+void TestSystem::writeMetrics(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
{
if (!record_)
{
string _is_accurate_;
- if(is_accurate == 1)
+ if(is_accurate_ == 1)
_is_accurate_ = "Pass";
- else if(is_accurate == 0)
+ else if(is_accurate_ == 0)
_is_accurate_ = "Fail";
- else if(is_accurate == -1)
+ else if(is_accurate_ == -1)
_is_accurate_ = " ";
else
{
- std::cout<<"is_accurate errer: "<<is_accurate<<"\n";
+ std::cout<<"is_accurate errer: "<<is_accurate_<<"\n";
exit(-1);
}
- fprintf(record_, "%s,%s,%s,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n", itname_changed_ ? itname_.c_str() : "",
+ fprintf(record_, "%s,%s,%s,%.2f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
+ itname_changed_ ? itname_.c_str() : "",
cur_subtest_description_.str().c_str(),
- _is_accurate_.c_str(), cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
+ _is_accurate_.c_str(),
+ accurate_diff_,
+ cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
gpu_min, gpu_max, std_dev);
if (itname_changed_)
return std::abs(diff.at<float>(0, 0) - 1.f);
}
-
+/*
int ExpectedMatNear(cv::Mat dst, cv::Mat cpu_dst, double eps)
{
assert(dst.type() == cpu_dst.type());
return 0;
}
-
+/*
int ExceptedMatSimilar(cv::Mat dst, cv::Mat cpu_dst, double eps)
{
assert(dst.type() == cpu_dst.type());
- assert(dst.size() == cpu_dst.size());
+ assert(dst.size() == cpu_dst.size());
if(checkSimilarity(cv::Mat(cpu_dst), cv::Mat(dst)) <= eps)
return 1;
return 0;
}
+*/
itname_changed_ = true;
}
- void setAccurate(int is_accurate = -1)
+ void setAccurate(int accurate, double diff)
{
- is_accurate_ = is_accurate;
+ is_accurate_ = accurate;
+ accurate_diff_ = diff;
+ }
+
+ void ExpectMatsNear(vector<Mat>& dst, vector<Mat>& cpu_dst, vector<double>& eps)
+ {
+ assert(dst.size() == cpu_dst.size());
+ assert(cpu_dst.size() == eps.size());
+ is_accurate_ = 1;
+ for(size_t i=0; i<dst.size(); i++)
+ {
+ double cur_diff = checkNorm(dst[i], cpu_dst[i]);
+ accurate_diff_ = max(accurate_diff_, cur_diff);
+ if(cur_diff > eps[i])
+ is_accurate_ = 0;
+ }
+ }
+
+ void ExpectedMatNear(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
+ {
+ assert(dst.type() == cpu_dst.type());
+ assert(dst.size() == cpu_dst.size());
+ accurate_diff_ = checkNorm(dst, cpu_dst);
+ if(accurate_diff_ <= eps)
+ is_accurate_ = 1;
+ else
+ is_accurate_ = 0;
+ }
+
+ void ExceptedMatSimilar(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
+ {
+ assert(dst.type() == cpu_dst.type());
+ assert(dst.size() == cpu_dst.size());
+ accurate_diff_ = checkSimilarity(cpu_dst, dst);
+ if(accurate_diff_ <= eps)
+ is_accurate_ = 1;
+ else
+ is_accurate_ = 0;
}
std::stringstream &getCurSubtestDescription()
num_iters_(10), cpu_num_iters_(2),
gpu_warmup_iters_(1), cur_iter_idx_(0), cur_warmup_idx_(0),
record_(0), recordname_("performance"), itname_changed_(true),
- is_accurate_(-1)
+ is_accurate_(-1), accurate_diff_(0.)
{
cpu_times_.reserve(num_iters_);
gpu_times_.reserve(num_iters_);
gpu_times_.clear();
gpu_full_times_.clear();
is_accurate_ = -1;
+ accurate_diff_ = 0.;
}
double meanTime(const std::vector<int64> &samples);
void writeHeading();
void writeSummary();
- void writeMetrics(int is_accurate, double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f,
+ void writeMetrics(double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f,
double speedup = 0.0f, double fullspeedup = 0.0f,
double gpu_min = 0.0f, double gpu_max = 0.0f, double std_dev = 0.0f);
bool itname_changed_;
int is_accurate_;
+ double accurate_diff_;
};
projects / platform / upstream / opencv.git / commitdiff