generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #1593 from ilya-lavrenov:ocl_war_on_double

Browse Source
This commit is contained in:
Andrey Pavlenko 2013-10-10 15:54:07 +04:00 committed by OpenCV Buildbot
commit 37a9c7bdd6
33 changed files with 399 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/core/include/opencv2/core/types_c.h
View File

@ -264,7 +264,9 @@ enum {
CV_GpuNotSupported= -216,
CV_GpuApiCallError= -217,
CV_OpenGlNotSupported= -218,
CV_OpenGlApiCallError= -219
CV_OpenGlApiCallError= -219,
CV_OpenCLDoubleNotSupported= -220,
CV_OpenCLInitError= -221
};
/****************************************************************************************\

24
modules/ocl/perf/perf_kalman.cpp
View File

@ -43,30 +43,33 @@
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "perf_precomp.hpp"
#ifdef HAVE_CLAMDBLAS
using namespace perf;
using namespace std;
using namespace cv::ocl;
using namespace cv;
using std::tr1::tuple;
using std::tr1::get;
///////////// Kalman Filter ////////////////////////
typedef tuple<int> KalmanFilterType;
typedef TestBaseWithParam<KalmanFilterType> KalmanFilterFixture;
typedef TestBaseWithParam<int> KalmanFilterFixture;
PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
::testing::Values(1000, 1500))
{
KalmanFilterType params = GetParam();
const int dim = get<0>(params);
const int dim = GetParam();
cv::Mat sample(dim, 1, CV_32FC1), dresult;
randu(sample, -1, 1);
cv::Mat statePre_;
if(RUN_PLAIN_IMPL)
if (RUN_PLAIN_IMPL)
{
cv::KalmanFilter kalman;
TEST_CYCLE()
@ -76,7 +79,8 @@ PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
kalman.predict();
}
statePre_ = kalman.statePre;
}else if(RUN_OCL_IMPL)
}
else if(RUN_OCL_IMPL)
{
cv::ocl::oclMat dsample(sample);
cv::ocl::KalmanFilter kalman_ocl;
@ -87,7 +91,11 @@ PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
kalman_ocl.predict();
}
kalman_ocl.statePre.download(statePre_);
}else
}
else
OCL_PERF_ELSE
SANITY_CHECK(statePre_);
}
}
#endif // HAVE_CLAMDBLAS

221
modules/ocl/src/arithm.cpp
View File

@ -69,7 +69,7 @@ static void arithmetic_run_generic(const oclMat &src1, const oclMat &src2, const
bool hasDouble = clCxt->supportsFeature(FEATURE_CL_DOUBLE);
if (!hasDouble && (src1.depth() == CV_64F || src2.depth() == CV_64F || dst.depth() == CV_64F))
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -242,9 +242,7 @@ void cv::ocl::absdiff(const oclMat &src1, const Scalar &src2, oclMat &dst)
static void compare_run(const oclMat &src1, const oclMat &src2, oclMat &dst, int cmpOp,
string kernelName, const cv::ocl::ProgramEntry* source)
{
CV_Assert(src1.type() == src2.type());
dst.create(src1.size(), CV_8UC1);
Context *clCxt = src1.clCxt;
int depth = src1.depth();
size_t localThreads[3] = { 64, 4, 1 };
@ -271,7 +269,7 @@ static void compare_run(const oclMat &src1, const oclMat &src2, oclMat &dst, int
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads,
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads,
args, -1, -1, buildOptions.c_str());
}
@ -279,11 +277,11 @@ void cv::ocl::compare(const oclMat &src1, const oclMat &src2, oclMat &dst , int
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
{
cout << "Selected device do not support double" << endl;
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(src1.channels() == 1 && src2.channels() == 1);
CV_Assert(src1.type() == src2.type() && src1.channels() == 1);
CV_Assert(cmpOp >= CMP_EQ && cmpOp <= CMP_NE);
compare_run(src1, src2, dst, cmpOp, "arithm_compare", &arithm_compare);
@ -363,7 +361,7 @@ Scalar cv::ocl::sum(const oclMat &src)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return Scalar::all(0);
}
static sumFunc functab[3] =
@ -382,7 +380,7 @@ Scalar cv::ocl::absSum(const oclMat &src)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return cv::Scalar::all(0);
}
@ -402,7 +400,7 @@ Scalar cv::ocl::sqrSum(const oclMat &src)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return cv::Scalar::all(0);
}
static sumFunc functab[3] =
@ -412,7 +410,7 @@ Scalar cv::ocl::sqrSum(const oclMat &src)
arithmetic_sum<double>
};
int ddepth = src.depth() <= CV_32S ? CV_32S : CV_64F;
int ddepth = std::max(src.depth(), CV_32S);
sumFunc func = functab[ddepth - CV_32S];
return func(src, SQR_SUM, ddepth);
}
@ -423,6 +421,12 @@ Scalar cv::ocl::sqrSum(const oclMat &src)
void cv::ocl::meanStdDev(const oclMat &src, Scalar &mean, Scalar &stddev)
{
if (src.depth() == CV_64F && !src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
double total = 1.0 / src.size().area();
mean = sum(src);
@ -455,7 +459,8 @@ static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem
ostringstream stream;
stream << "-D T=" << typeMap[src.depth()] << channelMap[src.channels()];
stream << " -D MAX_VAL=" << (WT)numeric_limits<T>::max();
stream << " -D MIN_VAL=" << (WT)numeric_limits<T>::min();
stream << " -D MIN_VAL=" << (numeric_limits<T>::is_integer ?
(WT)numeric_limits<T>::min() : -(WT)(std::numeric_limits<T>::max()));
string buildOptions = stream.str();
vector<pair<size_t , const void *> > args;
@ -532,7 +537,7 @@ void cv::ocl::minMax(const oclMat &src, double *minVal, double *maxVal, const oc
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -566,8 +571,13 @@ double cv::ocl::norm(const oclMat &src1, int normType)
static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & src2, oclMat & diff, int ntype)
{
CV_Assert(src1.step % src1.elemSize() == 0 && (src2.empty() || src2.step % src2.elemSize() == 0));
Context *clCxt = src1.clCxt;
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(src1.step % src1.elemSize() == 0 && (src2.empty() || src2.step % src2.elemSize() == 0));
int ddepth = std::max(src1.depth(), CV_32S);
if (ntype == NORM_L2)
@ -621,13 +631,12 @@ static void arithm_absdiff_nonsaturate_run(const oclMat & src1, const oclMat & s
double cv::ocl::norm(const oclMat &src1, const oclMat &src2, int normType)
{
CV_Assert(!src1.empty());
CV_Assert(src2.empty() || (src1.type() == src2.type() && src1.size() == src2.size()));
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return -1;
}
CV_Assert(src2.empty() || (src1.type() == src2.type() && src1.size() == src2.size()));
bool isRelative = (normType & NORM_RELATIVE) != 0;
normType &= NORM_TYPE_MASK;
@ -670,17 +679,6 @@ double cv::ocl::norm(const oclMat &src1, const oclMat &src2, int normType)
static void arithmetic_flip_rows_run(const oclMat &src, oclMat &dst, string kernelName)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
CV_Assert(src.cols == dst.cols && src.rows == dst.rows);
CV_Assert(src.type() == dst.type());
Context *clCxt = src.clCxt;
int channels = dst.oclchannels();
int depth = dst.depth();
@ -712,21 +710,11 @@ static void arithmetic_flip_rows_run(const oclMat &src, oclMat &dst, string kern
args.push_back( make_pair( sizeof(cl_int), (void *)&rows ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
openCLExecuteKernel(clCxt, &arithm_flip, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src.clCxt, &arithm_flip, kernelName, globalThreads, localThreads, args, -1, depth);
}
static void arithmetic_flip_cols_run(const oclMat &src, oclMat &dst, string kernelName, bool isVertical)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
CV_Assert(src.cols == dst.cols && src.rows == dst.rows);
CV_Assert(src.type() == dst.type());
Context *clCxt = src.clCxt;
int channels = dst.oclchannels();
int depth = dst.depth();
@ -765,16 +753,21 @@ static void arithmetic_flip_cols_run(const oclMat &src, oclMat &dst, string kern
const cv::ocl::ProgramEntry* source = isVertical ? &arithm_flip_rc : &arithm_flip;
openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads, args, src.oclchannels(), depth);
openCLExecuteKernel(src.clCxt, source, kernelName, globalThreads, localThreads, args, src.oclchannels(), depth);
}
void cv::ocl::flip(const oclMat &src, oclMat &dst, int flipCode)
{
dst.create(src.size(), src.type());
if (flipCode == 0)
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
arithmetic_flip_rows_run(src, dst, "arithm_flip_rows");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
dst.create(src.size(), src.type());
if (flipCode == 0)
arithmetic_flip_rows_run(src, dst, "arithm_flip_rows");
else if (flipCode > 0)
arithmetic_flip_cols_run(src, dst, "arithm_flip_cols", false);
else
@ -787,7 +780,6 @@ void cv::ocl::flip(const oclMat &src, oclMat &dst, int flipCode)
static void arithmetic_lut_run(const oclMat &src, const oclMat &lut, oclMat &dst, string kernelName)
{
Context *clCxt = src.clCxt;
int sdepth = src.depth();
int src_step1 = src.step1(), dst_step1 = dst.step1();
int src_offset1 = src.offset / src.elemSize1(), dst_offset1 = dst.offset / dst.elemSize1();
@ -812,19 +804,26 @@ static void arithmetic_lut_run(const oclMat &src, const oclMat &lut, oclMat &dst
args.push_back( make_pair( sizeof(cl_int), (void *)&src_step1 ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
openCLExecuteKernel(clCxt, &arithm_LUT, kernelName, globalSize, localSize,
openCLExecuteKernel(src.clCxt, &arithm_LUT, kernelName, globalSize, localSize,
args, lut.oclchannels(), -1, buildOptions.c_str());
}
void cv::ocl::LUT(const oclMat &src, const oclMat &lut, oclMat &dst)
{
if (!lut.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && lut.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
int cn = src.channels(), depth = src.depth();
CV_Assert(depth == CV_8U || depth == CV_8S);
CV_Assert(lut.channels() == 1 || lut.channels() == src.channels());
CV_Assert(lut.rows == 1 && lut.cols == 256);
dst.create(src.size(), CV_MAKETYPE(lut.depth(), cn));
string kernelName = "LUT";
arithmetic_lut_run(src, lut, dst, kernelName);
arithmetic_lut_run(src, lut, dst, "LUT");
}
//////////////////////////////////////////////////////////////////////////////
@ -836,7 +835,7 @@ static void arithmetic_exp_log_run(const oclMat &src, oclMat &dst, string kernel
Context *clCxt = src.clCxt;
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -884,13 +883,6 @@ void cv::ocl::log(const oclMat &src, oclMat &dst)
static void arithmetic_magnitude_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, string kernelName)
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
Context *clCxt = src1.clCxt;
int channels = dst.oclchannels();
int depth = dst.depth();
@ -914,11 +906,17 @@ static void arithmetic_magnitude_phase_run(const oclMat &src1, const oclMat &src
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
openCLExecuteKernel(clCxt, &arithm_magnitude, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, &arithm_magnitude, kernelName, globalThreads, localThreads, args, -1, depth);
}
void cv::ocl::magnitude(const oclMat &src1, const oclMat &src2, oclMat &dst)
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(src1.type() == src2.type() && src1.size() == src2.size() &&
(src1.depth() == CV_32F || src1.depth() == CV_64F));
@ -928,13 +926,6 @@ void cv::ocl::magnitude(const oclMat &src1, const oclMat &src2, oclMat &dst)
static void arithmetic_phase_run(const oclMat &src1, const oclMat &src2, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
Context *clCxt = src1.clCxt;
int depth = dst.depth(), cols1 = src1.cols * src1.oclchannels();
int src1step1 = src1.step / src1.elemSize1(), src1offset1 = src1.offset / src1.elemSize1();
int src2step1 = src2.step / src2.elemSize1(), src2offset1 = src2.offset / src2.elemSize1();
@ -956,11 +947,17 @@ static void arithmetic_phase_run(const oclMat &src1, const oclMat &src2, oclMat
args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
}
void cv::ocl::phase(const oclMat &x, const oclMat &y, oclMat &Angle, bool angleInDegrees)
{
if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(x.type() == y.type() && x.size() == y.size() && (x.depth() == CV_32F || x.depth() == CV_64F));
CV_Assert(x.step % x.elemSize() == 0 && y.step % y.elemSize() == 0);
@ -975,13 +972,6 @@ void cv::ocl::phase(const oclMat &x, const oclMat &y, oclMat &Angle, bool angleI
static void arithmetic_cartToPolar_run(const oclMat &src1, const oclMat &src2, oclMat &dst_mag, oclMat &dst_cart,
string kernelName, bool angleInDegrees)
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
Context *clCxt = src1.clCxt;
int channels = src1.oclchannels();
int depth = src1.depth();
@ -1008,11 +998,17 @@ static void arithmetic_cartToPolar_run(const oclMat &src1, const oclMat &src2, o
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int), (void *)&tmp ));
openCLExecuteKernel(clCxt, &arithm_cartToPolar, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, &arithm_cartToPolar, kernelName, globalThreads, localThreads, args, -1, depth);
}
void cv::ocl::cartToPolar(const oclMat &x, const oclMat &y, oclMat &mag, oclMat &angle, bool angleInDegrees)
{
if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(x.type() == y.type() && x.size() == y.size() && (x.depth() == CV_32F || x.depth() == CV_64F));
mag.create(x.size(), x.type());
@ -1028,13 +1024,6 @@ void cv::ocl::cartToPolar(const oclMat &x, const oclMat &y, oclMat &mag, oclMat
static void arithmetic_ptc_run(const oclMat &src1, const oclMat &src2, oclMat &dst1, oclMat &dst2, bool angleInDegrees,
string kernelName)
{
if (!src1.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
Context *clCxt = src2.clCxt;
int channels = src2.oclchannels();
int depth = src2.depth();
@ -1065,21 +1054,25 @@ static void arithmetic_ptc_run(const oclMat &src1, const oclMat &src2, oclMat &d
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int), (void *)&tmp ));
openCLExecuteKernel(clCxt, &arithm_polarToCart, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, &arithm_polarToCart, kernelName, globalThreads, localThreads, args, -1, depth);
}
void cv::ocl::polarToCart(const oclMat &magnitude, const oclMat &angle, oclMat &x, oclMat &y, bool angleInDegrees)
{
if (!magnitude.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && magnitude.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(angle.depth() == CV_32F || angle.depth() == CV_64F);
CV_Assert(magnitude.size() == angle.size() && magnitude.type() == angle.type());
x.create(angle.size(), angle.type());
y.create(angle.size(), angle.type());
if ( magnitude.data )
{
CV_Assert( magnitude.size() == angle.size() && magnitude.type() == angle.type() );
arithmetic_ptc_run(magnitude, angle, x, y, angleInDegrees, "arithm_polarToCart_mag");
}
else
arithmetic_ptc_run(magnitude, angle, x, y, angleInDegrees, "arithm_polarToCart");
}
@ -1211,7 +1204,7 @@ void cv::ocl::minMaxLoc(const oclMat &src, double *minVal, double *maxVal,
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -1269,7 +1262,8 @@ int cv::ocl::countNonZero(const oclMat &src)
Context *clCxt = src.clCxt;
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "selected device doesn't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "selected device doesn't support double");
return -1;
}
size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;
@ -1302,8 +1296,6 @@ static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName
{
dst.create(src1.size(), src1.type());
Context *clCxt = src1.clCxt;
int channels = dst.oclchannels();
int depth = dst.depth();
@ -1332,7 +1324,7 @@ static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
}
enum { AND = 0, OR, XOR };
@ -1340,13 +1332,6 @@ enum { AND = 0, OR, XOR };
static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Scalar& src3, const oclMat &mask,
oclMat &dst, int operationType)
{
Context *clCxt = src1.clCxt;
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src1.depth() == CV_64F)
{
cout << "Selected device does not support double" << endl;
return;
}
CV_Assert(operationType >= AND && operationType <= XOR);
CV_Assert(src2.empty() || (!src2.empty() && src1.type() == src2.type() && src1.size() == src2.size()));
CV_Assert(mask.empty() || (!mask.empty() && mask.type() == CV_8UC1 && mask.size() == src1.size()));
@ -1405,7 +1390,7 @@ static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Sca
args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
openCLExecuteKernel(clCxt, mask.empty() ? (!src2.empty() ? &arithm_bitwise_binary : &arithm_bitwise_binary_scalar) :
openCLExecuteKernel(src1.clCxt, mask.empty() ? (!src2.empty() ? &arithm_bitwise_binary : &arithm_bitwise_binary_scalar) :
(!src2.empty() ? &arithm_bitwise_binary_mask : &arithm_bitwise_binary_scalar_mask),
kernelName, globalThreads, localThreads,
args, -1, -1, buildOptions.c_str());
@ -1413,15 +1398,14 @@ static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Sca
void cv::ocl::bitwise_not(const oclMat &src, oclMat &dst)
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.type() == CV_64F)
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
cout << "Selected device does not support double" << endl;
CV_Error(CV_OpenCLDoubleNotSupported, "selected device doesn't support double");
return;
}
dst.create(src.size(), src.type());
string kernelName = "arithm_bitwise_not";
bitwise_unary_run(src, dst, kernelName, &arithm_bitwise_not);
bitwise_unary_run(src, dst, "arithm_bitwise_not", &arithm_bitwise_not);
}
void cv::ocl::bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
@ -1541,13 +1525,6 @@ oclMatExpr::operator oclMat() const
static void transpose_run(const oclMat &src, oclMat &dst, string kernelName, bool inplace = false)
{
Context *clCxt = src.clCxt;
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
return;
}
const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
const char channelsString[] = { ' ', ' ', '2', '4', '4' };
std::string buildOptions = format("-D T=%s%c", typeMap[src.depth()],
@ -1569,13 +1546,17 @@ static void transpose_run(const oclMat &src, oclMat &dst, string kernelName, boo
args.push_back( make_pair( sizeof(cl_int), (void *)&srcoffset1 ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));
openCLExecuteKernel(clCxt, &arithm_transpose, kernelName, globalThreads, localThreads,
openCLExecuteKernel(src.clCxt, &arithm_transpose, kernelName, globalThreads, localThreads,
args, -1, -1, buildOptions.c_str());
}
void cv::ocl::transpose(const oclMat &src, oclMat &dst)
{
CV_Assert(src.depth() <= CV_64F && src.channels() <= 4);
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
if ( src.data == dst.data && src.cols == src.rows && dst.offset == src.offset
&& dst.size() == src.size())
@ -1597,7 +1578,7 @@ void cv::ocl::addWeighted(const oclMat &src1, double alpha, const oclMat &src2,
bool hasDouble = clCxt->supportsFeature(FEATURE_CL_DOUBLE);
if (!hasDouble && src1.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -1661,10 +1642,6 @@ void cv::ocl::addWeighted(const oclMat &src1, double alpha, const oclMat &src2,
static void arithmetic_pow_run(const oclMat &src1, double p, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
{
CV_Assert(src1.cols == dst.cols && src1.rows == dst.rows);
CV_Assert(src1.type() == dst.type());
Context *clCxt = src1.clCxt;
int channels = dst.oclchannels();
int depth = dst.depth();
@ -1694,22 +1671,21 @@ static void arithmetic_pow_run(const oclMat &src1, double p, oclMat &dst, string
else
args.push_back( make_pair( sizeof(cl_double), (void *)&p ));
openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
}
void cv::ocl::pow(const oclMat &x, double p, oclMat &y)
{
if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.type() == CV_64F)
if (!x.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && x.depth() == CV_64F)
{
cout << "Selected device do not support double" << endl;
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_Assert(x.depth() == CV_32F || x.depth() == CV_64F);
y.create(x.size(), x.type());
string kernelName = "arithm_pow";
arithmetic_pow_run(x, p, y, kernelName, &arithm_pow);
arithmetic_pow_run(x, p, y, "arithm_pow", &arithm_pow);
}
//////////////////////////////////////////////////////////////////////////////
@ -1718,10 +1694,9 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y)
void cv::ocl::setIdentity(oclMat& src, const Scalar & scalar)
{
Context *clCxt = Context::getContext();
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device doesn't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -1745,6 +1720,6 @@ void cv::ocl::setIdentity(oclMat& src, const Scalar & scalar)
oclMat sc(1, 1, src.type(), scalar);
args.push_back( make_pair( sizeof(cl_mem), (void *)&sc.data ));
openCLExecuteKernel(clCxt, &arithm_setidentity, "setIdentity", global_threads, local_threads,
openCLExecuteKernel(src.clCxt, &arithm_setidentity, "setIdentity", global_threads, local_threads,
args, -1, -1, buildOptions.c_str());
}

4
modules/ocl/src/cl_context.cpp
View File

@ -517,14 +517,14 @@ Context* Context::getContext()
{
if (initializeOpenCLDevices() == 0)
{
CV_Error(CV_GpuNotSupported, "OpenCL not available");
CV_Error(CV_OpenCLInitError, "OpenCL not available");
}
}
if (!__deviceSelected)
{
if (!selectOpenCLDevice())
{
CV_Error(CV_GpuNotSupported, "Can't select OpenCL device");
CV_Error(CV_OpenCLInitError, "Can't select OpenCL device");
}
}
}

2
modules/ocl/src/filtering.cpp
View File

@ -1417,7 +1417,7 @@ void cv::ocl::Laplacian(const oclMat &src, oclMat &dst, int ddepth, int ksize, d
{
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}

15
modules/ocl/src/imgproc.cpp
View File

@ -977,7 +977,7 @@ namespace cv
CV_Assert(src.type() == CV_8UC1);
if(!src.clCxt->supportsFeature(ocl::FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "select device don't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
return;
}
@ -1168,7 +1168,7 @@ namespace cv
{
if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "select device don't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
}
CV_Assert(src.cols >= blockSize / 2 && src.rows >= blockSize / 2);
CV_Assert(borderType == cv::BORDER_CONSTANT || borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@ -1187,7 +1187,7 @@ namespace cv
{
if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "select device don't support double");
CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
}
CV_Assert(src.cols >= blockSize / 2 && src.rows >= blockSize / 2);
CV_Assert(borderType == cv::BORDER_CONSTANT || borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@ -1301,10 +1301,11 @@ namespace cv
if( src.depth() != CV_8U || src.oclchannels() != 4 )
CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" );
// if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
// {
// CV_Error( CV_GpuNotSupported, "Selected device doesn't support double, so a deviation exists.\nIf the accuracy is acceptable, the error can be ignored.\n");
// }
// if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
// {
// CV_Error( CV_OpenCLDoubleNotSupportedNotSupported, "Selected device doesn't support double, so a deviation exists.\nIf the accuracy is acceptable, the error can be ignored.\n");
// return;
// }
dstr.create( src.size(), CV_8UC4 );
dstsp.create( src.size(), CV_16SC2 );

2
modules/ocl/src/kmeans.cpp
View File

@ -164,7 +164,7 @@ void cv::ocl::distanceToCenters(oclMat &dists, oclMat &labels, const oclMat &src
{
//if(src.clCxt -> impl -> double_support == 0 && src.type() == CV_64F)
//{
// CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
// CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
// return;
//}

8
modules/ocl/src/matrix_operations.cpp
View File

@ -119,6 +119,12 @@ static void convert_C4C3(const oclMat &src, cl_mem &dst)
void cv::ocl::oclMat::upload(const Mat &m)
{
if (!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE) && m.depth() == CV_64F)
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
CV_DbgAssert(!m.empty());
Size wholeSize;
Point ofs;
@ -308,7 +314,7 @@ void cv::ocl::oclMat::convertTo( oclMat &dst, int rtype, double alpha, double be
if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) &&
(depth() == CV_64F || dst.depth() == CV_64F))
{
CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}

4
modules/ocl/src/split_merge.cpp
View File

@ -59,7 +59,7 @@ namespace cv
{
if(!mat_dst.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && mat_dst.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
@ -154,7 +154,7 @@ namespace cv
if(!mat_src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && mat_src.type() == CV_64F)
{
CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}

155
modules/ocl/src/svm.cpp
View File

@ -75,6 +75,7 @@ public:
void calc_non_rbf_base( int vec_count, const int row_idx, Qfloat* results, Mat& src);
void calc_rbf( int vec_count, const int row_idx, Qfloat* results, Mat& src);
};
class CvSVMSolver_ocl: public CvSVMSolver
{
public:
@ -90,13 +91,16 @@ typedef struct CvSparseVecElem32f
int idx;
float val;
} CvSparseVecElem32f;
static int icvCmpSparseVecElems( const void* a, const void* b )
{
return ((CvSparseVecElem32f*)a)->idx - ((CvSparseVecElem32f*)b)->idx;
}
void cvPreparePredictData( const CvArr* sample, int dims_all, const CvMat* comp_idx,
int class_count, const CvMat* prob, float** row_sample,
int as_sparse CV_DEFAULT(0) );
void cvPreparePredictData( const CvArr* _sample, int dims_all,
const CvMat* comp_idx, int class_count,
const CvMat* prob, float** _row_sample,
@ -135,9 +139,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
}
if( d == 1 )
{
sizes[1] = 1;
}
if( sizes[0] + sizes[1] - 1 != dims_all )
CV_ERROR( CV_StsUnmatchedSizes,
@ -184,25 +186,19 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
sample_step = CV_IS_MAT_CONT(sample->type) ? 1 : sample->step / sizeof(row_sample[0]);
if( !comp_idx && CV_IS_MAT_CONT(sample->type) && !as_sparse )
{
*_row_sample = sample_data;
}
else
{
CV_CALL( row_sample = (float*)cvAlloc( vec_size ));
if( !comp_idx )
for( i = 0; i < dims_selected; i++ )
{
row_sample[i] = sample_data[sample_step * i];
}
else
{
int* comp = comp_idx->data.i;
for( i = 0; i < dims_selected; i++ )
{
row_sample[i] = sample_data[sample_step * comp[i]];
}
}
*_row_sample = row_sample;
@ -236,9 +232,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
CV_CALL( inverse_comp_idx = (int*)cvAlloc( dims_all * sizeof(int) ));
memset( inverse_comp_idx, -1, dims_all * sizeof(int) );
for( i = 0; i < dims_selected; i++ )
{
inverse_comp_idx[comp_idx->data.i[i]] = i;
}
}
if( !as_sparse )
@ -252,9 +246,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
{
idx = inverse_comp_idx[idx];
if( idx < 0 )
{
continue;
}
}
row_sample[idx] = *(float*)CV_NODE_VAL( sparse, node );
}
@ -270,9 +262,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
{
idx = inverse_comp_idx[idx];
if( idx < 0 )
{
continue;
}
}
ptr->idx = idx;
ptr->val = *(float*)CV_NODE_VAL( sparse, node );
@ -290,9 +280,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
__END__;
if( inverse_comp_idx )
{
cvFree( &inverse_comp_idx );
}
if( cvGetErrStatus() < 0 && _row_sample )
{
@ -300,6 +288,7 @@ void cvPreparePredictData( const CvArr* _sample, int dims_all,
*_row_sample = 0;
}
}
float CvSVM_OCL::predict( const int row_index, int row_len, Mat& src, bool returnDFVal ) const
{
assert( kernel );
@ -323,9 +312,7 @@ float CvSVM_OCL::predict( const int row_index, int row_len, Mat& src, bool retur
((CvSVMKernel_ocl*)kernel)->calc( sv_count, row_index, buffer, src);
for( i = 0; i < sv_count; i++ )
{
sum += buffer[i] * df->alpha[i];
}
result = params.svm_type == ONE_CLASS ? (float)(sum > 0) : (float)sum;
}
@ -341,27 +328,20 @@ float CvSVM_OCL::predict( const int row_index, int row_len, Mat& src, bool retur
double sum = 0.;
for( i = 0; i < class_count; i++ )
{
for( j = i + 1; j < class_count; j++, df++ )
{
sum = -df->rho;
int sv_count = df->sv_count;
for( k = 0; k < sv_count; k++ )
{
sum += df->alpha[k] * buffer[df->sv_index[k]];
}
vote[sum > 0 ? i : j]++;
}
}
for( i = 1, k = 0; i < class_count; i++ )
{
if( vote[i] > vote[k] )
{
k = i;
}
}
result = returnDFVal && class_count == 2 ? (float)sum : (float)(class_labels->data.i[k]);
}
else
@ -370,11 +350,13 @@ float CvSVM_OCL::predict( const int row_index, int row_len, Mat& src, bool retur
return result;
}
float CvSVM_OCL::predict( const Mat& _sample, bool returnDFVal ) const
{
CvMat sample = _sample;
return CvSVM::predict(&sample, returnDFVal);
}
float CvSVM_OCL::predict( const int row_index, Mat& src, bool returnDFVal) const
{
float result = 0;
@ -383,6 +365,7 @@ float CvSVM_OCL::predict( const int row_index, Mat& src, bool returnDFVal) const
return result;
}
#undef get_C
#define get_C(i) (C[y[i]>0])
#undef is_upper_bound
@ -397,12 +380,14 @@ CvSVMSolver_ocl::CvSVMSolver_ocl(const CvSVMParams* _params)
{
params = _params;
}
float* CvSVMSolver_ocl::get_row( int i, float* dst, Mat& src )
{
bool existed = false;
float* row = get_row_base( i, &existed, src);
return (this->*get_row_func)( i, row, dst, existed );
}
float* CvSVMSolver_ocl::get_row_base( int i, bool* _existed, Mat& src )
{
int i1 = i < sample_count ? i : i - sample_count;
@ -434,19 +419,16 @@ float* CvSVMSolver_ocl::get_row_base( int i, bool* _existed, Mat& src )
row->prev->next = row->next->prev = row;
if( !existed )
{
((CvSVMKernel_ocl*)kernel)->calc( sample_count, i1, row->data, src);
}
if( _existed )
{
*_existed = existed;
}
return row->data;
}
#ifndef HAVE_CLAMDBLAS
static void matmul_sigmod(oclMat & src, oclMat & src2, oclMat & dst, int src_rows, int src2_cols, int var_count, double alpha1, double beta1)
{
Context *clCxt = Context::getContext();
@ -486,6 +468,7 @@ static void matmul_sigmod(oclMat & src, oclMat & src2, oclMat & dst, int src_row
}
openCLExecuteKernel(clCxt, &svm, kernelName, globalThreads, localThreads, args, -1, -1);
}
static void matmul_poly(oclMat & src, oclMat & src2, oclMat & dst, int src_rows, int src2_cols, int var_count, double alpha1, double beta1, double degree1, bool flag)
{
Context *clCxt = Context::getContext();
@ -534,6 +517,7 @@ static void matmul_poly(oclMat & src, oclMat & src2, oclMat & dst, int src_rows,
}
openCLExecuteKernel(clCxt, &svm, kernelName, globalThreads, localThreads, args, -1, -1, build_options);
}
static void matmul_linear(oclMat & src, oclMat & src2, oclMat & dst, int src_rows, int src2_cols, int var_count, double alpha1, double beta1)
{
Context *clCxt = Context::getContext();
@ -573,6 +557,7 @@ static void matmul_linear(oclMat & src, oclMat & src2, oclMat & dst, int src_row
}
openCLExecuteKernel(clCxt, &svm, kernelName, globalThreads, localThreads, args, -1, -1);
}
#endif // #ifndef HAVE_CLAMDBLAS
static void matmul_rbf(oclMat& src, oclMat& src_e, oclMat& dst, int src_rows, int src2_cols, int var_count, double gamma1, bool flag)
@ -594,9 +579,8 @@ static void matmul_rbf(oclMat& src, oclMat& src_e, oclMat& dst, int src_rows, in
char build_options[50];
if(flag)
{
sprintf(build_options, "-D ADDEXP");
}
vector< pair<size_t, const void *> > args;
args.push_back(make_pair(sizeof(cl_mem), (void* )&src.data));
args.push_back(make_pair(sizeof(cl_int), (void* )&src_step));
@ -614,9 +598,7 @@ static void matmul_rbf(oclMat& src, oclMat& src_e, oclMat& dst, int src_rows, in
args.push_back(make_pair(sizeof(cl_float), (void* )&gamma));
}
else
{
args.push_back(make_pair(sizeof(cl_double), (void* )&gamma1));
}
openCLExecuteKernel(clCxt, &svm, kernelName, globalThreads, localThreads, args, -1, -1, build_options);
}
@ -649,14 +631,12 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
CV_CALL( cvPreparePredictData(&sample, var_all, var_idx,
class_count, 0, &row_sample ));
for(int j = 0; j < var_count; ++j)
{
src_temp.at<float>(i, j) = row_sample[j];
}
__END__;
}
Mat dst1;
double alpha1 = 0.0, beta1 = 0.0, gamma1 = 0.0, degree1 = 0.0;
double alpha1 = 0.0, beta1 = 0.0, gamma1 = 0.0;
if(params.kernel_type == CvSVM::LINEAR)
{
alpha1 = 1;
@ -666,7 +646,6 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
{
alpha1 = params.gamma;
beta1 = params.coef0;
degree1 = params.degree;
}
if(params.kernel_type == CvSVM::SIGMOID)
{
@ -674,27 +653,22 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
beta1 = - 2 * params.coef0;
}
if(params.kernel_type == CvSVM::RBF)
{
gamma1 = - params.gamma;
}
Mat sv_temp = Mat(sv_total, var_count, CV_32FC1, Scalar::all(0));
for(int i = 0; i < sv_total; ++i)
{
for(int j = 0; j < var_count; ++j)
{
sv_temp.at<float>(i, j) = sv[i][j];
}
}
oclMat src(sample_count, var_count, CV_32FC1, Scalar::all(0));
oclMat sv_;
src.upload(src_temp);
oclMat dst;
#if defined HAVE_CLAMDBLAS
#ifdef HAVE_CLAMDBLAS
dst = oclMat(sample_count, sv_total, CV_32FC1);
oclMat src3(sample_count, sv_total, CV_32FC1, Scalar::all(1));
@ -707,15 +681,15 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
}
#else
double degree1 = 0.0;
if (params.kernel_type == CvSVM::POLY)
degree1 = params.degree;
if(!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE))
{
dst = oclMat(sample_count, sv_total, CV_32FC1);
}
else
{
dst = oclMat(sample_count, sv_total, CV_64FC1);
}
if(params.kernel_type == CvSVM::LINEAR)
{
sv_.upload(sv_temp);
@ -731,13 +705,9 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
{
sv_.upload(sv_temp);
if(sample_count > 0)
{
matmul_poly(src, sv_, dst, sample_count, sv_total, var_count, alpha1, beta1, degree1, true);
}
else
{
matmul_poly(src, sv_, dst, sample_count, sv_total, var_count, alpha1, beta1, degree1, false);
}
}
#endif
@ -745,21 +715,14 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
{
sv_.upload(sv_temp);
if(!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE))
{
dst = oclMat(sample_count, sv_total, CV_32FC1);
}
else
{
dst = oclMat(sample_count, sv_total, CV_64FC1);
}
if(sample_count > 0)
{
matmul_rbf(src, sv_, dst, sample_count, sv_total, var_count, gamma1, true);
}
else
{
matmul_rbf(src, sv_, dst, sample_count, sv_total, var_count, gamma1, false);
}
}
dst.download(dst1);
@ -768,22 +731,20 @@ float CvSVM_OCL::predict(const CvMat* samples, CV_OUT CvMat* results) const
{
int r = (int)this->predict(i, dst1);
if (results)
{
results->data.fl[i] = (float)r;
}
if (i == 0)
{
result = (float)r;
}
}
return result;
}
void CvSVM_OCL::predict( cv::InputArray _samples, cv::OutputArray _results ) const
{
_results.create(_samples.size().height, 1, CV_32F);
CvMat samples = _samples.getMat(), results = _results.getMat();
predict(&samples, &results);
}
bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
{
int iter = 0;
@ -800,7 +761,7 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
}
}
Mat dst1;
double alpha1 = 0.0, beta1 = 0.0, gamma1 = 0.0, degree1 = 0.0;
double alpha1 = 0.0, beta1 = 0.0, gamma1 = 0.0;
if(params->kernel_type == CvSVM::LINEAR)
{
alpha1 = 1;
@ -810,7 +771,6 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
{
alpha1 = params->gamma;
beta1 = params->coef0;
degree1 = params->degree;
}
if(params->kernel_type == CvSVM::SIGMOID)
{
@ -834,7 +794,7 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
src.upload(src1);
oclMat dst;
#if defined HAVE_CLAMDBLAS
#ifdef HAVE_CLAMDBLAS
dst = oclMat(sample_count, sample_count, CV_32FC1);
oclMat src3(sample_count, sample_count, CV_32FC1, Scalar::all(1));
@ -845,14 +805,15 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
}
#else
double degree1 = 0.0;
if(params->kernel_type == CvSVM::POLY)
degree1 = params->degree;
if(!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE))
{
dst = oclMat(sample_count, sample_count, CV_32FC1);
}
else
{
dst = oclMat(sample_count, sample_count, CV_64FC1);
}
if(params->kernel_type == CvSVM::LINEAR )
{
src_e = src;
@ -868,13 +829,9 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
{
src_e = src;
if(sample_count > 0)
{
matmul_poly(src, src_e, dst, sample_count, sample_count, var_count, alpha1, beta1, degree1, true);
}
else
{
matmul_poly(src, src_e, dst, sample_count, sample_count, var_count, alpha1, beta1, degree1, false);
}
}
#endif
@ -883,21 +840,14 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
{
src_e = src;
if(!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE))
{
dst = oclMat(sample_count, sample_count, CV_32FC1);
}
else
{
dst = oclMat(sample_count, sample_count, CV_64FC1);
}
if(sample_count > 0)
{
matmul_rbf(src, src_e, dst, sample_count, sample_count, var_count, gamma1, true);
}
else
{
matmul_rbf(src, src_e, dst, sample_count, sample_count, var_count, gamma1, false);
}
}
dst.download(dst1);
for( i = 0; i < alpha_count; i++ )
@ -908,9 +858,7 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
double alpha_i = alpha[i];
for( j = 0; j < alpha_count; j++ )
{
G[j] += alpha_i * Q_i[j];
}
}
}
@ -926,14 +874,10 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
for( i = 0; i < alpha_count; i++ )
{
if( fabs(G[i]) > 1e+300 )
{
return false;
}
if( fabs(alpha[i]) > 1e16 )
{
return false;
}
}
#endif
@ -1021,9 +965,7 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
delta_alpha_j = alpha_j - old_alpha_j;
for( k = 0; k < alpha_count; k++ )
{
G[k] += Q_i[k] * delta_alpha_i + Q_j[k] * delta_alpha_j;
}
}
// calculate rho
@ -1031,9 +973,7 @@ bool CvSVMSolver_ocl::solve_generic( CvSVMSolutionInfo& si )
// calculate objective value
for( i = 0, si.obj = 0; i < alpha_count; i++ )
{
si.obj += alpha[i] * (G[i] + b[i]);
}
si.obj *= 0.5;
@ -1053,14 +993,11 @@ void CvSVMKernel_ocl::calc( int vcount, const int row_idx, Qfloat* results, Mat&
const Qfloat max_val = (Qfloat)(FLT_MAX * 1e-3);
int j;
for( j = 0; j < vcount; j++ )
{
if( results[j] > max_val )
{
results[j] = max_val;
}
}
// FIXIT #endif
}
bool CvSVMKernel_ocl::create( const CvSVMParams* _params, Calc_ocl _calc_func, Calc _calc_func1 )
{
clear();
@ -1084,9 +1021,10 @@ CvSVMKernel_ocl::CvSVMKernel_ocl(const CvSVMParams* params, CvSVMKernel_ocl::Cal
CvSVMKernel::clear();
CvSVMKernel_ocl::create( params, _calc_func, _calc_func1 );
}
void CvSVMKernel_ocl::calc_non_rbf_base( int vcount, const int row_idx, Qfloat* results, Mat& src)
{
#if defined HAVE_CLAMDBLAS
#ifdef HAVE_CLAMDBLAS
for(int i = 0; i < vcount; i++)
{
@ -1109,23 +1047,17 @@ void CvSVMKernel_ocl::calc_non_rbf_base( int vcount, const int row_idx, Qfloat*
}
#endif
}
void CvSVMKernel_ocl::calc_rbf( int vcount, const int row_idx, Qfloat* results, Mat& src)
{
if(!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE))
{
for(int m = 0; m < vcount; m++)
{
results[m] = (Qfloat) * src.ptr<float>(row_idx, m);
}
}
else
{
for(int m = 0; m < vcount; m++)
{
results[m] = (Qfloat) * src.ptr<double>(row_idx, m);
}
}
}
void CvSVMKernel_ocl::calc_linear( int vcount, const int row_idx, Qfloat* results, Mat& src )
{
calc_non_rbf_base( vcount, row_idx, results, src);
@ -1133,16 +1065,13 @@ void CvSVMKernel_ocl::calc_linear( int vcount, const int row_idx, Qfloat* result
void CvSVMKernel_ocl::calc_poly( int vcount, const int row_idx, Qfloat* results, Mat& src)
{
calc_non_rbf_base( vcount, row_idx, results, src);
//FIXIT #if defined HAVE_CLAMDBLAS
CvMat R = cvMat( 1, vcount, QFLOAT_TYPE, results );
if( vcount > 0 )
{
cvPow( &R, &R, params->degree );
}
//FIXIT #endif
}
@ -1157,16 +1086,13 @@ void CvSVMKernel_ocl::calc_sigmoid( int vcount, const int row_idx, Qfloat* resul
Qfloat t = results[j];
double e = ::exp(-fabs(t));
if( t > 0 )
{
results[j] = (Qfloat)((1. - e) / (1. + e));
}
else
{
results[j] = (Qfloat)((e - 1.) / (e + 1.));
}
}
//FIXIT #endif
}
CvSVM_OCL::CvSVM_OCL()
{
CvSVM();
@ -1191,6 +1117,7 @@ void CvSVM_OCL::create_kernel()
{
kernel = new CvSVMKernel_ocl(&params, 0, 0);
}
void CvSVM_OCL::create_solver( )
{
solver = new CvSVMSolver_ocl(&params);

132
modules/ocl/test/test_arithm.cpp
View File

@ -126,7 +126,7 @@ PARAM_TEST_CASE(Lut, int, int, bool, bool)
}
};
TEST_P(Lut, Mat)
OCL_TEST_P(Lut, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -232,7 +232,7 @@ PARAM_TEST_CASE(ArithmTestBase, int, int, bool)
typedef ArithmTestBase Exp;
TEST_P(Exp, Mat)
OCL_TEST_P(Exp, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -249,7 +249,7 @@ TEST_P(Exp, Mat)
typedef ArithmTestBase Log;
TEST_P(Log, Mat)
OCL_TEST_P(Log, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -265,7 +265,7 @@ TEST_P(Log, Mat)
typedef ArithmTestBase Add;
TEST_P(Add, Mat)
OCL_TEST_P(Add, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -277,7 +277,7 @@ TEST_P(Add, Mat)
}
}
TEST_P(Add, Mat_Mask)
OCL_TEST_P(Add, Mat_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -289,7 +289,7 @@ TEST_P(Add, Mat_Mask)
}
}
TEST_P(Add, Scalar)
OCL_TEST_P(Add, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -301,7 +301,7 @@ TEST_P(Add, Scalar)
}
}
TEST_P(Add, Scalar_Mask)
OCL_TEST_P(Add, Scalar_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -317,7 +317,7 @@ TEST_P(Add, Scalar_Mask)
typedef ArithmTestBase Sub;
TEST_P(Sub, Mat)
OCL_TEST_P(Sub, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -330,7 +330,7 @@ TEST_P(Sub, Mat)
}
}
TEST_P(Sub, Mat_Mask)
OCL_TEST_P(Sub, Mat_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -342,7 +342,7 @@ TEST_P(Sub, Mat_Mask)
}
}
TEST_P(Sub, Scalar)
OCL_TEST_P(Sub, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -355,7 +355,7 @@ TEST_P(Sub, Scalar)
}
}
TEST_P(Sub, Scalar_Mask)
OCL_TEST_P(Sub, Scalar_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -371,7 +371,7 @@ TEST_P(Sub, Scalar_Mask)
typedef ArithmTestBase Mul;
TEST_P(Mul, Mat)
OCL_TEST_P(Mul, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -383,7 +383,7 @@ TEST_P(Mul, Mat)
}
}
TEST_P(Mul, Scalar)
OCL_TEST_P(Mul, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -396,7 +396,7 @@ TEST_P(Mul, Scalar)
}
}
TEST_P(Mul, Mat_Scalar)
OCL_TEST_P(Mul, Mat_Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -413,7 +413,7 @@ TEST_P(Mul, Mat_Scalar)
typedef ArithmTestBase Div;
TEST_P(Div, Mat)
OCL_TEST_P(Div, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -425,7 +425,7 @@ TEST_P(Div, Mat)
}
}
TEST_P(Div, Scalar)
OCL_TEST_P(Div, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -438,7 +438,7 @@ TEST_P(Div, Scalar)
}
}
TEST_P(Div, Mat_Scalar)
OCL_TEST_P(Div, Mat_Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -447,7 +447,7 @@ TEST_P(Div, Mat_Scalar)
cv::divide(src1_roi, src2_roi, dst1_roi, val[0]);
cv::ocl::divide(gsrc1_roi, gsrc2_roi, gdst1_roi, val[0]);
Near(gdst1_roi.depth() >= CV_32F ? 1e-3 : 1);
Near(gdst1_roi.depth() >= CV_32F ? 4e-3 : 1);
}
}
@ -455,7 +455,7 @@ TEST_P(Div, Mat_Scalar)
typedef ArithmTestBase Min;
TEST_P(Min, Mat)
OCL_TEST_P(Min, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -469,7 +469,7 @@ TEST_P(Min, Mat)
typedef ArithmTestBase Max;
TEST_P(Max, Mat)
OCL_TEST_P(Max, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -485,7 +485,7 @@ TEST_P(Max, Mat)
typedef ArithmTestBase Abs;
TEST_P(Abs, Abs)
OCL_TEST_P(Abs, Abs)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -501,7 +501,7 @@ TEST_P(Abs, Abs)
typedef ArithmTestBase Absdiff;
TEST_P(Absdiff, Mat)
OCL_TEST_P(Absdiff, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -513,7 +513,7 @@ TEST_P(Absdiff, Mat)
}
}
TEST_P(Absdiff, Scalar)
OCL_TEST_P(Absdiff, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -529,7 +529,7 @@ TEST_P(Absdiff, Scalar)
typedef ArithmTestBase CartToPolar;
TEST_P(CartToPolar, angleInDegree)
OCL_TEST_P(CartToPolar, angleInDegree)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -542,7 +542,7 @@ TEST_P(CartToPolar, angleInDegree)
}
}
TEST_P(CartToPolar, angleInRadians)
OCL_TEST_P(CartToPolar, angleInRadians)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -559,7 +559,7 @@ TEST_P(CartToPolar, angleInRadians)
typedef ArithmTestBase PolarToCart;
TEST_P(PolarToCart, angleInDegree)
OCL_TEST_P(PolarToCart, angleInDegree)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -573,7 +573,7 @@ TEST_P(PolarToCart, angleInDegree)
}
}
TEST_P(PolarToCart, angleInRadians)
OCL_TEST_P(PolarToCart, angleInRadians)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -591,7 +591,7 @@ TEST_P(PolarToCart, angleInRadians)
typedef ArithmTestBase Magnitude;
TEST_P(Magnitude, Mat)
OCL_TEST_P(Magnitude, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -607,7 +607,7 @@ TEST_P(Magnitude, Mat)
typedef ArithmTestBase Transpose;
TEST_P(Transpose, Mat)
OCL_TEST_P(Transpose, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -620,7 +620,7 @@ TEST_P(Transpose, Mat)
}
}
TEST_P(Transpose, SquareInplace)
OCL_TEST_P(Transpose, SquareInplace)
{
const int type = CV_MAKE_TYPE(depth, cn);
@ -646,7 +646,7 @@ TEST_P(Transpose, SquareInplace)
typedef ArithmTestBase Flip;
TEST_P(Flip, X)
OCL_TEST_P(Flip, X)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -658,7 +658,7 @@ TEST_P(Flip, X)
}
}
TEST_P(Flip, Y)
OCL_TEST_P(Flip, Y)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -670,7 +670,7 @@ TEST_P(Flip, Y)
}
}
TEST_P(Flip, BOTH)
OCL_TEST_P(Flip, BOTH)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -686,7 +686,7 @@ TEST_P(Flip, BOTH)
typedef ArithmTestBase MinMax;
TEST_P(MinMax, MAT)
OCL_TEST_P(MinMax, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -717,7 +717,7 @@ TEST_P(MinMax, MAT)
}
}
TEST_P(MinMax, MASK)
OCL_TEST_P(MinMax, MASK)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -754,7 +754,7 @@ TEST_P(MinMax, MASK)
typedef ArithmTestBase MinMaxLoc;
TEST_P(MinMaxLoc, MAT)
OCL_TEST_P(MinMaxLoc, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -868,7 +868,7 @@ TEST_P(MinMaxLoc, MAT)
}
}
TEST_P(MinMaxLoc, MASK)
OCL_TEST_P(MinMaxLoc, MASK)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -986,7 +986,7 @@ TEST_P(MinMaxLoc, MASK)
typedef ArithmTestBase Sum;
TEST_P(Sum, MAT)
OCL_TEST_P(Sum, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1032,7 +1032,7 @@ static Scalar sqrSum(const Mat & src)
typedef Scalar (*sumFunc)(const Mat &);
TEST_P(SqrSum, MAT)
OCL_TEST_P(SqrSum, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1088,7 +1088,7 @@ static Scalar absSum(const Mat & src)
return sum;
}
TEST_P(AbsSum, MAT)
OCL_TEST_P(AbsSum, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1121,7 +1121,7 @@ TEST_P(AbsSum, MAT)
typedef ArithmTestBase CountNonZero;
TEST_P(CountNonZero, MAT)
OCL_TEST_P(CountNonZero, MAT)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1137,7 +1137,7 @@ TEST_P(CountNonZero, MAT)
typedef ArithmTestBase Phase;
TEST_P(Phase, angleInDegrees)
OCL_TEST_P(Phase, angleInDegrees)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1149,7 +1149,7 @@ TEST_P(Phase, angleInDegrees)
}
}
TEST_P(Phase, angleInRadians)
OCL_TEST_P(Phase, angleInRadians)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1165,7 +1165,7 @@ TEST_P(Phase, angleInRadians)
typedef ArithmTestBase Bitwise_and;
TEST_P(Bitwise_and, Mat)
OCL_TEST_P(Bitwise_and, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1177,7 +1177,7 @@ TEST_P(Bitwise_and, Mat)
}
}
TEST_P(Bitwise_and, Mat_Mask)
OCL_TEST_P(Bitwise_and, Mat_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1189,7 +1189,7 @@ TEST_P(Bitwise_and, Mat_Mask)
}
}
TEST_P(Bitwise_and, Scalar)
OCL_TEST_P(Bitwise_and, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1201,7 +1201,7 @@ TEST_P(Bitwise_and, Scalar)
}
}
TEST_P(Bitwise_and, Scalar_Mask)
OCL_TEST_P(Bitwise_and, Scalar_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1217,7 +1217,7 @@ TEST_P(Bitwise_and, Scalar_Mask)
typedef ArithmTestBase Bitwise_or;
TEST_P(Bitwise_or, Mat)
OCL_TEST_P(Bitwise_or, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1229,7 +1229,7 @@ TEST_P(Bitwise_or, Mat)
}
}
TEST_P(Bitwise_or, Mat_Mask)
OCL_TEST_P(Bitwise_or, Mat_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1241,7 +1241,7 @@ TEST_P(Bitwise_or, Mat_Mask)
}
}
TEST_P(Bitwise_or, Scalar)
OCL_TEST_P(Bitwise_or, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1253,7 +1253,7 @@ TEST_P(Bitwise_or, Scalar)
}
}
TEST_P(Bitwise_or, Scalar_Mask)
OCL_TEST_P(Bitwise_or, Scalar_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1269,7 +1269,7 @@ TEST_P(Bitwise_or, Scalar_Mask)
typedef ArithmTestBase Bitwise_xor;
TEST_P(Bitwise_xor, Mat)
OCL_TEST_P(Bitwise_xor, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1281,7 +1281,7 @@ TEST_P(Bitwise_xor, Mat)
}
}
TEST_P(Bitwise_xor, Mat_Mask)
OCL_TEST_P(Bitwise_xor, Mat_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1293,7 +1293,7 @@ TEST_P(Bitwise_xor, Mat_Mask)
}
}
TEST_P(Bitwise_xor, Scalar)
OCL_TEST_P(Bitwise_xor, Scalar)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1305,7 +1305,7 @@ TEST_P(Bitwise_xor, Scalar)
}
}
TEST_P(Bitwise_xor, Scalar_Mask)
OCL_TEST_P(Bitwise_xor, Scalar_Mask)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1321,7 +1321,7 @@ TEST_P(Bitwise_xor, Scalar_Mask)
typedef ArithmTestBase Bitwise_not;
TEST_P(Bitwise_not, Mat)
OCL_TEST_P(Bitwise_not, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1337,7 +1337,7 @@ TEST_P(Bitwise_not, Mat)
typedef ArithmTestBase Compare;
TEST_P(Compare, Mat)
OCL_TEST_P(Compare, Mat)
{
int cmp_codes[] = { CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE };
int cmp_num = sizeof(cmp_codes) / sizeof(int);
@ -1358,7 +1358,7 @@ TEST_P(Compare, Mat)
typedef ArithmTestBase Pow;
TEST_P(Pow, Mat)
OCL_TEST_P(Pow, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1374,7 +1374,7 @@ TEST_P(Pow, Mat)
typedef ArithmTestBase AddWeighted;
TEST_P(AddWeighted, Mat)
OCL_TEST_P(AddWeighted, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1385,7 +1385,7 @@ TEST_P(AddWeighted, Mat)
cv::addWeighted(src1_roi, alpha, src2_roi, beta, gama, dst1_roi);
cv::ocl::addWeighted(gsrc1_roi, alpha, gsrc2_roi, beta, gama, gdst1_roi);
Near(1e-5);
Near(3e-4);
}
}
@ -1393,7 +1393,7 @@ TEST_P(AddWeighted, Mat)
typedef ArithmTestBase SetIdentity;
TEST_P(SetIdentity, Mat)
OCL_TEST_P(SetIdentity, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1410,7 +1410,7 @@ TEST_P(SetIdentity, Mat)
typedef ArithmTestBase MeanStdDev;
TEST_P(MeanStdDev, Mat)
OCL_TEST_P(MeanStdDev, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -1434,7 +1434,7 @@ TEST_P(MeanStdDev, Mat)
typedef ArithmTestBase Norm;
TEST_P(Norm, NORM_INF)
OCL_TEST_P(Norm, NORM_INF)
{
for (int relative = 0; relative < 2; ++relative)
for (int j = 0; j < LOOP_TIMES; j++)
@ -1452,7 +1452,7 @@ TEST_P(Norm, NORM_INF)
}
}
TEST_P(Norm, NORM_L1)
OCL_TEST_P(Norm, NORM_L1)
{
for (int relative = 0; relative < 2; ++relative)
for (int j = 0; j < LOOP_TIMES; j++)
@ -1466,11 +1466,11 @@ TEST_P(Norm, NORM_L1)
const double cpuRes = cv::norm(src1_roi, src2_roi, type);
const double gpuRes = cv::ocl::norm(gsrc1_roi, gsrc2_roi, type);
EXPECT_NEAR(cpuRes, gpuRes, 0.2);
EXPECT_NEAR(cpuRes, gpuRes, 0.1);
}
}
TEST_P(Norm, NORM_L2)
OCL_TEST_P(Norm, NORM_L2)
{
for (int relative = 0; relative < 2; ++relative)
for (int j = 0; j < LOOP_TIMES; j++)

6
modules/ocl/test/test_bgfg.cpp
View File

@ -90,7 +90,7 @@ PARAM_TEST_CASE(mog, UseGray, LearningRate, bool)
}
};
TEST_P(mog, Update)
OCL_TEST_P(mog, Update)
{
std::string inputFile = string(cvtest::TS::ptr()->get_data_path()) + "gpu/video/768x576.avi";
cv::VideoCapture cap(inputFile);
@ -151,7 +151,7 @@ PARAM_TEST_CASE(mog2, UseGray, DetectShadow, bool)
}
};
TEST_P(mog2, Update)
OCL_TEST_P(mog2, Update)
{
std::string inputFile = string(cvtest::TS::ptr()->get_data_path()) + "gpu/video/768x576.avi";
cv::VideoCapture cap(inputFile);
@ -192,7 +192,7 @@ TEST_P(mog2, Update)
}
}
TEST_P(mog2, getBackgroundImage)
OCL_TEST_P(mog2, getBackgroundImage)
{
if (useGray)
return;

2
modules/ocl/test/test_blend.cpp
View File

@ -88,7 +88,7 @@ PARAM_TEST_CASE(Blend, cv::Size, MatType/*, UseRoi*/)
}
};
TEST_P(Blend, Accuracy)
OCL_TEST_P(Blend, Accuracy)
{
int depth = CV_MAT_DEPTH(type);

6
modules/ocl/test/test_brute_force_matcher.cpp
View File

@ -106,7 +106,7 @@ namespace
}
};
TEST_P(BruteForceMatcher, Match_Single)
OCL_TEST_P(BruteForceMatcher, Match_Single)
{
cv::ocl::BruteForceMatcher_OCL_base matcher(distType);
@ -126,7 +126,7 @@ namespace
ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, KnnMatch_2_Single)
OCL_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
{
const int knn = 2;
@ -158,7 +158,7 @@ namespace
ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, RadiusMatch_Single)
OCL_TEST_P(BruteForceMatcher, RadiusMatch_Single)
{
float radius = 1.f / countFactor;

6
modules/ocl/test/test_calib3d.cpp
View File

@ -62,7 +62,7 @@ PARAM_TEST_CASE(StereoMatchBM, int, int)
}
};
TEST_P(StereoMatchBM, Regression)
OCL_TEST_P(StereoMatchBM, Regression)
{
Mat left_image = readImage("gpu/stereobm/aloe-L.png", IMREAD_GRAYSCALE);
@ -110,7 +110,7 @@ PARAM_TEST_CASE(StereoMatchBP, int, int, int, float, float, float, float)
disc_single_jump_ = GET_PARAM(6);
}
};
TEST_P(StereoMatchBP, Regression)
OCL_TEST_P(StereoMatchBP, Regression)
{
Mat left_image = readImage("gpu/stereobp/aloe-L.png");
Mat right_image = readImage("gpu/stereobp/aloe-R.png");
@ -163,7 +163,7 @@ PARAM_TEST_CASE(StereoMatchConstSpaceBP, int, int, int, int, float, float, float
msg_type_ = GET_PARAM(9);
}
};
TEST_P(StereoMatchConstSpaceBP, Regression)
OCL_TEST_P(StereoMatchConstSpaceBP, Regression)
{
Mat left_image = readImage("gpu/csstereobp/aloe-L.png");
Mat right_image = readImage("gpu/csstereobp/aloe-R.png");

2
modules/ocl/test/test_canny.cpp
View File

@ -64,7 +64,7 @@ PARAM_TEST_CASE(Canny, AppertureSize, L2gradient)
}
};
TEST_P(Canny, Accuracy)
OCL_TEST_P(Canny, Accuracy)
{
cv::Mat img = readImage("cv/shared/fruits.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());

26
modules/ocl/test/test_color.cpp
View File

@ -90,7 +90,7 @@ PARAM_TEST_CASE(CvtColor, cv::Size, MatDepth)
};
#define CVTCODE(name) cv::COLOR_ ## name
#define TEST_P_CVTCOLOR(name) TEST_P(CvtColor, name)\
#define OCL_TEST_P_CVTCOLOR(name) OCL_TEST_P(CvtColor, name)\
{\
cv::Mat src = img;\
cv::ocl::oclMat ocl_img, dst;\
@ -104,17 +104,17 @@ PARAM_TEST_CASE(CvtColor, cv::Size, MatDepth)
}
//add new ones here using macro
TEST_P_CVTCOLOR(RGB2GRAY)
TEST_P_CVTCOLOR(BGR2GRAY)
TEST_P_CVTCOLOR(RGBA2GRAY)
TEST_P_CVTCOLOR(BGRA2GRAY)
OCL_TEST_P_CVTCOLOR(RGB2GRAY)
OCL_TEST_P_CVTCOLOR(BGR2GRAY)
OCL_TEST_P_CVTCOLOR(RGBA2GRAY)
OCL_TEST_P_CVTCOLOR(BGRA2GRAY)
TEST_P_CVTCOLOR(RGB2YUV)
TEST_P_CVTCOLOR(BGR2YUV)
TEST_P_CVTCOLOR(YUV2RGB)
TEST_P_CVTCOLOR(YUV2BGR)
TEST_P_CVTCOLOR(RGB2YCrCb)
TEST_P_CVTCOLOR(BGR2YCrCb)
OCL_TEST_P_CVTCOLOR(RGB2YUV)
OCL_TEST_P_CVTCOLOR(BGR2YUV)
OCL_TEST_P_CVTCOLOR(YUV2RGB)
OCL_TEST_P_CVTCOLOR(YUV2BGR)
OCL_TEST_P_CVTCOLOR(RGB2YCrCb)
OCL_TEST_P_CVTCOLOR(BGR2YCrCb)
PARAM_TEST_CASE(CvtColor_Gray2RGB, cv::Size, MatDepth, int)
{
@ -131,7 +131,7 @@ PARAM_TEST_CASE(CvtColor_Gray2RGB, cv::Size, MatDepth, int)
img = randomMat(size, CV_MAKETYPE(depth, 1), 0.0, depth == CV_32F ? 1.0 : 255.0);
}
};
TEST_P(CvtColor_Gray2RGB, Accuracy)
OCL_TEST_P(CvtColor_Gray2RGB, Accuracy)
{
cv::Mat src = img;
cv::ocl::oclMat ocl_img, dst;
@ -160,7 +160,7 @@ PARAM_TEST_CASE(CvtColor_YUV420, cv::Size, int)
}
};
TEST_P(CvtColor_YUV420, Accuracy)
OCL_TEST_P(CvtColor_YUV420, Accuracy)
{
cv::Mat src = img;
cv::ocl::oclMat ocl_img, dst;

10
modules/ocl/test/test_fft.cpp
View File

@ -44,10 +44,14 @@
//M*/
#include "test_precomp.hpp"
using namespace std;
#ifdef HAVE_CLAMDFFT
////////////////////////////////////////////////////////////////////////////
// Dft
PARAM_TEST_CASE(Dft, cv::Size, int)
{
cv::Size dft_size;
@ -59,7 +63,7 @@ PARAM_TEST_CASE(Dft, cv::Size, int)
}
};
TEST_P(Dft, C2C)
OCL_TEST_P(Dft, C2C)
{
cv::Mat a = randomMat(dft_size, CV_32FC2, 0.0, 100.0);
cv::Mat b_gold;
@ -71,7 +75,7 @@ TEST_P(Dft, C2C)
EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), a.size().area() * 1e-4);
}
TEST_P(Dft, R2C)
OCL_TEST_P(Dft, R2C)
{
cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 100.0);
cv::Mat b_gold, b_gold_roi;
@ -88,7 +92,7 @@ TEST_P(Dft, R2C)
EXPECT_MAT_NEAR(b_gold_roi, cv::Mat(d_b), a.size().area() * 1e-4);
}
TEST_P(Dft, R2CthenC2R)
OCL_TEST_P(Dft, R2CthenC2R)
{
cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 10.0);

