{

CV_Assert(ocn == cn || (ocn == 4 && cn == 3));

static const int sizeMap[] = { sizeof(uchar), sizeof(char), sizeof(ushort),

sizeof(short), sizeof(int), sizeof(float), sizeof(double) };

int elemSize1 = sizeMap[depth];

int bufSize = elemSize1 * ocn;

std::vector<uchar> _buf(bufSize);

uchar * buf = &_buf[0];

scalarToRawData(sc, buf, CV_MAKE_TYPE(depth, cn));

memset(buf + elemSize1 * cn, 0, (ocn - cn) * elemSize1);

return _buf;

oclMat &dst, int op_type, bool use_scalar = false)

{

Context *clCxt = src1.clCxt;

bool hasDouble = clCxt->supportsFeature(FEATURE_CL_DOUBLE);

if (!hasDouble && (src1.depth() == CV_64F || src2.depth() == CV_64F || dst.depth() == CV_64F))

{

CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");

return;

}

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()));

CV_Assert(op_type >= ADD && op_type <= MAX);

dst.create(src1.size(), src1.type());

int oclChannels = src1.oclchannels(), depth = src1.depth();

int src1step1 = src1.step / src1.elemSize(), src1offset1 = src1.offset / src1.elemSize();

int src2step1 = src2.step / src2.elemSize(), src2offset1 = src2.offset / src2.elemSize();

int maskstep1 = mask.step, maskoffset1 = mask.offset / mask.elemSize();

int dststep1 = dst.step / dst.elemSize(), dstoffset1 = dst.offset / dst.elemSize();

std::vector<uchar> m;

#ifdef ANDROID

size_t localThreads[3] = { 16, 10, 1 };

#else

size_t localThreads[3] = { 16, 16, 1 };

#endif

size_t globalThreads[3] = { (size_t)dst.cols, (size_t)dst.rows, 1 };

std::string kernelName = "arithm_binary_op";

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

const char * const WTypeMap[] = { "short", "short", "int", "int", "int", "float", "double" };

const char * const funcMap[] = { "FUNC_ADD", "FUNC_SUB", "FUNC_MUL", "FUNC_DIV", "FUNC_ABS", "FUNC_ABS_DIFF", "FUNC_MIN", "FUNC_MAX" };

const char * const channelMap[] = { "", "", "2", "4", "4" };

bool haveScalar = use_scalar || src2.empty();

int WDepth = depth;

if (haveScalar)

WDepth = hasDouble && WDepth == CV_64F ? CV_64F : CV_32F;

if (op_type == DIV)

WDepth = hasDouble ? CV_64F : CV_32F;

else if (op_type == MUL)

WDepth = hasDouble && (depth == CV_32S || depth == CV_64F) ? CV_64F : CV_32F;

std::string buildOptions = format("-D T=%s%s -D WT=%s%s -D convertToT=convert_%s%s%s -D %s "

"-D convertToWT=convert_%s%s",

typeMap[depth], channelMap[oclChannels],

WTypeMap[WDepth], channelMap[oclChannels],

typeMap[depth], channelMap[oclChannels], (depth >= CV_32F ? "" : (depth == CV_32S ? "_rte" : "_sat_rte")),

funcMap[op_type], WTypeMap[WDepth], channelMap[oclChannels]);

vector<pair<size_t , const void *> > args;

args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));

if (!src2.empty())

{

args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));

kernelName += "_mat";

if (haveScalar)

buildOptions += " -D HAVE_SCALAR";

}

if (haveScalar)

{

const int WDepthMap[] = { CV_16S, CV_16S, CV_32S, CV_32S, CV_32S, CV_32F, CV_64F };

m = scalarToVector(scalar, WDepthMap[WDepth], oclChannels, src1.channels());

args.push_back( make_pair( m.size(), (void *)&m[0]));

kernelName += "_scalar";

}

if (!mask.empty())

{

args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&maskstep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&maskoffset1 ));

kernelName += "_mask";

}

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));

openCLExecuteKernel(clCxt, mask.empty() ?

(!src2.empty() ? &arithm_add : &arithm_add_scalar) :

(!src2.empty() ? &arithm_add_mask : &arithm_add_scalar_mask),

kernelName, globalThreads, localThreads,

args, -1, -1, buildOptions.c_str());

