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

refactored core using new macro

Browse Source
This commit is contained in:
Ilya Lavrenov 2014-01-24 21:03:31 +04:00
parent cc514ac7a9
commit 7f785e0a11
8 changed files with 155 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
modules/core/include/opencv2/core/opencl/ocl_defs.hpp
View File

@ -31,4 +31,3 @@
#else #else
#define CV_OCL_RUN(condition, func) #define CV_OCL_RUN(condition, func)
#endif #endif

54
modules/core/src/arithm.cpp
View File

@ -918,6 +918,8 @@ enum { OCL_OP_ADD=0, OCL_OP_SUB=1, OCL_OP_RSUB=2, OCL_OP_ABSDIFF=3, OCL_OP_MUL=4
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_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 }; OCL_OP_RDIV_SCALE=15 };
#ifdef HAVE_OPENCL
static const char* oclop2str[] = { "OP_ADD", "OP_SUB", "OP_RSUB", "OP_ABSDIFF", static const char* oclop2str[] = { "OP_ADD", "OP_SUB", "OP_RSUB", "OP_ABSDIFF",
"OP_MUL", "OP_MUL_SCALE", "OP_DIV_SCALE", "OP_RECIP_SCALE", "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 }; "OP_ADDW", "OP_AND", "OP_OR", "OP_XOR", "OP_NOT", "OP_MIN", "OP_MAX", "OP_RDIV_SCALE", 0 };
@ -989,6 +991,7 @@ static bool ocl_binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
return k.run(2, globalsize, 0, false); return k.run(2, globalsize, 0, false);
} }
#endif
static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst, static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, const BinaryFunc* tab, InputArray _mask, const BinaryFunc* tab,
@ -1001,16 +1004,19 @@ static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
int dims1 = psrc1->dims(), dims2 = psrc2->dims(); int dims1 = psrc1->dims(), dims2 = psrc2->dims();
Size sz1 = dims1 <= 2 ? psrc1->size() : Size(); Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
Size sz2 = dims2 <= 2 ? psrc2->size() : Size(); Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
#ifdef HAVE_OPENCL
bool use_opencl = (kind1 == _InputArray::UMAT || kind2 == _InputArray::UMAT) && 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; bool haveMask = !_mask.empty(), haveScalar = false;
BinaryFunc func; BinaryFunc func;
if( dims1 <= 2 && dims2 <= 2 && kind1 == kind2 && sz1 == sz2 && type1 == type2 && !haveMask ) if( dims1 <= 2 && dims2 <= 2 && kind1 == kind2 && sz1 == sz2 && type1 == type2 && !haveMask )
{ {
_dst.create(sz1, type1); _dst.create(sz1, type1);
if( use_opencl && ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, false) ) CV_OCL_RUN(use_opencl,
return; ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, false))
if( bitwise ) if( bitwise )
{ {
func = *tab; func = *tab;
@ -1077,8 +1083,9 @@ static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
if( haveMask && reallocate ) if( haveMask && reallocate )
_dst.setTo(0.); _dst.setTo(0.);
if( use_opencl && ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, haveScalar )) CV_OCL_RUN(use_opencl,
return; ocl_binary_op(*psrc1, *psrc2, _dst, _mask, bitwise, oclop, haveScalar))
Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(); Mat src1 = psrc1->getMat(), src2 = psrc2->getMat();
Mat dst = _dst.getMat(), mask = _mask.getMat(); Mat dst = _dst.getMat(), mask = _mask.getMat();
@ -1089,9 +1096,7 @@ static void binary_op( InputArray _src1, InputArray _src2, OutputArray _dst,
cn = (int)esz; cn = (int)esz;
} }
else else
{
func = tab[depth1]; func = tab[depth1];
}
if( !haveScalar ) if( !haveScalar )
{ {
@ -1278,6 +1283,7 @@ static int actualScalarDepth(const double* data, int len)
CV_32S; CV_32S;
} }
#ifdef HAVE_OPENCL
static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst, static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, int wtype, InputArray _mask, int wtype,
@ -1395,6 +1401,7 @@ static bool ocl_arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
return k.run(2, globalsize, NULL, false); return k.run(2, globalsize, NULL, false);
} }
#endif
static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst, static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
InputArray _mask, int dtype, BinaryFunc* tab, bool muldiv=false, InputArray _mask, int dtype, BinaryFunc* tab, bool muldiv=false,
@ -1409,7 +1416,9 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
int wtype, dims1 = psrc1->dims(), dims2 = psrc2->dims(); int wtype, dims1 = psrc1->dims(), dims2 = psrc2->dims();
Size sz1 = dims1 <= 2 ? psrc1->size() : Size(); Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
Size sz2 = dims2 <= 2 ? psrc2->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 src1Scalar = checkScalar(*psrc1, type2, kind1, kind2);
bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1); bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1);
@ -1419,11 +1428,10 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
((src1Scalar && src2Scalar) || (!src1Scalar && !src2Scalar)) ) ((src1Scalar && src2Scalar) || (!src1Scalar && !src2Scalar)) )
{ {
_dst.createSameSize(*psrc1, type1); _dst.createSameSize(*psrc1, type1);
if( use_opencl && CV_OCL_RUN(use_opencl,
ocl_arithm_op(*psrc1, *psrc2, _dst, _mask, ocl_arithm_op(*psrc1, *psrc2, _dst, _mask,
(!usrdata ? type1 : std::max(depth1, CV_32F)), (!usrdata ? type1 : std::max(depth1, CV_32F)),
usrdata, oclop, false)) usrdata, oclop, false))
return;
Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(), dst = _dst.getMat(); Mat src1 = psrc1->getMat(), src2 = psrc2->getMat(), dst = _dst.getMat();
Size sz = getContinuousSize(src1, src2, dst, src1.channels()); Size sz = getContinuousSize(src1, src2, dst, src1.channels());
@ -1520,10 +1528,9 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
if( reallocate ) if( reallocate )
_dst.setTo(0.); _dst.setTo(0.);
if( use_opencl && CV_OCL_RUN(use_opencl,
ocl_arithm_op(*psrc1, *psrc2, _dst, _mask, wtype, ocl_arithm_op(*psrc1, *psrc2, _dst, _mask, wtype,
usrdata, oclop, haveScalar)) usrdata, oclop, haveScalar))
return;
BinaryFunc cvtsrc1 = type1 == wtype ? 0 : getConvertFunc(type1, wtype); BinaryFunc cvtsrc1 = type1 == wtype ? 0 : getConvertFunc(type1, wtype);
BinaryFunc cvtsrc2 = type2 == type1 ? cvtsrc1 : type2 == wtype ? 0 : getConvertFunc(type2, wtype); BinaryFunc cvtsrc2 = type2 == type1 ? cvtsrc1 : type2 == wtype ? 0 : getConvertFunc(type2, wtype);
@ -2600,6 +2607,8 @@ static double getMaxVal(int depth)
return tab[depth]; return tab[depth];
} }
#ifdef HAVE_OPENCL
static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op) static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
{ {
if ( !((_src1.isMat() || _src1.isUMat()) && (_src2.isMat() || _src2.isUMat())) ) if ( !((_src1.isMat() || _src1.isUMat()) && (_src2.isMat() || _src2.isUMat())) )
@ -2636,6 +2645,8 @@ static bool ocl_compare(InputArray _src1, InputArray _src2, OutputArray _dst, in
return k.run(2, globalsize, NULL, false); return k.run(2, globalsize, NULL, false);
} }
#endif
} }
void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op) void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
@ -2643,9 +2654,8 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
CV_Assert( op == CMP_LT || op == CMP_LE || op == CMP_EQ || CV_Assert( op == CMP_LT || op == CMP_LE || op == CMP_EQ ||
op == CMP_NE || op == CMP_GE || op == CMP_GT ); op == CMP_NE || op == CMP_GE || op == CMP_GT );
if (ocl::useOpenCL() && _src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat() && CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat(),
ocl_compare(_src1, _src2, _dst, op)) ocl_compare(_src1, _src2, _dst, op))
return;
int kind1 = _src1.kind(), kind2 = _src2.kind(); int kind1 = _src1.kind(), kind2 = _src2.kind();
Mat src1 = _src1.getMat(), src2 = _src2.getMat(); Mat src1 = _src1.getMat(), src2 = _src2.getMat();
@ -2877,6 +2887,8 @@ static InRangeFunc getInRangeFunc(int depth)
return inRangeTab[depth]; return inRangeTab[depth];
} }
#ifdef HAVE_OPENCL
static bool ocl_inRange( InputArray _src, InputArray _lowerb, static bool ocl_inRange( InputArray _src, InputArray _lowerb,
InputArray _upperb, OutputArray _dst ) InputArray _upperb, OutputArray _dst )
{ {
@ -2983,14 +2995,16 @@ static bool ocl_inRange( InputArray _src, InputArray _lowerb,
return ker.run(2, globalsize, NULL, false); return ker.run(2, globalsize, NULL, false);
} }
#endif
} }
void cv::inRange(InputArray _src, InputArray _lowerb, void cv::inRange(InputArray _src, InputArray _lowerb,
InputArray _upperb, OutputArray _dst) InputArray _upperb, OutputArray _dst)
{ {
if (ocl::useOpenCL() && _src.dims() <= 2 && _lowerb.dims() <= 2 && CV_OCL_RUN(_src.dims() <= 2 && _lowerb.dims() <= 2 &&
_upperb.dims() <= 2 && _dst.isUMat() && ocl_inRange(_src, _lowerb, _upperb, _dst)) _upperb.dims() <= 2 && _dst.isUMat(),
return; ocl_inRange(_src, _lowerb, _upperb, _dst))
int skind = _src.kind(), lkind = _lowerb.kind(), ukind = _upperb.kind(); int skind = _src.kind(), lkind = _lowerb.kind(), ukind = _upperb.kind();
Mat src = _src.getMat(), lb = _lowerb.getMat(), ub = _upperb.getMat(); Mat src = _src.getMat(), lb = _lowerb.getMat(), ub = _upperb.getMat();

61
modules/core/src/convert.cpp
View File

@ -264,6 +264,8 @@ void cv::split(const Mat& src, Mat* mv)
} }
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv ) static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
@ -302,11 +304,12 @@ static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
} }
#endif
void cv::split(InputArray _m, OutputArrayOfArrays _mv) void cv::split(InputArray _m, OutputArrayOfArrays _mv)
{ {
if (ocl::useOpenCL() && _m.dims() <= 2 && _mv.isUMatVector() && CV_OCL_RUN(_m.dims() <= 2 && _mv.isUMatVector(),
ocl_split(_m, _mv)) ocl_split(_m, _mv))
return;
Mat m = _m.getMat(); Mat m = _m.getMat();
if( m.empty() ) if( m.empty() )
@ -395,6 +398,8 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
} }
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst ) static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
@ -442,10 +447,12 @@ static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
} }
#endif
void cv::merge(InputArrayOfArrays _mv, OutputArray _dst) void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
{ {
if (ocl::useOpenCL() && _mv.isUMatVector() && _dst.isUMat() && ocl_merge(_mv, _dst)) CV_OCL_RUN(_mv.isUMatVector() && _dst.isUMat(),
return; ocl_merge(_mv, _dst))
std::vector<Mat> mv; std::vector<Mat> mv;
_mv.getMatVector(mv); _mv.getMatVector(mv);
@ -612,6 +619,8 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
} }
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static void getUMatIndex(const std::vector<UMat> & um, int cn, int & idx, int & cnidx) static void getUMatIndex(const std::vector<UMat> & um, int cn, int & idx, int & cnidx)
@ -701,15 +710,16 @@ static bool ocl_mixChannels(InputArrayOfArrays _src, InputOutputArrayOfArrays _d
} }
#endif
void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
const int* fromTo, size_t npairs) const int* fromTo, size_t npairs)
{ {
if (npairs == 0 || fromTo == NULL) if (npairs == 0 || fromTo == NULL)
return; return;
if (ocl::useOpenCL() && src.isUMatVector() && dst.isUMatVector() && CV_OCL_RUN(src.isUMatVector() && dst.isUMatVector(),
ocl_mixChannels(src, dst, fromTo, npairs)) ocl_mixChannels(src, dst, fromTo, npairs))
return;
bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT && bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
src.kind() != _InputArray::STD_VECTOR_VECTOR && src.kind() != _InputArray::STD_VECTOR_VECTOR &&
@ -737,9 +747,8 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
if (fromTo.empty()) if (fromTo.empty())
return; return;
if (ocl::useOpenCL() && src.isUMatVector() && dst.isUMatVector() && CV_OCL_RUN(src.isUMatVector() && dst.isUMatVector(),
ocl_mixChannels(src, dst, &fromTo[0], fromTo.size()>>1)) ocl_mixChannels(src, dst, &fromTo[0], fromTo.size()>>1))
return;
bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT && bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
src.kind() != _InputArray::STD_VECTOR_VECTOR && src.kind() != _InputArray::STD_VECTOR_VECTOR &&
@ -1284,6 +1293,8 @@ static BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)]; 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 ) 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); int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
@ -1319,13 +1330,14 @@ static bool ocl_convertScaleAbs( InputArray _src, OutputArray _dst, double alpha
return k.run(2, globalsize, NULL, false); return k.run(2, globalsize, NULL, false);
} }
#endif
} }
void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta ) void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
{ {
if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat() && CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
ocl_convertScaleAbs(_src, _dst, alpha, beta)) ocl_convertScaleAbs(_src, _dst, alpha, beta))
return;
Mat src = _src.getMat(); Mat src = _src.getMat();
int cn = src.channels(); int cn = src.channels();
@ -1462,9 +1474,7 @@ static LUTFunc lutTab[] =
(LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0 (LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0
}; };
} #ifdef HAVE_OPENCL
namespace cv {
static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst) static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst)
{ {
@ -1489,7 +1499,9 @@ static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst)
return k.run(2, globalSize, NULL, false); return k.run(2, globalSize, NULL, false);
} }
} // cv #endif
}
void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst ) void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
{ {
@ -1500,8 +1512,8 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
_lut.total() == 256 && _lut.isContinuous() && _lut.total() == 256 && _lut.isContinuous() &&
(depth == CV_8U || depth == CV_8S) ); (depth == CV_8U || depth == CV_8S) );
if (ocl::useOpenCL() && _dst.isUMat() && ocl_LUT(_src, _lut, _dst)) CV_OCL_RUN(_dst.isUMat(),
return; ocl_LUT(_src, _lut, _dst))
Mat src = _src.getMat(), lut = _lut.getMat(); Mat src = _src.getMat(), lut = _lut.getMat();
_dst.create(src.dims, src.size, CV_MAKETYPE(_lut.depth(), cn)); _dst.create(src.dims, src.size, CV_MAKETYPE(_lut.depth(), cn));
@ -1521,6 +1533,8 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
namespace cv { namespace cv {
#ifdef HAVE_OPENCL
static bool ocl_normalize( InputArray _src, OutputArray _dst, InputArray _mask, int rtype, static bool ocl_normalize( InputArray _src, OutputArray _dst, InputArray _mask, int rtype,
double scale, double shift ) double scale, double shift )
{ {
@ -1538,6 +1552,8 @@ static bool ocl_normalize( InputArray _src, OutputArray _dst, InputArray _mask,
return true; return true;
} }
#endif
} }
void cv::normalize( InputArray _src, OutputArray _dst, double a, double b, void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
@ -1566,9 +1582,8 @@ void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
rtype = _dst.fixedType() ? _dst.depth() : depth; rtype = _dst.fixedType() ? _dst.depth() : depth;
_dst.createSameSize(_src, CV_MAKETYPE(rtype, cn)); _dst.createSameSize(_src, CV_MAKETYPE(rtype, cn));
if (ocl::useOpenCL() && _dst.isUMat() && CV_OCL_RUN(_dst.isUMat(),
ocl_normalize(_src, _dst, _mask, rtype, scale, shift)) ocl_normalize(_src, _dst, _mask, rtype, scale, shift))
return;
Mat src = _src.getMat(), dst = _dst.getMat(); Mat src = _src.getMat(), dst = _dst.getMat();
if( _mask.empty() ) if( _mask.empty() )

27
modules/core/src/copy.cpp
View File

@ -475,6 +475,8 @@ flipVert( const uchar* src0, size_t sstep, uchar* dst0, size_t dstep, Size size,
} }
} }
#ifdef HAVE_OPENCL
enum { FLIP_COLS = 1 << 0, FLIP_ROWS = 1 << 1, FLIP_BOTH = FLIP_ROWS | FLIP_COLS }; 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 ) static bool ocl_flip(InputArray _src, OutputArray _dst, int flipCode )
@ -519,13 +521,13 @@ 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); 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 ) void flip( InputArray _src, OutputArray _dst, int flip_mode )
{ {
CV_Assert( _src.dims() <= 2 ); CV_Assert( _src.dims() <= 2 );
bool use_opencl = ocl::useOpenCL() && _dst.isUMat(); CV_OCL_RUN( _dst.isUMat(), ocl_flip(_src,_dst, flip_mode))
if ( use_opencl && ocl_flip(_src,_dst, flip_mode))
return;
Mat src = _src.getMat(); Mat src = _src.getMat();
_dst.create( src.size(), src.type() ); _dst.create( src.size(), src.type() );
@ -541,6 +543,7 @@ void flip( InputArray _src, OutputArray _dst, int flip_mode )
flipHoriz( dst.data, dst.step, dst.data, dst.step, dst.size(), esz ); 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) static bool ocl_repeat(InputArray _src, int ny, int nx, OutputArray _dst)
{ {
@ -556,6 +559,8 @@ static bool ocl_repeat(InputArray _src, int ny, int nx, OutputArray _dst)
return true; return true;
} }
#endif
void repeat(InputArray _src, int ny, int nx, OutputArray _dst) void repeat(InputArray _src, int ny, int nx, OutputArray _dst)
{ {
CV_Assert( _src.dims() <= 2 ); CV_Assert( _src.dims() <= 2 );
@ -564,11 +569,8 @@ void repeat(InputArray _src, int ny, int nx, OutputArray _dst)
Size ssize = _src.size(); Size ssize = _src.size();
_dst.create(ssize.height*ny, ssize.width*nx, _src.type()); _dst.create(ssize.height*ny, ssize.width*nx, _src.type());
if (ocl::useOpenCL() && _src.isUMat()) CV_OCL_RUN(_dst.isUMat(),
{ ocl_repeat(_src, ny, nx, _dst))
CV_Assert(ocl_repeat(_src, ny, nx, _dst));
return;
}
Mat src = _src.getMat(), dst = _dst.getMat(); Mat src = _src.getMat(), dst = _dst.getMat();
Size dsize = dst.size(); Size dsize = dst.size();
@ -768,6 +770,8 @@ void copyMakeConstBorder_8u( const uchar* src, size_t srcstep, cv::Size srcroi,
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom, static bool ocl_copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
@ -824,14 +828,15 @@ static bool ocl_copyMakeBorder( InputArray _src, OutputArray _dst, int top, int
} }
#endif
void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom, void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
int left, int right, int borderType, const Scalar& value ) int left, int right, int borderType, const Scalar& value )
{ {
CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 ); CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 );
if (ocl::useOpenCL() && _dst.isUMat() && _src.dims() <= 2 && CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2,
ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value)) ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value))
return;
Mat src = _src.getMat(); Mat src = _src.getMat();