18
modules/ocl/test/test_filters.cpp
View File

@ -145,7 +145,7 @@ struct Blur : FilterTestBase
}
};
TEST_P(Blur, Mat)
OCL_TEST_P(Blur, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -172,7 +172,7 @@ struct Laplacian : FilterTestBase
}
};
TEST_P(Laplacian, Accuracy)
OCL_TEST_P(Laplacian, Accuracy)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -205,7 +205,7 @@ struct ErodeDilate : FilterTestBase
};
TEST_P(ErodeDilate, Mat)
OCL_TEST_P(ErodeDilate, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -244,7 +244,7 @@ struct Sobel : FilterTestBase
}
};
TEST_P(Sobel, Mat)
OCL_TEST_P(Sobel, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -274,7 +274,7 @@ struct Scharr : FilterTestBase
}
};
TEST_P(Scharr, Mat)
OCL_TEST_P(Scharr, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -307,7 +307,7 @@ struct GaussianBlur : FilterTestBase
}
};
TEST_P(GaussianBlur, Mat)
OCL_TEST_P(GaussianBlur, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -339,7 +339,7 @@ struct Filter2D : FilterTestBase
}
};
TEST_P(Filter2D, Mat)
OCL_TEST_P(Filter2D, Mat)
{
cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
for(int j = 0; j < LOOP_TIMES; j++)
@ -370,7 +370,7 @@ struct Bilateral : FilterTestBase
}
};
TEST_P(Bilateral, Mat)
OCL_TEST_P(Bilateral, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -400,7 +400,7 @@ struct AdaptiveBilateral : FilterTestBase
}
};
TEST_P(AdaptiveBilateral, Mat)
OCL_TEST_P(AdaptiveBilateral, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{

2
modules/ocl/test/test_gemm.cpp
View File

@ -62,7 +62,7 @@ PARAM_TEST_CASE(Gemm, int, cv::Size, int)
}
};
TEST_P(Gemm, Accuracy)
OCL_TEST_P(Gemm, Accuracy)
{
cv::Mat a = randomMat(mat_size, type, 0.0, 10.0);
cv::Mat b = randomMat(mat_size, type, 0.0, 10.0);

34
modules/ocl/test/test_imgproc.cpp
View File

@ -453,7 +453,7 @@ PARAM_TEST_CASE(ImgprocTestBase, MatType, MatType, MatType, MatType, MatType, bo
struct equalizeHist : ImgprocTestBase {};
TEST_P(equalizeHist, Mat)
OCL_TEST_P(equalizeHist, Mat)
{
if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
{
@ -477,7 +477,7 @@ TEST_P(equalizeHist, Mat)
struct CopyMakeBorder : ImgprocTestBase {};
TEST_P(CopyMakeBorder, Mat)
OCL_TEST_P(CopyMakeBorder, Mat)
{
int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT_101};
int top = rng.uniform(0, 10);
@ -532,7 +532,7 @@ TEST_P(CopyMakeBorder, Mat)
struct cornerMinEigenVal : ImgprocTestBase {};
TEST_P(cornerMinEigenVal, Mat)
OCL_TEST_P(cornerMinEigenVal, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -554,7 +554,7 @@ TEST_P(cornerMinEigenVal, Mat)
struct cornerHarris : ImgprocTestBase {};
TEST_P(cornerHarris, Mat)
OCL_TEST_P(cornerHarris, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -576,7 +576,7 @@ TEST_P(cornerHarris, Mat)
struct integral : ImgprocTestBase {};
TEST_P(integral, Mat1)
OCL_TEST_P(integral, Mat1)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -588,7 +588,7 @@ TEST_P(integral, Mat1)
}
}
TEST_P(integral, Mat2)
OCL_TEST_P(integral, Mat2)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -690,7 +690,7 @@ PARAM_TEST_CASE(WarpTestBase, MatType, int)
struct WarpAffine : WarpTestBase {};
TEST_P(WarpAffine, Mat)
OCL_TEST_P(WarpAffine, Mat)
{
static const double coeffs[2][3] =
{
@ -718,7 +718,7 @@ TEST_P(WarpAffine, Mat)
struct WarpPerspective : WarpTestBase {};
TEST_P(WarpPerspective, Mat)
OCL_TEST_P(WarpPerspective, Mat)
{
static const double coeffs[3][3] =
{
@ -887,7 +887,7 @@ PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int)
}
};
TEST_P(Remap, Mat)
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))
{
@ -1012,7 +1012,7 @@ PARAM_TEST_CASE(Resize, MatType, cv::Size, double, double, int)
};
TEST_P(Resize, Mat)
OCL_TEST_P(Resize, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -1105,7 +1105,7 @@ PARAM_TEST_CASE(Threshold, MatType, ThreshOp)
};
TEST_P(Threshold, Mat)
OCL_TEST_P(Threshold, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -1206,7 +1206,7 @@ PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, cv::TermCriteria)
/////////////////////////meanShiftFiltering/////////////////////////////
struct meanShiftFiltering : meanShiftTestBase {};
TEST_P(meanShiftFiltering, Mat)
OCL_TEST_P(meanShiftFiltering, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
@ -1227,7 +1227,7 @@ TEST_P(meanShiftFiltering, Mat)
///////////////////////////meanShiftProc//////////////////////////////////
struct meanShiftProc : meanShiftTestBase {};
TEST_P(meanShiftProc, Mat)
OCL_TEST_P(meanShiftProc, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
@ -1315,7 +1315,7 @@ PARAM_TEST_CASE(histTestBase, MatType, MatType)
///////////////////////////calcHist///////////////////////////////////////
struct calcHist : histTestBase {};
TEST_P(calcHist, Mat)
OCL_TEST_P(calcHist, Mat)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -1354,7 +1354,7 @@ PARAM_TEST_CASE(CLAHE, cv::Size, double)
}
};
TEST_P(CLAHE, Accuracy)
OCL_TEST_P(CLAHE, Accuracy)
{
cv::Ptr<cv::CLAHE> clahe = cv::ocl::createCLAHE(clipLimit, gridSize);
clahe->apply(g_src, g_dst);
@ -1477,7 +1477,7 @@ void conv2( cv::Mat x, cv::Mat y, cv::Mat z)
dstdata[i * (z.step >> 2) + j] = temp;
}
}
TEST_P(Convolve, Mat)
OCL_TEST_P(Convolve, Mat)
{
if(mat1.type() != CV_32FC1)
{
@ -1512,7 +1512,7 @@ PARAM_TEST_CASE(ColumnSum, cv::Size)
}
};
TEST_P(ColumnSum, Accuracy)
OCL_TEST_P(ColumnSum, Accuracy)
{
cv::Mat src = randomMat(size, CV_32FC1, 0, 255);
cv::ocl::oclMat d_dst;

12
modules/ocl/test/test_kalman.cpp
View File

@ -43,7 +43,11 @@
//M*/
#include "test_precomp.hpp"
#ifdef HAVE_OPENCL
#ifdef HAVE_CLAMDBLAS
using namespace cv;
using namespace cv::ocl;
using namespace cvtest;
@ -51,6 +55,7 @@ using namespace testing;
using namespace std;
//////////////////////////////////////////////////////////////////////////
PARAM_TEST_CASE(Kalman, int, int)
{
int size_;
@ -62,7 +67,7 @@ PARAM_TEST_CASE(Kalman, int, int)
}
};
TEST_P(Kalman, Accuracy)
OCL_TEST_P(Kalman, Accuracy)
{
const int Dim = size_;
const int Steps = iteration;
@ -139,6 +144,9 @@ TEST_P(Kalman, Accuracy)
//test end
EXPECT_MAT_NEAR(kalman_filter_cpu.statePost, kalman_filter_ocl.statePost, 0);
}
INSTANTIATE_TEST_CASE_P(OCL_Video, Kalman, Combine(Values(3, 7), Values(30)));
#endif // HAVE_OPENCL
#endif // HAVE_CLAMDBLAS
#endif // HAVE_OPENCL

2
modules/ocl/test/test_kmeans.cpp
View File

@ -98,7 +98,7 @@ PARAM_TEST_CASE(Kmeans, int, int, int)
}
}
};
TEST_P(Kmeans, Mat){
OCL_TEST_P(Kmeans, Mat){
if(flags & KMEANS_USE_INITIAL_LABELS)
{

4
modules/ocl/test/test_match_template.cpp
View File

@ -70,7 +70,7 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::Size, TemplateSize, Channels, TemplateMetho
}
};
TEST_P(MatchTemplate8U, Accuracy)
OCL_TEST_P(MatchTemplate8U, Accuracy)
{
cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn), 0, 255);
cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn), 0, 255);
@ -103,7 +103,7 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::Size, TemplateSize, Channels, TemplateMeth
}
};
TEST_P(MatchTemplate32F, Accuracy)
OCL_TEST_P(MatchTemplate32F, Accuracy)
{
cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn), 0, 255);
cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn), 0, 255);