string kernelName, const cv::ocl::ProgramEntry* source)

{

dst.create(src1.size(), CV_8UC1);

int depth = src1.depth();

size_t localThreads[3] = { 64, 4, 1 };

size_t globalThreads[3] = { (size_t)dst.cols, (size_t)dst.rows, 1 };

int src1step1 = src1.step1(), src1offset1 = src1.offset / src1.elemSize1();

int src2step1 = src2.step1(), src2offset1 = src2.offset / src2.elemSize1();

int dststep1 = dst.step1(), dstoffset1 = dst.offset / dst.elemSize1();

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

const char * operationMap[] = { "==", ">", ">=", "<", "<=", "!=" };

std::string buildOptions = format("-D T=%s -D Operation=%s", typeMap[depth], operationMap[cmpOp]);

vector<pair<size_t , const void *> > args;

args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));

openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads,

args, -1, -1, buildOptions.c_str());

{

int vElemSize = vlen * src.elemSize();

int src_offset = src.offset / vElemSize, src_step = src.step / vElemSize;

int src_cols = src.cols / vlen, total = src.size().area() / vlen;

vlen *= src.oclchannels();

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

const char * const funcMap[] = { "FUNC_SUM", "FUNC_ABS_SUM", "FUNC_SQR_SUM" };

const char * const channelMap[] = { " ", " ", "2", "4", "4", "", "", "", "8" };

string buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s -D %s",

typeMap[src.depth()], channelMap[vlen], typeMap[ddepth],

channelMap[vlen], typeMap[ddepth], channelMap[vlen], funcMap[type]);

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 ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&src_cols ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&total ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum ));

args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));

size_t globalThreads[3] = { (size_t)groupnum * 256, 1, 1 };

#ifdef ANDROID

openCLExecuteKernel(src.clCxt, &arithm_sum, "arithm_op_sum", globalThreads, NULL,

args, -1, -1, buildOptions.c_str());

#else

size_t localThreads[3] = { 256, 1, 1 };

openCLExecuteKernel(src.clCxt, &arithm_sum, "arithm_op_sum", globalThreads, localThreads,

args, -1, -1, buildOptions.c_str());

#endif

{

CV_Assert(src.step % src.elemSize() == 0);

size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;

CV_Assert(groupnum != 0);

int vlen = 8 / src.channels(), vElemSize = vlen * src.elemSize1();

while (src.offset % vElemSize != 0 || src.step % vElemSize != 0 || src.cols % vlen != 0)

vlen >>= 1, vElemSize >>= 1;

int dbsize = groupnum * src.oclchannels() * vlen;

Context *clCxt = src.clCxt;

AutoBuffer<T> _buf(dbsize);

T *p = (T*)_buf;

memset(p, 0, dbsize * sizeof(T));

cl_mem dstBuffer = openCLCreateBuffer(clCxt, CL_MEM_WRITE_ONLY, dbsize * sizeof(T));

arithmetic_sum_buffer_run(src, dstBuffer, groupnum, type, ddepth, vlen);

openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize * sizeof(T));

openCLFree(dstBuffer);

Scalar s = Scalar::all(0.0);

for (int i = 0; i < dbsize; )

for (int j = 0; j < src.oclchannels(); j++, i++)

s.val[j] += p[i];

return s;

{

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

const char * const channelMap[] = { " ", " ", "2", "4", "4", "", "", "", "8" };

ostringstream stream;

stream << "-D T=" << typeMap[src.depth()] << channelMap[vlen];

if (numeric_limits<T>::is_integer)

{

stream << " -D MAX_VAL=" << (WT)numeric_limits<T>::max();

stream << " -D MIN_VAL=" << (WT)numeric_limits<T>::min();

}

else

stream << " -D DEPTH_" << src.depth();

stream << " -D vlen=" << vlen;

std::string buildOptions = stream.str();

int vElemSize = src.elemSize1() * vlen, src_cols = src.cols / vlen;

int src_step = src.step / vElemSize, src_offset = src.offset / vElemSize;

int mask_step = mask.step / vlen, mask_offset = mask.offset / vlen;

int total = src.size().area() / vlen;

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 ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&src.rows ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&src_cols ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&total));

args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));

args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst));

if (!mask.empty())

{

args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&mask_step ));

