#else
#define CV_OCL_RUN(condition, func)
#endif
-
OCL_OP_AND=9, OCL_OP_OR=10, OCL_OP_XOR=11, OCL_OP_NOT=12, OCL_OP_MIN=13, OCL_OP_MAX=14,
OCL_OP_RDIV_SCALE=15 };
+#ifdef HAVE_OPENCL
+
static const char* oclop2str[] = { "OP_ADD", "OP_SUB", "OP_RSUB", "OP_ABSDIFF",
"OP_MUL", "OP_MUL_SCALE", "OP_DIV_SCALE", "OP_RECIP_SCALE",
"OP_ADDW", "OP_AND", "OP_OR", "OP_XOR", "OP_NOT", "OP_MIN", "OP_MAX", "OP_RDIV_SCALE", 0 };
return k.run(2, globalsize, 0, false);
}
+#endif
static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, const BinaryFunc* tab,
int dims1 = psrc1->dims(), dims2 = psrc2->dims();
Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
+#ifdef HAVE_OPENCL
bool use_opencl = (kind1 == _InputArray::UMAT || kind2 == _InputArray::UMAT) &&
- ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2;
+ dims1 <= 2 && dims2 <= 2;
+#endif
bool haveMask = !_mask.empty(), haveScalar = false;
BinaryFunc func;
if( dims1 <= 2 && dims2 <= 2 && kind1 == kind2 && sz1 == sz2 && type1 == type2 && !haveMask )
{
_dst.create(sz1, type1);
- if( use_opencl && ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, false) )
- return;
+ CV_OCL_RUN(use_opencl,
+ ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, false))
+
if( bitwise )
{
func = *tab;
if( haveMask && reallocate )
_dst.setTo(0.);
- if( use_opencl && ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, haveScalar ))
- return;
+ CV_OCL_RUN(use_opencl,
+ ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, haveScalar))
+
Mat src1 = psrc1->getMat(), src2 = psrc2->getMat();
Mat dst = _dst.getMat(), mask = _mask.getMat();
cn = (int)esz;
}
else
- {
func = tab[depth1];
- }
if( !haveScalar )
{
CV_32S;
}
+#ifdef HAVE_OPENCL
static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, int wtype,
return k.run(2, globalsize, NULL, false);
}
+#endif
static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, int dtype, BinaryFunc* tab, bool muldiv=false,
int wtype, dims1 = psrc1->dims(), dims2 = psrc2->dims();
Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
- bool use_opencl = _dst.isUMat() && ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2;
+#ifdef HAVE_OPENCL
+ bool use_opencl = _dst.isUMat() && dims1 <= 2 && dims2 <= 2;
+#endif
bool src1Scalar = checkScalar(*psrc1, type2, kind1, kind2);
bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1);
((src1Scalar && src2Scalar) || (!src1Scalar && !src2Scalar)) )
{
_dst.createSameSize(*psrc1, type1);
- if( use_opencl &&
+ CV_OCL_RUN(use_opencl,
ocl_arithm_op(*psrc1, *psrc2, _dst, _mask,
(!usrdata ? type1 : std::max(depth1, CV_32F)),
usrdata, oclop, false))
- return;
Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(), dst = _dst.getMat();
Size sz = getContinuousSize(src1, src2, dst, src1.channels());
if( reallocate )
_dst.setTo(0.);
- if( use_opencl &&
- ocl_arithm_op(*psrc1, *psrc2, _dst, _mask, wtype,
- usrdata, oclop, haveScalar))
- return;
+ CV_OCL_RUN(use_opencl,
+ ocl_arithm_op(*psrc1, *psrc2, _dst, _mask, wtype,
+ usrdata, oclop, haveScalar))
BinaryFunc cvtsrc1 = type1 == wtype ? 0 : getConvertFunc(type1, wtype);
BinaryFunc cvtsrc2 = type2 == type1 ? cvtsrc1 : type2 == wtype ? 0 : getConvertFunc(type2, wtype);
return tab[depth];
}
+#ifdef HAVE_OPENCL
+
static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
{
if ( !((_src1.isMat() || _src1.isUMat()) && (_src2.isMat() || _src2.isUMat())) )
return k.run(2, globalsize, NULL, false);
}
+#endif
+
}
void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
CV_Assert( op == CMP_LT || op == CMP_LE || op == CMP_EQ ||
op == CMP_NE || op == CMP_GE || op == CMP_GT );
- if (ocl::useOpenCL() && _src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat() &&
- ocl_compare(_src1, _src2, _dst, op))
- return;
+ CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat(),
+ ocl_compare(_src1, _src2, _dst, op))
int kind1 = _src1.kind(), kind2 = _src2.kind();
Mat src1 = _src1.getMat(), src2 = _src2.getMat();
return inRangeTab[depth];
}
+#ifdef HAVE_OPENCL
+
static bool ocl_inRange( InputArray _src, InputArray _lowerb,
InputArray _upperb, OutputArray _dst )
{
return ker.run(2, globalsize, NULL, false);
}
+#endif
+
}
void cv::inRange(InputArray _src, InputArray _lowerb,
InputArray _upperb, OutputArray _dst)
{
- if (ocl::useOpenCL() && _src.dims() <= 2 && _lowerb.dims() <= 2 &&
- _upperb.dims() <= 2 && _dst.isUMat() && ocl_inRange(_src, _lowerb, _upperb, _dst))
- return;
+ CV_OCL_RUN(_src.dims() <= 2 && _lowerb.dims() <= 2 &&
+ _upperb.dims() <= 2 && _dst.isUMat(),
+ ocl_inRange(_src, _lowerb, _upperb, _dst))
int skind = _src.kind(), lkind = _lowerb.kind(), ukind = _upperb.kind();
Mat src = _src.getMat(), lb = _lowerb.getMat(), ub = _upperb.getMat();
}
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
}
+#endif
+
void cv::split(InputArray _m, OutputArrayOfArrays _mv)
{
- if (ocl::useOpenCL() && _m.dims() <= 2 && _mv.isUMatVector() &&
- ocl_split(_m, _mv))
- return;
+ CV_OCL_RUN(_m.dims() <= 2 && _mv.isUMatVector(),
+ ocl_split(_m, _mv))
Mat m = _m.getMat();
if( m.empty() )
}
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
}
+#endif
+
void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
{
- if (ocl::useOpenCL() && _mv.isUMatVector() && _dst.isUMat() && ocl_merge(_mv, _dst))
- return;
+ CV_OCL_RUN(_mv.isUMatVector() && _dst.isUMat(),
+ ocl_merge(_mv, _dst))
std::vector<Mat> mv;
_mv.getMatVector(mv);
}
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static void getUMatIndex(const std::vector<UMat> & um, int cn, int & idx, int & cnidx)
}
+#endif
+
void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
const int* fromTo, size_t npairs)
{
if (npairs == 0 || fromTo == NULL)
return;
- if (ocl::useOpenCL() && src.isUMatVector() && dst.isUMatVector() &&
- ocl_mixChannels(src, dst, fromTo, npairs))
- return;
+ CV_OCL_RUN(src.isUMatVector() && dst.isUMatVector(),
+ ocl_mixChannels(src, dst, fromTo, npairs))
bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
src.kind() != _InputArray::STD_VECTOR_VECTOR &&
if (fromTo.empty())
return;
- if (ocl::useOpenCL() && src.isUMatVector() && dst.isUMatVector() &&
- ocl_mixChannels(src, dst, &fromTo[0], fromTo.size()>>1))
- return;
+ CV_OCL_RUN(src.isUMatVector() && dst.isUMatVector(),
+ ocl_mixChannels(src, dst, &fromTo[0], fromTo.size()>>1))
bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
src.kind() != _InputArray::STD_VECTOR_VECTOR &&
return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
}
+#ifdef HAVE_OPENCL
+
static bool ocl_convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
{
int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
return k.run(2, globalsize, NULL, false);
}
+#endif
+
}
void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
{
- if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat() &&
- ocl_convertScaleAbs(_src, _dst, alpha, beta))
- return;
+ CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
+ ocl_convertScaleAbs(_src, _dst, alpha, beta))
Mat src = _src.getMat();
int cn = src.channels();
(LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0
};
-}
-
-namespace cv {
+#ifdef HAVE_OPENCL
static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst)
{
return k.run(2, globalSize, NULL, false);
}
-} // cv
+#endif
+
+}
void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
{
_lut.total() == 256 && _lut.isContinuous() &&
(depth == CV_8U || depth == CV_8S) );
- if (ocl::useOpenCL() && _dst.isUMat() && ocl_LUT(_src, _lut, _dst))
- return;
+ CV_OCL_RUN(_dst.isUMat(),
+ ocl_LUT(_src, _lut, _dst))
Mat src = _src.getMat(), lut = _lut.getMat();
_dst.create(src.dims, src.size, CV_MAKETYPE(_lut.depth(), cn));
namespace cv {
+#ifdef HAVE_OPENCL
+
static bool ocl_normalize( InputArray _src, OutputArray _dst, InputArray _mask, int rtype,
double scale, double shift )
{
return true;
}
+#endif
+
}
void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
rtype = _dst.fixedType() ? _dst.depth() : depth;
_dst.createSameSize(_src, CV_MAKETYPE(rtype, cn));
- if (ocl::useOpenCL() && _dst.isUMat() &&
- ocl_normalize(_src, _dst, _mask, rtype, scale, shift))
- return;
+ CV_OCL_RUN(_dst.isUMat(),
+ ocl_normalize(_src, _dst, _mask, rtype, scale, shift))
Mat src = _src.getMat(), dst = _dst.getMat();
if( _mask.empty() )
}
}
+#ifdef HAVE_OPENCL
+
enum { FLIP_COLS = 1 << 0, FLIP_ROWS = 1 << 1, FLIP_BOTH = FLIP_ROWS | FLIP_COLS };
static bool ocl_flip(InputArray _src, OutputArray _dst, int flipCode )
return k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::WriteOnly(dst), rows, cols).run(2, globalsize, NULL, false);
}
+#endif
+
void flip( InputArray _src, OutputArray _dst, int flip_mode )
{
CV_Assert( _src.dims() <= 2 );
- bool use_opencl = ocl::useOpenCL() && _dst.isUMat();
- if ( use_opencl && ocl_flip(_src,_dst, flip_mode))
- return;
+ CV_OCL_RUN( _dst.isUMat(), ocl_flip(_src,_dst, flip_mode))
Mat src = _src.getMat();
_dst.create( src.size(), src.type() );
flipHoriz( dst.data, dst.step, dst.data, dst.step, dst.size(), esz );
}
+#ifdef HAVE_OPENCL
static bool ocl_repeat(InputArray _src, int ny, int nx, OutputArray _dst)
{
return true;
}
+#endif
+
void repeat(InputArray _src, int ny, int nx, OutputArray _dst)
{
CV_Assert( _src.dims() <= 2 );
Size ssize = _src.size();
_dst.create(ssize.height*ny, ssize.width*nx, _src.type());
- if (ocl::useOpenCL() && _src.isUMat())
- {
- CV_Assert(ocl_repeat(_src, ny, nx, _dst));
- return;
- }
+ CV_OCL_RUN(_dst.isUMat(),
+ ocl_repeat(_src, ny, nx, _dst))
Mat src = _src.getMat(), dst = _dst.getMat();
Size dsize = dst.size();
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
}
+#endif
+
void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
int left, int right, int borderType, const Scalar& value )
{
CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 );
- if (ocl::useOpenCL() && _dst.isUMat() && _src.dims() <= 2 &&
- ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value))
- return;
+ CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2,
+ ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value))
Mat src = _src.getMat();
void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
{
#ifdef HAVE_CLAMDFFT
- if (ocl::useOpenCL() && ocl::haveAmdFft() && ocl::Device::getDefault().type() != ocl::Device::TYPE_CPU &&
- _dst.isUMat() && _src0.dims() <= 2 && nonzero_rows == 0 && ocl_dft(_src0, _dst, flags))
- return;
+ CV_OCL_RUN(ocl::haveAmdFft() && ocl::Device::getDefault().type() != ocl::Device::TYPE_CPU &&
+ _dst.isUMat() && _src0.dims() <= 2 && nonzero_rows == 0,
+ ocl_dft(_src0, _dst, flags))
#endif
static DFTFunc dft_tbl[6] =
dft( src, dst, flags | DFT_INVERSE, nonzero_rows );
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_mulSpectrums( InputArray _srcA, InputArray _srcB,
}
+#endif
+
void cv::mulSpectrums( InputArray _srcA, InputArray _srcB,
OutputArray _dst, int flags, bool conjB )
{
- if (ocl::useOpenCL() && _dst.isUMat() &&
+ CV_OCL_RUN(_dst.isUMat() && _srcA.dims() <= 2 && _srcB.dims() <= 2,
ocl_mulSpectrums(_srcA, _srcB, _dst, flags, conjB))
- return;
Mat srcA = _srcA.getMat(), srcB = _srcB.getMat();
int depth = srcA.depth(), cn = srcA.channels(), type = srcA.type();
InputArray matC, double beta, OutputArray _matD, int flags )
{
#ifdef HAVE_CLAMDBLAS
- if (ocl::haveAmdBlas() && matA.dims() <= 2 && matB.dims() <= 2 && matC.dims() <= 2 &&
- ocl::useOpenCL() && _matD.isUMat() &&
+ CV_OCL_RUN(ocl::haveAmdBlas() && matA.dims() <= 2 && matB.dims() <= 2 && matC.dims() <= 2 && _matD.isUMat(),
ocl_gemm(matA, matB, alpha, matC, beta, _matD, flags))
- return;
#endif
const int block_lin_size = 128;
typedef void (*ScaleAddFunc)(const uchar* src1, const uchar* src2, uchar* dst, int len, const void* alpha);
+#ifdef HAVE_OPENCL
+
static bool ocl_scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray _dst, int type )
{
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), wdepth = std::max(depth, CV_32F);
return k.run(2, globalsize, NULL, false);
}
+#endif
+
}
void cv::scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray _dst )
int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
CV_Assert( type == _src2.type() );
- if (ocl::useOpenCL() && _src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat() &&
+ CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat(),
ocl_scaleAdd(_src1, alpha, _src2, _dst, type))
- return;
if( depth < CV_32F )
{
//////////////////////////////////////// set identity ////////////////////////////////////////////
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
}
+#endif
+
void cv::setIdentity( InputOutputArray _m, const Scalar& s )
{
CV_Assert( _m.dims() <= 2 );
- if (ocl::useOpenCL() && _m.isUMat() && ocl_setIdentity(_m, s))
- return;
+ CV_OCL_RUN(_m.isUMat(),
+ ocl_setIdentity(_m, s))
Mat m = _m.getMat();
int i, j, rows = m.rows, cols = m.cols, type = m.type();
0, 0, 0, 0, 0, 0, 0, transposeI_32sC6, 0, 0, 0, 0, 0, 0, 0, transposeI_32sC8
};
+#ifdef HAVE_OPENCL
+
static inline int divUp(int a, int b)
{
return (a + b - 1) / b;
return k.run(2, globalsize, localsize, false);
}
+#endif
+
}
void cv::transpose( InputArray _src, OutputArray _dst )
int type = _src.type(), esz = CV_ELEM_SIZE(type);
CV_Assert( _src.dims() <= 2 && esz <= 32 );
- if (ocl::useOpenCL() && _dst.isUMat() && ocl_transpose(_src, _dst))
- return;
+ CV_OCL_RUN(_dst.isUMat(),
+ ocl_transpose(_src, _dst))
Mat src = _src.getMat();
if( src.empty() )
#define reduceMinC32f reduceC_<float, float, OpMin<float> >
#define reduceMinC64f reduceC_<double,double,OpMin<double> >
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_reduce(InputArray _src, OutputArray _dst,
}
+#endif
+
void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
{
CV_Assert( _src.dims() <= 2 );
CV_Assert( op == CV_REDUCE_SUM || op == CV_REDUCE_MAX ||
op == CV_REDUCE_MIN || op == CV_REDUCE_AVG );
- if (ocl::useOpenCL() && _dst.isUMat() &&
- ocl_reduce(_src, _dst, dim, op, op0, stype, dtype))
- return;
+ CV_OCL_RUN(_dst.isUMat(),
+ ocl_reduce(_src, _dst, dim, op, op0, stype, dtype))
Mat src = _src.getMat();
_dst.create(dim == 0 ? 1 : src.rows, dim == 0 ? src.cols : 1, dtype);
return s;
}
+#ifdef HAVE_OPENCL
+
enum { OCL_OP_SUM = 0, OCL_OP_SUM_ABS = 1, OCL_OP_SUM_SQR = 2 };
static bool ocl_sum( InputArray _src, Scalar & res, int sum_op, InputArray _mask = noArray() )
return false;
}
+#endif
+
}
cv::Scalar cv::sum( InputArray _src )
{
+#ifdef HAVE_OPENCL
Scalar _res;
if (ocl::useOpenCL() && _src.isUMat() && ocl_sum(_src, _res, OCL_OP_SUM))
return _res;
+#endif
Mat src = _src.getMat();
int k, cn = src.channels(), depth = src.depth();
return s;
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_countNonZero( InputArray _src, int & res )
}
+#endif
+
int cv::countNonZero( InputArray _src )
{
CV_Assert( _src.channels() == 1 );
+#ifdef HAVE_OPENCL
int res = -1;
if (ocl::useOpenCL() && _src.isUMat() && ocl_countNonZero(_src, res))
return res;
+#endif
Mat src = _src.getMat();
CountNonZeroFunc func = getCountNonZeroTab(src.depth());
return s*(nz0 ? 1./nz0 : 0);
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
}
+#endif
+
void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
{
- if (ocl::useOpenCL() && _src.isUMat() && ocl_meanStdDev(_src, _mean, _sdv, _mask))
- return;
+ CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2,
+ ocl_meanStdDev(_src, _mean, _sdv, _mask))
Mat src = _src.getMat(), mask = _mask.getMat();
CV_Assert( mask.empty() || mask.type() == CV_8U );
}
}
-}
-
-namespace cv
-{
+#ifdef HAVE_OPENCL
template <typename T>
void getMinMaxRes(const Mat &minv, const Mat &maxv, const Mat &minl, const Mat &maxl, double* minVal,
return true;
}
+
+#endif
+
}
void cv::minMaxIdx(InputArray _src, double* minVal,
CV_Assert( (_src.channels() == 1 && (_mask.empty() || _mask.type() == CV_8U)) ||
(_src.channels() >= 1 && _mask.empty() && !minIdx && !maxIdx) );
- if( ocl::useOpenCL() && _src.isUMat() && _src.dims() <= 2 && ( _mask.empty() || _src.size() == _mask.size() )
- && ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask) )
- return;
+ CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2 && (_mask.empty() || _src.size() == _mask.size()),
+ ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask))
Mat src = _src.getMat(), mask = _mask.getMat();
int depth = src.depth(), cn = src.channels();
return normDiffTab[normType][depth];
}
-}
-
-namespace cv {
+#ifdef HAVE_OPENCL
static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double & result )
{
return true;
}
+#endif
+
}
double cv::norm( InputArray _src, int normType, InputArray _mask )
normType == NORM_L2 || normType == NORM_L2SQR ||
((normType == NORM_HAMMING || normType == NORM_HAMMING2) && _src.type() == CV_8U) );
+#ifdef HAVE_OPENCL
double _result = 0;
if (ocl::useOpenCL() && _src.isUMat() && _src.dims() <= 2 && ocl_norm(_src, normType, _mask, _result))
return _result;
+#endif
Mat src = _src.getMat(), mask = _mask.getMat();
int depth = src.depth(), cn = src.channels();
return result.d;
}
+#ifdef HAVE_OPENCL
+
namespace cv {
static bool ocl_norm( InputArray _src1, InputArray _src2, int normType, double & result )
}
+#endif
+
double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask )
{
CV_Assert( _src1.sameSize(_src2) && _src1.type() == _src2.type() );
+#ifdef HAVE_OPENCL
double _result = 0;
if (ocl::useOpenCL() && _mask.empty() && _src1.isUMat() && _src2.isUMat() &&
_src1.dims() <= 2 && _src2.dims() <= 2 && ocl_norm(_src1, _src2, normType, _result))
return _result;
+#endif
if( normType & CV_RELATIVE )
{