12
modules/ocl/test/test_matrix_operation.cpp
View File

@ -126,7 +126,7 @@ PARAM_TEST_CASE(ConvertToTestBase, MatType, MatType, int, bool)
typedef ConvertToTestBase ConvertTo;
TEST_P(ConvertTo, Accuracy)
OCL_TEST_P(ConvertTo, Accuracy)
{
if((src_depth == CV_64F || dst_depth == CV_64F) &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@ -219,7 +219,7 @@ PARAM_TEST_CASE(CopyToTestBase, MatType, int, bool)
typedef CopyToTestBase CopyTo;
TEST_P(CopyTo, Without_mask)
OCL_TEST_P(CopyTo, Without_mask)
{
if((src.depth() == CV_64F) &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@ -237,7 +237,7 @@ TEST_P(CopyTo, Without_mask)
}
}
TEST_P(CopyTo, With_mask)
OCL_TEST_P(CopyTo, With_mask)
{
if(src.depth() == CV_64F &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@ -331,7 +331,7 @@ PARAM_TEST_CASE(SetToTestBase, MatType, int, bool)
typedef SetToTestBase SetTo;
TEST_P(SetTo, Without_mask)
OCL_TEST_P(SetTo, Without_mask)
{
if(depth == CV_64F &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@ -349,7 +349,7 @@ TEST_P(SetTo, Without_mask)
}
}
TEST_P(SetTo, With_mask)
OCL_TEST_P(SetTo, With_mask)
{
if(depth == CV_64F &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@ -417,7 +417,7 @@ PARAM_TEST_CASE(convertC3C4, MatType, bool)
}
};
TEST_P(convertC3C4, Accuracy)
OCL_TEST_P(convertC3C4, Accuracy)
{
if(depth == CV_64F &&
!cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))

17
modules/ocl/test/test_ml.cpp
View File

@ -44,12 +44,16 @@
//M*/
#include "test_precomp.hpp"
#ifdef HAVE_OPENCL
using namespace cv;
using namespace cv::ocl;
using namespace cvtest;
using namespace testing;
///////K-NEAREST NEIGHBOR//////////////////////////
static void genTrainData(cv::RNG& rng, Mat& trainData, int trainDataRow, int trainDataCol,
Mat& trainLabel = Mat().setTo(Scalar::all(0)), int nClasses = 0)
{
@ -80,7 +84,7 @@ PARAM_TEST_CASE(KNN, int, Size, int, bool)
}
};
TEST_P(KNN, Accuracy)
OCL_TEST_P(KNN, Accuracy)
{
Mat trainData, trainLabels;
const int trainDataRow = 500;
@ -118,10 +122,14 @@ TEST_P(KNN, Accuracy)
EXPECT_MAT_NEAR(Mat(best_label_ocl), best_label_cpu, 0.0);
}
}
INSTANTIATE_TEST_CASE_P(OCL_ML, KNN, Combine(Values(6, 5), Values(Size(200, 400), Size(300, 600)),
Values(4, 3), Values(false, true)));
////////////////////////////////SVM/////////////////////////////////////////////////
#ifdef HAVE_CLAMDBLAS
PARAM_TEST_CASE(SVM_OCL, int, int, int)
{
cv::Size size;
@ -193,7 +201,8 @@ PARAM_TEST_CASE(SVM_OCL, int, int, int)
labels_predict.convertTo(labels_predict, CV_32FC1);
}
};
TEST_P(SVM_OCL, Accuracy)
OCL_TEST_P(SVM_OCL, Accuracy)
{
CvSVMParams params;
params.degree = 0.4;
@ -289,11 +298,15 @@ TEST_P(SVM_OCL, Accuracy)
}
}
}
// TODO FIXIT: CvSVM::EPS_SVR case is crashed inside CPU implementation
// Anonymous enums are not supported well so cast them to 'int'
INSTANTIATE_TEST_CASE_P(OCL_ML, SVM_OCL, testing::Combine(
Values((int)CvSVM::LINEAR, (int)CvSVM::POLY, (int)CvSVM::RBF, (int)CvSVM::SIGMOID),
Values((int)CvSVM::C_SVC, (int)CvSVM::NU_SVC, (int)CvSVM::ONE_CLASS, (int)CvSVM::NU_SVR),
Values(2, 3, 4)
));
#endif // HAVE_CLAMDBLAS
#endif // HAVE_OPENCL