args.push_back( make_pair( sizeof(cl_int) , (void *)&mask_offset ));

buildOptions += " -D WITH_MASK";

}

size_t globalThreads[3] = { (size_t)groupnum * 256, 1, 1 };

size_t localThreads[3] = { 256, 1, 1 };

// kernel use fixed grid size, replace lt on NULL is impossible without kernel changes

openCLExecuteKernel(src.clCxt, &arithm_minMax, "arithm_op_minMax", globalThreads, localThreads,

args, -1, -1, buildOptions.c_str());

{

size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;

CV_Assert(groupnum != 0);

int vlen = mask.empty() ? 8 : 1, vElemSize = vlen * src.elemSize1();

while (src.offset % vElemSize != 0 || src.step % vElemSize != 0 || src.cols % vlen != 0)

{

vlen >>= 1;

vElemSize >>= 1;

}

int dbsize = groupnum * 2 * vElemSize;

oclMat buf;

ensureSizeIsEnough(1, dbsize, CV_8UC1, buf);

cl_mem buf_data = reinterpret_cast<cl_mem>(buf.data);

arithmetic_minMax_run<T, WT>(src, mask, buf_data, vlen, groupnum);

Mat matbuf = Mat(buf);

T *p = matbuf.ptr<T>();

if (minVal != NULL)

{

*minVal = std::numeric_limits<double>::max();

for (int i = 0, end = vlen * (int)groupnum; i < end; i++)

*minVal = *minVal < p[i] ? *minVal : p[i];

}

if (maxVal != NULL)

{

*maxVal = -std::numeric_limits<double>::max();

for (int i = vlen * (int)groupnum, end = i << 1; i < end; i++)

*maxVal = *maxVal > p[i] ? *maxVal : p[i];

}

{

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));

if (src2.empty() && (src1.depth() == CV_8U || src1.depth() == CV_16U))

{

src1.convertTo(diff, CV_32S);

return;

}

int ddepth = std::max(src1.depth(), CV_32S);

if (ntype == NORM_L2)

ddepth = std::max<int>(CV_32F, ddepth);

diff.create(src1.size(), CV_MAKE_TYPE(ddepth, src1.channels()));

CV_Assert(diff.step % diff.elemSize() == 0);

int oclChannels = src1.oclchannels(), sdepth = src1.depth();

int src1step1 = src1.step / src1.elemSize(), src1offset1 = src1.offset / src1.elemSize();

int src2step1 = src2.step / src2.elemSize(), src2offset1 = src2.offset / src2.elemSize();

int diffstep1 = diff.step / diff.elemSize(), diffoffset1 = diff.offset / diff.elemSize();

string kernelName = "arithm_absdiff_nonsaturate";

#ifdef ANDROID

size_t localThreads[3] = { 16, 10, 1 };

#else

size_t localThreads[3] = { 16, 16, 1 };

#endif

size_t globalThreads[3] = { (size_t)diff.cols, (size_t)diff.rows, 1 };

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

const char * const channelMap[] = { "", "", "2", "4", "4" };

std::string buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s",

typeMap[sdepth], channelMap[oclChannels],

typeMap[ddepth], channelMap[oclChannels],

typeMap[ddepth], channelMap[oclChannels]);

vector<pair<size_t , const void *> > args;

args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));

if (!src2.empty())

{

args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));

kernelName += "_binary";

buildOptions += " -D BINARY";

}

args.push_back( make_pair( sizeof(cl_mem), (void *)&diff.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&diffstep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&diffoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));

openCLExecuteKernel(clCxt, &arithm_absdiff_nonsaturate,

kernelName, globalThreads, localThreads,

args, -1, -1, buildOptions.c_str());

{

int cols = dst.cols, rows = dst.rows;

if ((cols == 1 && flipType == FLIP_COLS) ||

(rows == 1 && flipType == FLIP_ROWS) ||

(rows == 1 && cols == 1 && flipType == FLIP_BOTH))

{

src.copyTo(dst);

return;

}

cols = flipType == FLIP_COLS ? divUp(cols, 2) : cols;

rows = flipType & FLIP_ROWS ? divUp(rows, 2) : rows;

const char * const channelMap[] = { "", "", "2", "4", "4" };

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

std::string buildOptions = format("-D T=%s%s", typeMap[dst.depth()], channelMap[dst.oclchannels()]);

size_t localThreads[3] = { 64, 4, 1 };

size_t globalThreads[3] = { (size_t)cols, (size_t)rows, 1 };

int elemSize = src.elemSize();

int src_step = src.step / elemSize, src_offset = src.offset / elemSize;

int dst_step = dst.step / elemSize, dst_offset = dst.offset / elemSize;

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 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst.cols ));