13
modules/core/src/dxt.cpp
View File

@ -1726,9 +1726,9 @@ static bool ocl_dft(InputArray _src, OutputArray _dst, int flags)
void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows ) void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
{ {
#ifdef HAVE_CLAMDFFT #ifdef HAVE_CLAMDFFT
if (ocl::useOpenCL() && ocl::haveAmdFft() && ocl::Device::getDefault().type() != ocl::Device::TYPE_CPU && 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)) _dst.isUMat() && _src0.dims() <= 2 && nonzero_rows == 0,
return; ocl_dft(_src0, _dst, flags))
#endif #endif
static DFTFunc dft_tbl[6] = static DFTFunc dft_tbl[6] =
@ -2135,6 +2135,8 @@ void cv::idft( InputArray src, OutputArray dst, int flags, int nonzero_rows )
dft( src, dst, flags | DFT_INVERSE, nonzero_rows ); dft( src, dst, flags | DFT_INVERSE, nonzero_rows );
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_mulSpectrums( InputArray _srcA, InputArray _srcB, static bool ocl_mulSpectrums( InputArray _srcA, InputArray _srcB,
@ -2168,12 +2170,13 @@ static bool ocl_mulSpectrums( InputArray _srcA, InputArray _srcB,
} }
#endif
void cv::mulSpectrums( InputArray _srcA, InputArray _srcB, void cv::mulSpectrums( InputArray _srcA, InputArray _srcB,
OutputArray _dst, int flags, bool conjB ) 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)) ocl_mulSpectrums(_srcA, _srcB, _dst, flags, conjB))
return;
Mat srcA = _srcA.getMat(), srcB = _srcB.getMat(); Mat srcA = _srcA.getMat(), srcB = _srcB.getMat();
int depth = srcA.depth(), cn = srcA.channels(), type = srcA.type(); int depth = srcA.depth(), cn = srcA.channels(), type = srcA.type();