2
modules/ocl/test/test_moments.cpp
View File

@ -35,7 +35,7 @@ PARAM_TEST_CASE(MomentsTest, MatType, bool)
};
TEST_P(MomentsTest, Mat)
OCL_TEST_P(MomentsTest, Mat)
{
bool binaryImage = 0;

8
modules/ocl/test/test_objdetect.cpp
View File

@ -66,7 +66,7 @@ PARAM_TEST_CASE(HOG, Size, int)
}
};
TEST_P(HOG, GetDescriptors)
OCL_TEST_P(HOG, GetDescriptors)
{
// Convert image
Mat img;
@ -112,7 +112,7 @@ TEST_P(HOG, GetDescriptors)
EXPECT_MAT_SIMILAR(down_descriptors, cpu_descriptors, 1e-2);
}
TEST_P(HOG, Detect)
OCL_TEST_P(HOG, Detect)
{
// Convert image
Mat img;
@ -216,7 +216,7 @@ PARAM_TEST_CASE(Haar, int, CascadeName)
}
};
TEST_P(Haar, FaceDetect)
OCL_TEST_P(Haar, FaceDetect)
{
MemStorage storage(cvCreateMemStorage(0));
CvSeq *_objects;
@ -234,7 +234,7 @@ TEST_P(Haar, FaceDetect)
EXPECT_LT(checkRectSimilarity(img.size(), faces, oclfaces), 1.0);
}
TEST_P(Haar, FaceDetectUseBuf)
OCL_TEST_P(Haar, FaceDetectUseBuf)
{
ocl::OclCascadeClassifierBuf cascadebuf;
ASSERT_TRUE(cascadebuf.load(cascadeName)) << "could not load classifier cascade for FaceDetectUseBuf!";

10
modules/ocl/test/test_optflow.cpp
View File

@ -70,7 +70,7 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, MinDistance)
}
};
TEST_P(GoodFeaturesToTrack, Accuracy)
OCL_TEST_P(GoodFeaturesToTrack, Accuracy)
{
cv::Mat frame = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame.empty());
@ -111,7 +111,7 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
ASSERT_LE(bad_ratio, 0.01);
}
TEST_P(GoodFeaturesToTrack, EmptyCorners)
OCL_TEST_P(GoodFeaturesToTrack, EmptyCorners)
{
int maxCorners = 1000;
double qualityLevel = 0.01;
@ -141,7 +141,7 @@ PARAM_TEST_CASE(TVL1, bool)
};
TEST_P(TVL1, Accuracy)
OCL_TEST_P(TVL1, Accuracy)
{
cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());
@ -182,7 +182,7 @@ PARAM_TEST_CASE(Sparse, bool, bool)
}
};
TEST_P(Sparse, Mat)
OCL_TEST_P(Sparse, Mat)
{
cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
ASSERT_FALSE(frame0.empty());
@ -295,7 +295,7 @@ PARAM_TEST_CASE(Farneback, PyrScale, PolyN, FarnebackOptFlowFlags, UseInitFlow)
}
};
TEST_P(Farneback, Accuracy)
OCL_TEST_P(Farneback, Accuracy)
{
cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());