args.push_back( make_pair( sizeof(cl_int), (void *)&rows ));

args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));

openCLExecuteKernel(src.clCxt, &arithm_flip, kernelName, globalThreads, localThreads, args,

-1, -1, buildOptions.c_str());

{

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();

int lut_offset1 = lut.offset / lut.elemSize1() + (sdepth == CV_8U ? 0 : 128) * lut.channels();

int cols1 = src.cols * src.oclchannels();

size_t localSize[] = { 16, 16, 1 };

size_t globalSize[] = { (size_t)(lut.channels() == 1 ? cols1 : src.cols), (size_t)src.rows, 1 };

const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };

std::string buildOptions = format("-D srcT=%s -D dstT=%s", typeMap[sdepth], typeMap[dst.depth()]);

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_mem), (void *)&lut.data ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&cols1));

args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&lut_offset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src_step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));

openCLExecuteKernel(src.clCxt, &arithm_LUT, kernelName, globalSize, localSize,

args, lut.oclchannels(), -1, buildOptions.c_str());

{

Context *clCxt = src.clCxt;

if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)

{

CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");

return;

}

CV_Assert( src.depth() == CV_32F || src.depth() == CV_64F);

dst.create(src.size(), src.type());

int ddepth = dst.depth();

int cols1 = src.cols * src.oclchannels();

int srcoffset1 = src.offset / src.elemSize1(), dstoffset1 = dst.offset / dst.elemSize1();

int srcstep1 = src.step1(), dststep1 = dst.step1();

#ifdef ANDROID

size_t localThreads[3] = { 64, 2, 1 };

#else

size_t localThreads[3] = { 64, 4, 1 };

#endif

size_t globalThreads[3] = { (size_t)dst.cols, (size_t)dst.rows, 1 };

std::string buildOptions = format("-D srcT=%s",

ddepth == CV_32F ? "float" : "double");

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_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows ));

args.push_back( make_pair( sizeof(cl_int), (void *)&srcoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&srcstep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));

openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads,

args, src.oclchannels(), -1, buildOptions.c_str());

{

int depth = dst.depth();

#ifdef ANDROID

size_t localThreads[3] = { 64, 2, 1 };

#else

size_t localThreads[3] = { 64, 4, 1 };

#endif

size_t globalThreads[3] = { (size_t)dst.cols, (size_t)dst.rows, 1 };

int src1_step = src1.step / src1.elemSize(), src1_offset = src1.offset / src1.elemSize();

int src2_step = src2.step / src2.elemSize(), src2_offset = src2.offset / src2.elemSize();

int dst_step = dst.step / dst.elemSize(), dst_offset = dst.offset / dst.elemSize();

vector<pair<size_t , const void *> > args;

args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1_step ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1_offset ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2_step ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2_offset ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst_offset ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst.cols ));

const char * const channelMap[] = { "", "", "2", "4", "4" };

std::string buildOptions = format("-D T=%s%s", depth == CV_32F ? "float" : "double", channelMap[dst.channels()]);

openCLExecuteKernel(src1.clCxt, &arithm_magnitude, kernelName, globalThreads, localThreads, args, -1, -1, buildOptions.c_str());

{

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();

int dststep1 = dst.step / dst.elemSize1(), dstoffset1 = dst.offset / dst.elemSize1();

#ifdef ANDROID

size_t localThreads[3] = { 64, 2, 1 };

#else

size_t localThreads[3] = { 64, 4, 1 };

#endif

size_t globalThreads[3] = { (size_t)cols1, (size_t)dst.rows, 1 };

vector<pair<size_t , const void *> > args;

args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src1offset1 ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2step1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&src2offset1 ));

args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dststep1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dstoffset1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&cols1 ));

args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));

openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);

string kernelName, bool angleInDegrees)

{

int channels = src1.oclchannels();

int depth = src1.depth();