11
modules/core/src/matmul.cpp
View File

@ -785,10 +785,8 @@ void cv::gemm( InputArray matA, InputArray matB, double alpha,
InputArray matC, double beta, OutputArray _matD, int flags ) InputArray matC, double beta, OutputArray _matD, int flags )
{ {
#ifdef HAVE_CLAMDBLAS #ifdef HAVE_CLAMDBLAS
if (ocl::haveAmdBlas() && matA.dims() <= 2 && matB.dims() <= 2 && matC.dims() <= 2 && CV_OCL_RUN(ocl::haveAmdBlas() && matA.dims() <= 2 && matB.dims() <= 2 && matC.dims() <= 2 && _matD.isUMat(),
ocl::useOpenCL() && _matD.isUMat() &&
ocl_gemm(matA, matB, alpha, matC, beta, _matD, flags)) ocl_gemm(matA, matB, alpha, matC, beta, _matD, flags))
return;
#endif #endif
const int block_lin_size = 128; const int block_lin_size = 128;
@ -2155,6 +2153,8 @@ static void scaleAdd_64f(const double* src1, const double* src2, double* dst,
typedef void (*ScaleAddFunc)(const uchar* src1, const uchar* src2, uchar* dst, int len, const void* alpha); 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 ) 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); int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), wdepth = std::max(depth, CV_32F);
@ -2190,6 +2190,8 @@ static bool ocl_scaleAdd( InputArray _src1, double alpha, InputArray _src2, Outp
return k.run(2, globalsize, NULL, false); return k.run(2, globalsize, NULL, false);
} }
#endif
} }
void cv::scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray _dst ) void cv::scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray _dst )
@ -2197,9 +2199,8 @@ void cv::scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray
int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
CV_Assert( type == _src2.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)) ocl_scaleAdd(_src1, alpha, _src2, _dst, type))
return;
if( depth < CV_32F ) if( depth < CV_32F )
{ {

25
modules/core/src/matrix.cpp
View File

@ -2522,6 +2522,8 @@ void cv::vconcat(InputArray _src, OutputArray dst)
//////////////////////////////////////// set identity //////////////////////////////////////////// //////////////////////////////////////// set identity ////////////////////////////////////////////
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s ) static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
@ -2544,12 +2546,14 @@ static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
} }
#endif
void cv::setIdentity( InputOutputArray _m, const Scalar& s ) void cv::setIdentity( InputOutputArray _m, const Scalar& s )
{ {
CV_Assert( _m.dims() <= 2 ); CV_Assert( _m.dims() <= 2 );
if (ocl::useOpenCL() && _m.isUMat() && ocl_setIdentity(_m, s)) CV_OCL_RUN(_m.isUMat(),
return; ocl_setIdentity(_m, s))
Mat m = _m.getMat(); Mat m = _m.getMat();
int i, j, rows = m.rows, cols = m.cols, type = m.type(); int i, j, rows = m.rows, cols = m.cols, type = m.type();
@ -2728,6 +2732,8 @@ static TransposeInplaceFunc transposeInplaceTab[] =
0, 0, 0, 0, 0, 0, 0, transposeI_32sC6, 0, 0, 0, 0, 0, 0, 0, transposeI_32sC8 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) static inline int divUp(int a, int b)
{ {
return (a + b - 1) / b; return (a + b - 1) / b;
@ -2769,6 +2775,8 @@ static bool ocl_transpose( InputArray _src, OutputArray _dst )
return k.run(2, globalsize, localsize, false); return k.run(2, globalsize, localsize, false);
} }
#endif
} }
void cv::transpose( InputArray _src, OutputArray _dst ) void cv::transpose( InputArray _src, OutputArray _dst )
@ -2776,8 +2784,8 @@ void cv::transpose( InputArray _src, OutputArray _dst )
int type = _src.type(), esz = CV_ELEM_SIZE(type); int type = _src.type(), esz = CV_ELEM_SIZE(type);
CV_Assert( _src.dims() <= 2 && esz <= 32 ); CV_Assert( _src.dims() <= 2 && esz <= 32 );
if (ocl::useOpenCL() && _dst.isUMat() && ocl_transpose(_src, _dst)) CV_OCL_RUN(_dst.isUMat(),
return; ocl_transpose(_src, _dst))
Mat src = _src.getMat(); Mat src = _src.getMat();
if( src.empty() ) if( src.empty() )
@ -3007,6 +3015,8 @@ typedef void (*ReduceFunc)( const Mat& src, Mat& dst );
#define reduceMinC32f reduceC_<float, float, OpMin<float> > #define reduceMinC32f reduceC_<float, float, OpMin<float> >
#define reduceMinC64f reduceC_<double,double,OpMin<double> > #define reduceMinC64f reduceC_<double,double,OpMin<double> >
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_reduce(InputArray _src, OutputArray _dst, static bool ocl_reduce(InputArray _src, OutputArray _dst,
@ -3060,6 +3070,8 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
} }
#endif
void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype) void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
{ {
CV_Assert( _src.dims() <= 2 ); CV_Assert( _src.dims() <= 2 );
@ -3074,9 +3086,8 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
CV_Assert( op == CV_REDUCE_SUM || op == CV_REDUCE_MAX || CV_Assert( op == CV_REDUCE_SUM || op == CV_REDUCE_MAX ||
op == CV_REDUCE_MIN || op == CV_REDUCE_AVG ); op == CV_REDUCE_MIN || op == CV_REDUCE_AVG );
if (ocl::useOpenCL() && _dst.isUMat() && CV_OCL_RUN(_dst.isUMat(),
ocl_reduce(_src, _dst, dim, op, op0, stype, dtype)) ocl_reduce(_src, _dst, dim, op, op0, stype, dtype))
return;
Mat src = _src.getMat(); Mat src = _src.getMat();
_dst.create(dim == 0 ? 1 : src.rows, dim == 0 ? src.cols : 1, dtype); _dst.create(dim == 0 ? 1 : src.rows, dim == 0 ? src.cols : 1, dtype);

47
modules/core/src/stat.cpp
View File

@ -464,6 +464,8 @@ template <typename T> Scalar ocl_part_sum(Mat m)
return s; return s;
} }
#ifdef HAVE_OPENCL
enum { OCL_OP_SUM = 0, OCL_OP_SUM_ABS = 1, OCL_OP_SUM_SQR = 2 }; 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() ) static bool ocl_sum( InputArray _src, Scalar & res, int sum_op, InputArray _mask = noArray() )
@ -523,13 +525,17 @@ static bool ocl_sum( InputArray _src, Scalar & res, int sum_op, InputArray _mask
return false; return false;
} }
#endif
} }
cv::Scalar cv::sum( InputArray _src ) cv::Scalar cv::sum( InputArray _src )
{ {
#ifdef HAVE_OPENCL
Scalar _res; Scalar _res;
if (ocl::useOpenCL() && _src.isUMat() && ocl_sum(_src, _res, OCL_OP_SUM)) if (ocl::useOpenCL() && _src.isUMat() && ocl_sum(_src, _res, OCL_OP_SUM))
return _res; return _res;
#endif
Mat src = _src.getMat(); Mat src = _src.getMat();
int k, cn = src.channels(), depth = src.depth(); int k, cn = src.channels(), depth = src.depth();
@ -621,6 +627,8 @@ cv::Scalar cv::sum( InputArray _src )
return s; return s;
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_countNonZero( InputArray _src, int & res ) static bool ocl_countNonZero( InputArray _src, int & res )
@ -658,13 +666,17 @@ static bool ocl_countNonZero( InputArray _src, int & res )
} }
#endif
int cv::countNonZero( InputArray _src ) int cv::countNonZero( InputArray _src )
{ {
CV_Assert( _src.channels() == 1 ); CV_Assert( _src.channels() == 1 );
#ifdef HAVE_OPENCL
int res = -1; int res = -1;
if (ocl::useOpenCL() && _src.isUMat() && ocl_countNonZero(_src, res)) if (ocl::useOpenCL() && _src.isUMat() && ocl_countNonZero(_src, res))
return res; return res;
#endif
Mat src = _src.getMat(); Mat src = _src.getMat();
CountNonZeroFunc func = getCountNonZeroTab(src.depth()); CountNonZeroFunc func = getCountNonZeroTab(src.depth());
@ -815,6 +827,8 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
return s*(nz0 ? 1./nz0 : 0); return s*(nz0 ? 1./nz0 : 0);
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask ) static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
@ -861,10 +875,12 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
} }
#endif
void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask ) void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
{ {
if (ocl::useOpenCL() && _src.isUMat() && ocl_meanStdDev(_src, _mean, _sdv, _mask)) CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2,
return; ocl_meanStdDev(_src, _mean, _sdv, _mask))
Mat src = _src.getMat(), mask = _mask.getMat(); Mat src = _src.getMat(), mask = _mask.getMat();
CV_Assert( mask.empty() || mask.type() == CV_8U ); CV_Assert( mask.empty() || mask.type() == CV_8U );
@ -1171,10 +1187,7 @@ static void ofs2idx(const Mat& a, size_t ofs, int* idx)
} }
} }
} #ifdef HAVE_OPENCL
namespace cv
{
template <typename T> template <typename T>
void getMinMaxRes(const Mat &minv, const Mat &maxv, const Mat &minl, const Mat &maxl, double* minVal, void getMinMaxRes(const Mat &minv, const Mat &maxv, const Mat &minl, const Mat &maxl, double* minVal,
@ -1288,6 +1301,9 @@ static bool ocl_minMaxIdx( InputArray _src, double* minVal, double* maxVal, int*
return true; return true;
} }
#endif
} }
void cv::minMaxIdx(InputArray _src, double* minVal, void cv::minMaxIdx(InputArray _src, double* minVal,
@ -1297,9 +1313,8 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
CV_Assert( (_src.channels() == 1 && (_mask.empty() || _mask.type() == CV_8U)) || CV_Assert( (_src.channels() == 1 && (_mask.empty() || _mask.type() == CV_8U)) ||
(_src.channels() >= 1 && _mask.empty() && !minIdx && !maxIdx) ); (_src.channels() >= 1 && _mask.empty() && !minIdx && !maxIdx) );
if( ocl::useOpenCL() && _src.isUMat() && _src.dims() <= 2 && ( _mask.empty() || _src.size() == _mask.size() ) CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2 && (_mask.empty() || _src.size() == _mask.size()),
&& ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask) ) ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask))
return;
Mat src = _src.getMat(), mask = _mask.getMat(); Mat src = _src.getMat(), mask = _mask.getMat();
int depth = src.depth(), cn = src.channels(); int depth = src.depth(), cn = src.channels();
@ -1892,9 +1907,7 @@ static NormDiffFunc getNormDiffFunc(int normType, int depth)
return normDiffTab[normType][depth]; return normDiffTab[normType][depth];
} }
} #ifdef HAVE_OPENCL
namespace cv {
static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double & result ) static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double & result )
{ {
@ -1959,6 +1972,8 @@ static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double &
return true; return true;
} }
#endif
} }
double cv::norm( InputArray _src, int normType, InputArray _mask ) double cv::norm( InputArray _src, int normType, InputArray _mask )
@ -1968,9 +1983,11 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
normType == NORM_L2 || normType == NORM_L2SQR || normType == NORM_L2 || normType == NORM_L2SQR ||
((normType == NORM_HAMMING || normType == NORM_HAMMING2) && _src.type() == CV_8U) ); ((normType == NORM_HAMMING || normType == NORM_HAMMING2) && _src.type() == CV_8U) );
#ifdef HAVE_OPENCL
double _result = 0; double _result = 0;
if (ocl::useOpenCL() && _src.isUMat() && _src.dims() <= 2 && ocl_norm(_src, normType, _mask, _result)) if (ocl::useOpenCL() && _src.isUMat() && _src.dims() <= 2 && ocl_norm(_src, normType, _mask, _result))
return _result; return _result;
#endif
Mat src = _src.getMat(), mask = _mask.getMat(); Mat src = _src.getMat(), mask = _mask.getMat();
int depth = src.depth(), cn = src.channels(); int depth = src.depth(), cn = src.channels();
@ -2252,6 +2269,8 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
return result.d; return result.d;
} }
#ifdef HAVE_OPENCL
namespace cv { namespace cv {
static bool ocl_norm( InputArray _src1, InputArray _src2, int normType, double & result ) static bool ocl_norm( InputArray _src1, InputArray _src2, int normType, double & result )
@ -2293,14 +2312,18 @@ static bool ocl_norm( InputArray _src1, InputArray _src2, int normType, double &
} }
#endif
double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask ) double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask )
{ {
CV_Assert( _src1.sameSize(_src2) && _src1.type() == _src2.type() ); CV_Assert( _src1.sameSize(_src2) && _src1.type() == _src2.type() );
#ifdef HAVE_OPENCL
double _result = 0; double _result = 0;
if (ocl::useOpenCL() && _mask.empty() && _src1.isUMat() && _src2.isUMat() && if (ocl::useOpenCL() && _mask.empty() && _src1.isUMat() && _src2.isUMat() &&
_src1.dims() <= 2 && _src2.dims() <= 2 && ocl_norm(_src1, _src2, normType, _result)) _src1.dims() <= 2 && _src2.dims() <= 2 && ocl_norm(_src1, _src2, normType, _result))
return _result; return _result;
#endif
if( normType & CV_RELATIVE ) if( normType & CV_RELATIVE )
{ {