4
modules/ocl/test/test_pyramids.cpp
View File

@ -74,7 +74,7 @@ PARAM_TEST_CASE(PyrBase, MatType, int)
typedef PyrBase PyrDown;
TEST_P(PyrDown, Mat)
OCL_TEST_P(PyrDown, Mat)
{
for (int j = 0; j < LOOP_TIMES; j++)
{
@ -97,7 +97,7 @@ INSTANTIATE_TEST_CASE_P(OCL_ImgProc, PyrDown, Combine(
typedef PyrBase PyrUp;
TEST_P(PyrUp, Accuracy)
OCL_TEST_P(PyrUp, Accuracy)
{
for (int j = 0; j < LOOP_TIMES; j++)
{

2
modules/ocl/test/test_sort.cpp
View File

@ -229,7 +229,7 @@ PARAM_TEST_CASE(SortByKey, InputSize, MatType, MatType, SortMethod, IsGreaterTha
}
};
TEST_P(SortByKey, Accuracy)
OCL_TEST_P(SortByKey, Accuracy)
{
using namespace cv;
ocl::oclMat oclmat_key(mat_key);

4
modules/ocl/test/test_split_merge.cpp
View File

@ -139,7 +139,7 @@ PARAM_TEST_CASE(MergeTestBase, MatType, int, bool)
struct Merge : MergeTestBase {};
TEST_P(Merge, Accuracy)
OCL_TEST_P(Merge, Accuracy)
{
for(int j = 0; j < LOOP_TIMES; j++)
{
@ -238,7 +238,7 @@ PARAM_TEST_CASE(SplitTestBase, MatType, int, bool)
struct Split : SplitTestBase {};
TEST_P(Split, Accuracy)
OCL_TEST_P(Split, Accuracy)
{
for(int j = 0; j < LOOP_TIMES; j++)
{

48
modules/ocl/test/utility.hpp
View File

@ -42,7 +42,7 @@
#ifndef __OPENCV_TEST_UTILITY_HPP__
#define __OPENCV_TEST_UTILITY_HPP__
#define LOOP_TIMES 10
#define LOOP_TIMES 1
#define MWIDTH 256
#define MHEIGHT 256
@ -254,4 +254,50 @@ CV_FLAGS(GemmFlags, GEMM_1_T, GEMM_2_T, GEMM_3_T);
CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)
CV_FLAGS(DftFlags, DFT_INVERSE, DFT_SCALE, DFT_ROWS, DFT_COMPLEX_OUTPUT, DFT_REAL_OUTPUT)
# define OCL_TEST_P(test_case_name, test_name) \
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : \
public test_case_name { \
public: \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() { } \
virtual void TestBody(); \
void OCLTestBody(); \
private: \
static int AddToRegistry() \
{ \
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
GetTestCasePatternHolder<test_case_name>(\
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\
#test_case_name, \
#test_name, \
new ::testing::internal::TestMetaFactory< \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
return 0; \
} \
\
static int gtest_registering_dummy_; \
GTEST_DISALLOW_COPY_AND_ASSIGN_(\
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
}; \
\
int GTEST_TEST_CLASS_NAME_(test_case_name, \
test_name)::gtest_registering_dummy_ = \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
\
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() \
{ \
try \
{ \
OCLTestBody(); \
} \
catch (const cv::Exception & ex) \
{ \
if (ex.code != CV_OpenCLDoubleNotSupported) \
throw; \
else \
std::cout << "Test skipped (selected device does not support double)" << std::endl; \
} \
} \
\
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::OCLTestBody()
#endif // __OPENCV_TEST_UTILITY_HPP__