自学教程：C++ CV_MAT_DEPTH函数代码示例

void CmShow::SaveShow(CMat& img, CStr& title){    if (title.size() == 0)        return;    int mDepth = CV_MAT_DEPTH(img.type());    double scale = (mDepth == CV_32F || mDepth == CV_64F ? 255 : 1);    if (title.size() > 4 && title[title.size() - 4] == '.')        imwrite(title, img*scale);    else if (title.size())        imshow(title, img);        }

 //! convert OpenCV data type to hppDataType inline int toHppType(const int cvType) {     int depth = CV_MAT_DEPTH(cvType);     int hppType = depth == CV_8U ? HPP_DATA_TYPE_8U :                  depth == CV_16U ? HPP_DATA_TYPE_16U :                  depth == CV_16S ? HPP_DATA_TYPE_16S :                  depth == CV_32S ? HPP_DATA_TYPE_32S :                  depth == CV_32F ? HPP_DATA_TYPE_32F :                  depth == CV_64F ? HPP_DATA_TYPE_64F : -1;     CV_Assert( hppType >= 0 );     return hppType; }

/*! Find Canny edges	/param input input (mat) image (must be color or gray 8-bit image)	/param output edges (mat) image (single channel)	/param threshold1 minimum threshold 	/param threshold2 maximum threshold	/param apertureSize aperture size for Sobel operator	/return <a>true</a> if edges were computed successfully 	The maximum threshold is set to three times the value of	<a>threshold1</a>, unless <a>threshold2</a> is greater than 0.	 	/note See OpenCV reference for an explanation on the thresholds	and aperture size. */bool findCannyEdges(const Mat& input, Mat& output, 					double threshold1, double threshold2, int apertureSize){	// check input type	if (input.type() != CV_8UC1 &&		input.type() != CV_8UC3)	{		ofLog(OF_LOG_WARNING, "in findCannyEdges, input image format is invalid");		return false;	}		// set threshold2 if necessary	if (threshold2 <= 0.0) threshold2 = threshold1*3;		// create output image	if (output.empty() || 		!sameProperties(input, output))	{		output.create(input.rows, 					  input.cols, 					  CV_MAKETYPE(CV_MAT_DEPTH(input.depth()),1));	}		// convert input image to single channel if necessary	Mat gray;	if (input.channels() == 3)	{		gray.create(input.rows, 					input.cols, 					CV_MAKETYPE(CV_MAT_DEPTH(input.depth()),1));		cvtColor(input, gray, CV_RGB2GRAY);	}	else {		gray = input;	}			// find edges	Canny(gray, output, threshold1, threshold2, apertureSize);	return true;}

// Internal, used by toCvCopy and cvtColorCvImagePtr toCvCopyImpl(const cv::Mat& source,                        const std_msgs::Header& src_header,                        const std::string& src_encoding,                        const std::string& dst_encoding){  // Copy metadata  CvImagePtr ptr = boost::make_shared<CvImage>();  ptr->header = src_header;    // Copy to new buffer if same encoding requested  if (dst_encoding.empty() || dst_encoding == src_encoding)  {    ptr->encoding = src_encoding;    source.copyTo(ptr->image);  }  else  {    // Convert the source data to the desired encoding    const std::vector<int> conversion_codes = getConversionCode(src_encoding, dst_encoding);    cv::Mat image1 = source;    cv::Mat image2;    for(size_t i=0; i<conversion_codes.size(); ++i) {      int conversion_code = conversion_codes[i];      if (conversion_code == SAME_FORMAT)      {        // Same number of channels, but different bit depth        int src_depth = enc::bitDepth(src_encoding);        int dst_depth = enc::bitDepth(dst_encoding);        // Keep the number of channels for now but changed to the final depth        int image2_type = CV_MAKETYPE(CV_MAT_DEPTH(getCvType(dst_encoding)), image1.channels());        // Do scaling between CV_8U [0,255] and CV_16U [0,65535] images.        if (src_depth == 8 && dst_depth == 16)          image1.convertTo(image2, image2_type, 65535. / 255.);        else if (src_depth == 16 && dst_depth == 8)          image1.convertTo(image2, image2_type, 255. / 65535.);        else          image1.convertTo(image2, image2_type);      }      else      {        // Perform color conversion        cv::cvtColor(image1, image2, conversion_code);      }      image1 = image2;    }    ptr->image = image2;    ptr->encoding = dst_encoding;  }  return ptr;}

double CxCore_MulSpectrumsTest::get_success_error_level( int test_case_idx, int i, int j ){    CV_UNUSED(test_case_idx);    CV_Assert(i == OUTPUT);    CV_Assert(j == 0);    int elem_depth = CV_MAT_DEPTH(cvGetElemType(test_array[i][j]));    CV_Assert(elem_depth == CV_32F || elem_depth == CV_64F);    element_wise_relative_error = false;    double maxInputValue = 1000; // ArrayTest::get_minmax_bounds    double err = 8 * maxInputValue;  // result = A*B + C*D    return (elem_depth == CV_32F ? FLT_EPSILON : DBL_EPSILON) * err;}

int cv::connectedComponents(InputArray _img, OutputArray _labels, int connectivity, int ltype){    const cv::Mat img = _img.getMat();    _labels.create(img.size(), CV_MAT_DEPTH(ltype));    cv::Mat labels = _labels.getMat();    connectedcomponents::NoOp sop;    if(ltype == CV_16U){        return connectedComponents_sub1(img, labels, connectivity, sop);    }else if(ltype == CV_32S){        return connectedComponents_sub1(img, labels, connectivity, sop);    }else{        CV_Error(CV_StsUnsupportedFormat, "the type of labels must be 16u or 32s");        return 0;    }}

static bool ocl_accumulate( InputArray _src, InputArray _src2, InputOutputArray _dst, double alpha,                            InputArray _mask, int op_type ){    CV_Assert(op_type == ACCUMULATE || op_type == ACCUMULATE_SQUARE ||              op_type == ACCUMULATE_PRODUCT || op_type == ACCUMULATE_WEIGHTED);    int stype = _src.type(), cn = CV_MAT_CN(stype);    int sdepth = CV_MAT_DEPTH(stype), ddepth = _dst.depth();    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,            haveMask = !_mask.empty();    if (!doubleSupport && (sdepth == CV_64F || ddepth == CV_64F))        return false;    const char * const opMap[4] = { "ACCUMULATE", "ACCUMULATE_SQUARE", "ACCUMULATE_PRODUCT",                                   "ACCUMULATE_WEIGHTED" };    ocl::Kernel k("accumulate", ocl::imgproc::accumulate_oclsrc,                  format("-D %s%s -D srcT=%s -D cn=%d -D dstT=%s%s",                         opMap[op_type], haveMask ? " -D HAVE_MASK" : "",                         ocl::typeToStr(sdepth), cn, ocl::typeToStr(ddepth),                         doubleSupport ? " -D DOUBLE_SUPPORT" : ""));    if (k.empty())        return false;    UMat src = _src.getUMat(), src2 = _src2.getUMat(), dst = _dst.getUMat(), mask = _mask.getUMat();    ocl::KernelArg srcarg = ocl::KernelArg::ReadOnlyNoSize(src),            src2arg = ocl::KernelArg::ReadOnlyNoSize(src2),            dstarg = ocl::KernelArg::ReadWrite(dst),            maskarg = ocl::KernelArg::ReadOnlyNoSize(mask);    int argidx = k.set(0, srcarg);    if (op_type == ACCUMULATE_PRODUCT)        argidx = k.set(argidx, src2arg);    argidx = k.set(argidx, dstarg);    if (op_type == ACCUMULATE_WEIGHTED)    {        if (ddepth == CV_32F)            argidx = k.set(argidx, (float)alpha);        else            argidx = k.set(argidx, alpha);    }    if (haveMask)        k.set(argidx, maskarg);    size_t globalsize[2] = { src.cols, src.rows };    return k.run(2, globalsize, NULL, false);}

static bool matchTemplate_CCOEFF(InputArray _image, InputArray _templ, OutputArray _result){    matchTemplate(_image, _templ, _result, CV_TM_CCORR);    UMat image_sums, temp;    integral(_image, temp);    if (temp.depth() == CV_64F)        temp.convertTo(image_sums, CV_32F);    else        image_sums = temp;    int type = image_sums.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);    ocl::Kernel k("matchTemplate_Prepared_CCOEFF", ocl::imgproc::match_template_oclsrc,                  format("-D CCOEFF -D T=%s -D elem_type=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), cn));    if (k.empty())        return false;    UMat templ = _templ.getUMat();    Size size = _image.size(), tsize = templ.size();    _result.create(size.height - templ.rows + 1, size.width - templ.cols + 1, CV_32F);    UMat result = _result.getUMat();    if (cn == 1)    {        float templ_sum = static_cast<float>(sum(_templ)[0]) / tsize.area();        k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result),                templ.rows, templ.cols, templ_sum);    }    else    {        Vec4f templ_sum = Vec4f::all(0);        templ_sum = sum(templ) / tsize.area();        if (cn == 2)            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,                   templ_sum[0], templ_sum[1]);        else if (cn==3)            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,                   templ_sum[0], templ_sum[1], templ_sum[2]);        else            k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadWrite(result), templ.rows, templ.cols,                   templ_sum[0], templ_sum[1], templ_sum[2], templ_sum[3]);    }    size_t globalsize[2] = { result.cols, result.rows };    return k.run(2, globalsize, NULL, false);}

void CV_MHIBaseTest::get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high ){    CvArrTest::get_minmax_bounds( i, j, type, low, high );    if( i == INPUT && CV_MAT_DEPTH(type) == CV_8U )    {        *low = cvScalarAll(cvRound(-1./silh_ratio)+2.);        *high = cvScalarAll(2);    }    else if( i == mhi_i || i == mhi_ref_i )    {        *low = cvScalarAll(-exp(max_log_duration));        *high = cvScalarAll(0.);    }}

static bool ocl_dot( InputArray _src1, InputArray _src2, double & res ){    UMat src1 = _src1.getUMat().reshape(1), src2 = _src2.getUMat().reshape(1);    int type = src1.type(), depth = CV_MAT_DEPTH(type),            kercn = ocl::predictOptimalVectorWidth(src1, src2);    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;    if ( !doubleSupport && depth == CV_64F )        return false;    int dbsize = ocl::Device::getDefault().maxComputeUnits();    size_t wgs = ocl::Device::getDefault().maxWorkGroupSize();    int ddepth = std::max(CV_32F, depth);    int wgs2_aligned = 1;    while (wgs2_aligned < (int)wgs)        wgs2_aligned <<= 1;    wgs2_aligned >>= 1;    char cvt[40];    ocl::Kernel k("reduce", ocl::core::reduce_oclsrc,                  format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstTK=%s -D ddepth=%d -D convertToDT=%s -D OP_DOT "                         "-D WGS=%d -D WGS2_ALIGNED=%d%s%s%s -D kercn=%d",                         ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), ocl::typeToStr(depth),                         ocl::typeToStr(ddepth), ocl::typeToStr(CV_MAKE_TYPE(ddepth, kercn)),                         ddepth, ocl::convertTypeStr(depth, ddepth, kercn, cvt),                         (int)wgs, wgs2_aligned, doubleSupport ? " -D DOUBLE_SUPPORT" : "",                         _src1.isContinuous() ? " -D HAVE_SRC_CONT" : "",                         _src2.isContinuous() ? " -D HAVE_SRC2_CONT" : "", kercn));    if (k.empty())        return false;    UMat db(1, dbsize, ddepth);    ocl::KernelArg src1arg = ocl::KernelArg::ReadOnlyNoSize(src1),            src2arg = ocl::KernelArg::ReadOnlyNoSize(src2),            dbarg = ocl::KernelArg::PtrWriteOnly(db);    k.args(src1arg, src1.cols, (int)src1.total(), dbsize, dbarg, src2arg);    size_t globalsize = dbsize * wgs;    if (k.run(1, &globalsize, &wgs, false))    {        res = sum(db.getMat(ACCESS_READ))[0];        return true;    }    return false;}

static bool ocl_pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType){    int type = _src.type(), depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);    if (channels > 4 || borderType != BORDER_DEFAULT)        return false;    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;    if (depth == CV_64F && !doubleSupport)        return false;    Size ssize = _src.size();    if ((_dsz.area() != 0) && (_dsz != Size(ssize.width * 2, ssize.height * 2)))        return false;    UMat src = _src.getUMat();    Size dsize = Size(ssize.width * 2, ssize.height * 2);    _dst.create( dsize, src.type() );    UMat dst = _dst.getUMat();    int float_depth = depth == CV_64F ? CV_64F : CV_32F;    const int local_size = 16;    char cvt[2][50];    String buildOptions = format(            "-D T=%s -D FT=%s -D convertToT=%s -D convertToFT=%s%s "            "-D T1=%s -D cn=%d -D LOCAL_SIZE=%d",            ocl::typeToStr(type), ocl::typeToStr(CV_MAKETYPE(float_depth, channels)),            ocl::convertTypeStr(float_depth, depth, channels, cvt[0]),            ocl::convertTypeStr(depth, float_depth, channels, cvt[1]),            doubleSupport ? " -D DOUBLE_SUPPORT" : "",            ocl::typeToStr(depth), channels, local_size    );    size_t globalThreads[2] = { dst.cols, dst.rows };    size_t localThreads[2] = { local_size, local_size };    ocl::Kernel k;    if (ocl::Device::getDefault().isIntel() && channels == 1)    {        k.create("pyrUp_unrolled", ocl::imgproc::pyr_up_oclsrc, buildOptions);        globalThreads[0] = dst.cols/2; globalThreads[1] = dst.rows/2;    }    else        k.create("pyrUp", ocl::imgproc::pyr_up_oclsrc, buildOptions);    if (k.empty())        return false;    k.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnly(dst));    return k.run(2, globalThreads, localThreads, false);}

static bool ocl_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType){    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;    if (cn > 4 || (depth == CV_64F && !doubleSupport))        return false;    Size ssize = _src.size();    Size dsize = _dsz.area() == 0 ? Size((ssize.width + 1) / 2, (ssize.height + 1) / 2) : _dsz;    if (dsize.height < 2 || dsize.width < 2)        return false;    CV_Assert( ssize.width > 0 && ssize.height > 0 &&            std::abs(dsize.width*2 - ssize.width) <= 2 &&            std::abs(dsize.height*2 - ssize.height) <= 2 );    UMat src = _src.getUMat();    _dst.create( dsize, src.type() );    UMat dst = _dst.getUMat();    int float_depth = depth == CV_64F ? CV_64F : CV_32F;    const int local_size = 256;    int kercn = 1;    if (depth == CV_8U && float_depth == CV_32F && cn == 1 && ocl::Device::getDefault().isIntel())        kercn = 4;    const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", "BORDER_WRAP",                                       "BORDER_REFLECT_101" };    char cvt[2][50];    String buildOptions = format(            "-D T=%s -D FT=%s -D convertToT=%s -D convertToFT=%s%s "            "-D T1=%s -D cn=%d -D kercn=%d -D fdepth=%d -D %s -D LOCAL_SIZE=%d",            ocl::typeToStr(type), ocl::typeToStr(CV_MAKETYPE(float_depth, cn)),            ocl::convertTypeStr(float_depth, depth, cn, cvt[0]),            ocl::convertTypeStr(depth, float_depth, cn, cvt[1]),            doubleSupport ? " -D DOUBLE_SUPPORT" : "", ocl::typeToStr(depth),            cn, kercn, float_depth, borderMap[borderType], local_size    );    ocl::Kernel k("pyrDown", ocl::imgproc::pyr_down_oclsrc, buildOptions);    if (k.empty())        return false;    k.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnly(dst));    size_t localThreads[2]  = { local_size/kercn, 1 };    size_t globalThreads[2] = { (src.cols + (kercn-1))/kercn, (dst.rows + 1) / 2 };    return k.run(2, globalThreads, localThreads, false);}

static void libopencv_(Main_opencvMat2torch)(CvMat *source, THTensor *dest) {  int mat_step;  CvSize mat_size;  THTensor *tensor;  // type dependent variables  float * data_32F;  float * data_32Fp;  double * data_64F;  double * data_64Fp;  uchar * data_8U;  uchar * data_8Up;  char * data_8S;  char * data_8Sp;  unsigned int * data_16U;  unsigned int * data_16Up;  short * data_16S;  short * data_16Sp;  switch (CV_MAT_DEPTH(source->type))    {    case CV_32F:      cvGetRawData(source, (uchar**)&data_32F, &mat_step, &mat_size);      // Resize target      THTensor_(resize3d)(dest, 1, source->rows, source->cols);      tensor = THTensor_(newContiguous)(dest);      data_32Fp = data_32F;      // copy      TH_TENSOR_APPLY(real, tensor,                      *tensor_data = ((real)(*data_32Fp));                      // step through channels of ipl                      data_32Fp++;                      );      THTensor_(free)(tensor);      break;    case CV_64F:      cvGetRawData(source, (uchar**)&data_64F, &mat_step, &mat_size);      // Resize target      THTensor_(resize3d)(dest, 1, source->rows, source->cols);      tensor = THTensor_(newContiguous)(dest);      data_64Fp = data_64F;      // copy      TH_TENSOR_APPLY(real, tensor,                      *tensor_data = ((real)(*data_64Fp));                      // step through channels of ipl                      data_64Fp++;                      );

  void FilterBase::apply(cv::InputArray _src, cv::OutputArray _dst, const int &ddepth){    int stype = _src.type();    int dcn = _src.channels();    int depth = CV_MAT_DEPTH(stype);    if (0 <= ddepth)      depth = ddepth;    Mat src, dst;    src = _src.getMat();    Size sz = src.size();    _dst.create(sz, CV_MAKETYPE(depth, dcn));    dst = _dst.getMat();    int imageWidth = src.rows;    int imageHeight = src.cols;    Mat srcChannels[3];    split(src, srcChannels);    int margineWidth = kernel.cols / 2;    int margineHeight = kernel.rows / 2;    double kernelElemCount = (double)(kernel.cols * kernel.rows);    for(int ch = 0; ch < dcn; ++ch){      for(int y = 0; y < imageHeight; ++y){	Vec3d  *ptr = dst.ptr<Vec3d>(y);	for(int x = 0; x < imageWidth; ++x){	  if (isEdge(x, y, imageWidth, imageHeight, margineWidth, margineWidth)){	    ptr[x][ch]	      = calcKernelOutputAtEdge(srcChannels[ch],				       kernel, x, y,				       imageWidth, imageHeight,				       margineWidth, margineHeight);	  }else{	    ptr[x][ch]	      = calcKernelOutput(srcChannels[ch],				 kernel, x, y,				 margineWidth, margineHeight,				 				 kernelElemCount);	  }	}      }    }  }

void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,                int ksize, double scale, double delta, int borderType ){    int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype);    if (ddepth < 0)        ddepth = sdepth;    int dtype = CV_MAKE_TYPE(ddepth, cn);    _dst.create( _src.size(), dtype );#ifdef HAVE_TEGRA_OPTIMIZATION    if (scale == 1.0 && delta == 0)    {        Mat src = _src.getMat(), dst = _dst.getMat();        if (ksize == 3 && tegra::sobel3x3(src, dst, dx, dy, borderType))            return;        if (ksize == -1 && tegra::scharr(src, dst, dx, dy, borderType))            return;    }#endif#ifdef HAVE_IPP    if (ksize < 0)    {        if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType))            return;    }    else if (0 < ksize)    {        if (IPPDerivSobel(_src, _dst, ddepth, dx, dy, ksize, scale, delta, borderType))            return;    }#endif    int ktype = std::max(CV_32F, std::max(ddepth, sdepth));    Mat kx, ky;    getDerivKernels( kx, ky, dx, dy, ksize, false, ktype );    if( scale != 1 )    {        // usually the smoothing part is the slowest to compute,        // so try to scale it instead of the faster differenciating part        if( dx == 0 )            kx *= scale;        else            ky *= scale;    }    sepFilter2D( _src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType );}

void UMat::copyTo(OutputArray _dst, InputArray _mask) const{    if( _mask.empty() )    {        copyTo(_dst);        return;    }#ifdef HAVE_OPENCL    int cn = channels(), mtype = _mask.type(), mdepth = CV_MAT_DEPTH(mtype), mcn = CV_MAT_CN(mtype);    CV_Assert( mdepth == CV_8U && (mcn == 1 || mcn == cn) );    if (ocl::useOpenCL() && _dst.isUMat() && dims <= 2)    {        UMatData * prevu = _dst.getUMat().u;        _dst.create( dims, size, type() );        UMat dst = _dst.getUMat();        bool haveDstUninit = false;        if( prevu != dst.u ) // do not leave dst uninitialized            haveDstUninit = true;        String opts = format("-D COPY_TO_MASK -D T1=%s -D scn=%d -D mcn=%d%s",                             ocl::memopTypeToStr(depth()), cn, mcn,                             haveDstUninit ? " -D HAVE_DST_UNINIT" : "");        ocl::Kernel k("copyToMask", ocl::core::copyset_oclsrc, opts);        if (!k.empty())        {            k.args(ocl::KernelArg::ReadOnlyNoSize(*this),                   ocl::KernelArg::ReadOnlyNoSize(_mask.getUMat()),                   haveDstUninit ? ocl::KernelArg::WriteOnly(dst) :                                   ocl::KernelArg::ReadWrite(dst));            size_t globalsize[2] = { cols, rows };            if (k.run(2, globalsize, NULL, false))            {                CV_IMPL_ADD(CV_IMPL_OCL);                return;            }        }    }#endif    Mat src = getMat(ACCESS_READ);    src.copyTo(_dst, _mask);}

static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double & result ){    const ocl::Device & d = ocl::Device::getDefault();#ifdef __ANDROID__    if (d.isNVidia())        return false;#endif    const int cn = _src.channels();    if (cn > 4)        return false;    int type = _src.type(), depth = CV_MAT_DEPTH(type);    bool doubleSupport = d.doubleFPConfig() > 0,            haveMask = _mask.kind() != _InputArray::NONE;    if ( !(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR) ||         (!doubleSupport && depth == CV_64F))        return false;    UMat src = _src.getUMat();    if (normType == NORM_INF)    {        if (!ocl_minMaxIdx(_src, NULL, &result, NULL, NULL, _mask,                           std::max(depth, CV_32S), depth != CV_8U && depth != CV_16U))            return false;    }    else if (normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR)    {        Scalar sc;        bool unstype = depth == CV_8U || depth == CV_16U;        if ( !ocl_sum(haveMask ? src : src.reshape(1), sc, normType == NORM_L2 || normType == NORM_L2SQR ?                    OCL_OP_SUM_SQR : (unstype ? OCL_OP_SUM : OCL_OP_SUM_ABS), _mask) )            return false;        double s = 0.0;        for (int i = 0; i < (haveMask ? cn : 1); ++i)            s += sc[i];        result = normType == NORM_L1 || normType == NORM_L2SQR ? s : std::sqrt(s);    }    return true;}

/* motion templates */CV_IMPL voidcvUpdateMotionHistory( const void* silhouette, void* mhimg,                       double timestamp, double mhi_duration ){    CvSize size;    CvMat  silhstub, *silh = (CvMat*)silhouette;    CvMat  mhistub, *mhi = (CvMat*)mhimg;    int mhi_step, silh_step;    CV_FUNCNAME( "cvUpdateMHIByTime" );    __BEGIN__;    CV_CALL( silh = cvGetMat( silh, &silhstub ));    CV_CALL( mhi = cvGetMat( mhi, &mhistub ));    if( !CV_IS_MASK_ARR( silh ))        CV_ERROR( CV_StsBadMask, "" );    if( CV_MAT_CN( mhi->type ) > 1 )        CV_ERROR( CV_BadNumChannels, "" );    if( CV_MAT_DEPTH( mhi->type ) != CV_32F )        CV_ERROR( CV_BadDepth, "" );    if( !CV_ARE_SIZES_EQ( mhi, silh ))        CV_ERROR( CV_StsUnmatchedSizes, "" );    size = cvGetMatSize( mhi );    mhi_step = mhi->step;    silh_step = silh->step;    if( CV_IS_MAT_CONT( mhi->type & silh->type ))    {        size.width *= size.height;        mhi_step = silh_step = CV_STUB_STEP;        size.height = 1;    }    IPPI_CALL( icvUpdateMotionHistory_8u32f_C1IR( (const uchar*)(silh->data.ptr), silh_step,                                                  mhi->data.fl, mhi_step, size,                                                  (float)timestamp, (float)mhi_duration ));    __END__;}

OCL_PERF_TEST_P(ConvertToFixture, ConvertTo,                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES)){    const Size_MatType_t params = GetParam();    const Size srcSize = get<0>(params);    const int type = get<1>(params), ddepth = CV_MAT_DEPTH(type) == CV_8U ? CV_32F : CV_8U,        cn = CV_MAT_CN(type), dtype = CV_MAKE_TYPE(ddepth, cn);    checkDeviceMaxMemoryAllocSize(srcSize, type);    checkDeviceMaxMemoryAllocSize(srcSize, dtype);    UMat src(srcSize, type), dst(srcSize, dtype);    declare.in(src, WARMUP_RNG).out(dst);    OCL_TEST_CYCLE() src.convertTo(dst, dtype);    SANITY_CHECK(dst);}

void LBSP::calcDescImgDiff(const cv::Mat& oDesc1, const cv::Mat& oDesc2, cv::Mat& oOutput, bool bForceMergeChannels) {    static_assert(LBSP::DESC_SIZE_BITS<=UCHAR_MAX,"bad assumptions in impl below");    static_assert(LBSP::DESC_SIZE==2,"bad assumptions in impl below");    CV_DbgAssert(oDesc1.size()==oDesc2.size() && oDesc1.type()==oDesc2.type());    CV_DbgAssert(oDesc1.type()==CV_16UC1 || oDesc1.type()==CV_16UC3);    CV_DbgAssert(CV_MAT_DEPTH(oDesc1.type())==CV_16U);    CV_DbgAssert(oDesc1.step.p[0]==oDesc2.step.p[0] && oDesc1.step.p[1]==oDesc2.step.p[1]);    const float fScaleFactor = (float)UCHAR_MAX/(LBSP::DESC_SIZE_BITS);    const size_t nChannels = CV_MAT_CN(oDesc1.type());    const size_t _step_row = oDesc1.step.p[0];    if(nChannels==1) {        oOutput.create(oDesc1.size(),CV_8UC1);        oOutput = cv::Scalar(0);        for(int i=0; i<oDesc1.rows; ++i) {            const size_t idx = _step_row*i;            const ushort* const desc1_ptr = (ushort*)(oDesc1.data+idx);            const ushort* const desc2_ptr = (ushort*)(oDesc2.data+idx);            for(int j=0; j<oDesc1.cols; ++j)                oOutput.at<uchar>(i,j) = (uchar)(fScaleFactor*DistanceUtils::hdist(desc1_ptr[j],desc2_ptr[j]));        }    }    else { //nChannels==3        if(bForceMergeChannels)            oOutput.create(oDesc1.size(),CV_8UC1);        else            oOutput.create(oDesc1.size(),CV_8UC3);        oOutput = cv::Scalar::all(0);        for(int i=0; i<oDesc1.rows; ++i) {            const size_t idx =  _step_row*i;            const ushort* const desc1_ptr = (ushort*)(oDesc1.data+idx);            const ushort* const desc2_ptr = (ushort*)(oDesc2.data+idx);            uchar* output_ptr = oOutput.data + oOutput.step.p[0]*i;            for(int j=0; j<oDesc1.cols; ++j) {                for(size_t n=0;n<3; ++n) {                    const size_t idx2 = 3*j+n;                    if(bForceMergeChannels)                        output_ptr[j] += (uchar)((fScaleFactor*DistanceUtils::hdist(desc1_ptr[idx2],desc2_ptr[idx2]))/3);                    else                        output_ptr[idx2] = (uchar)(fScaleFactor*DistanceUtils::hdist(desc1_ptr[idx2],desc2_ptr[idx2]));                }            }        }    }}

void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,                 double scale, double delta, int borderType ){    int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype);    if (ddepth < 0)        ddepth = sdepth;    int dtype = CV_MAKETYPE(ddepth, cn);    _dst.create( _src.size(), dtype );#ifdef HAVE_TEGRA_OPTIMIZATION    if (tegra::useTegra() && scale == 1.0 && delta == 0)    {        Mat src = _src.getMat(), dst = _dst.getMat();        if (tegra::scharr(src, dst, dx, dy, borderType))            return;    }#endif#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)    CV_IPP_CHECK()    {        if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType))        {            CV_IMPL_ADD(CV_IMPL_IPP);            return;        }    }#endif    int ktype = std::max(CV_32F, std::max(ddepth, sdepth));    Mat kx, ky;    getScharrKernels( kx, ky, dx, dy, false, ktype );    if( scale != 1 )    {        // usually the smoothing part is the slowest to compute,        // so try to scale it instead of the faster differenciating part        if( dx == 0 )            kx *= scale;        else            ky *= scale;    }    sepFilter2D( _src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType );}

static bool ocl_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType){    int type = _src.type(), depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);    if (channels > 4 || borderType != BORDER_DEFAULT)        return false;    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;    if ((depth == CV_64F) && !(doubleSupport))        return false;    Size ssize = _src.size();    Size dsize = _dsz.area() == 0 ? Size((ssize.width + 1) / 2, (ssize.height + 1) / 2) : _dsz;    CV_Assert( ssize.width > 0 && ssize.height > 0 &&            std::abs(dsize.width*2 - ssize.width) <= 2 &&            std::abs(dsize.height*2 - ssize.height) <= 2 );    UMat src = _src.getUMat();    _dst.create( dsize, src.type() );    UMat dst = _dst.getUMat();    int float_depth = depth == CV_64F ? CV_64F : CV_32F;    char cvt[2][50];    String buildOptions = format(            "-D T=%s -D FT=%s -D convertToT=%s -D convertToFT=%s%s "            "-D T1=%s -D cn=%d",            ocl::typeToStr(type), ocl::typeToStr(CV_MAKETYPE(float_depth, channels)),            ocl::convertTypeStr(float_depth, depth, channels, cvt[0]),            ocl::convertTypeStr(depth, float_depth, channels, cvt[1]),            doubleSupport ? " -D DOUBLE_SUPPORT" : "",            ocl::typeToStr(depth), channels    );    ocl::Kernel k("pyrDown", ocl::imgproc::pyr_down_oclsrc, buildOptions);    if (k.empty())        return false;    k.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnly(dst));    size_t localThreads[2]  = { 256, 1 };    size_t globalThreads[2] = { src.cols, dst.rows };    return k.run(2, globalThreads, localThreads, false);}

static bool ocl_threshold( InputArray _src, OutputArray _dst, double & thresh, double maxval, int thresh_type ){    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),        kercn = ocl::predictOptimalVectorWidth(_src, _dst), ktype = CV_MAKE_TYPE(depth, kercn);    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;    if ( !(thresh_type == THRESH_BINARY || thresh_type == THRESH_BINARY_INV || thresh_type == THRESH_TRUNC ||           thresh_type == THRESH_TOZERO || thresh_type == THRESH_TOZERO_INV) ||         (!doubleSupport && depth == CV_64F))        return false;    const char * const thresholdMap[] = { "THRESH_BINARY", "THRESH_BINARY_INV", "THRESH_TRUNC",                                          "THRESH_TOZERO", "THRESH_TOZERO_INV" };    ocl::Device dev = ocl::Device::getDefault();    int stride_size = dev.isIntel() && (dev.type() & ocl::Device::TYPE_GPU) ? 4 : 1;    ocl::Kernel k("threshold", ocl::imgproc::threshold_oclsrc,                  format("-D %s -D T=%s -D T1=%s -D STRIDE_SIZE=%d%s", thresholdMap[thresh_type],                         ocl::typeToStr(ktype), ocl::typeToStr(depth), stride_size,                         doubleSupport ? " -D DOUBLE_SUPPORT" : ""));    if (k.empty())        return false;    UMat src = _src.getUMat();    _dst.create(src.size(), type);    UMat dst = _dst.getUMat();    if (depth <= CV_32S)        thresh = cvFloor(thresh);    const double min_vals[] = { 0, CHAR_MIN, 0, SHRT_MIN, INT_MIN, -FLT_MAX, -DBL_MAX, 0 };    double min_val = min_vals[depth];    k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::WriteOnly(dst, cn, kercn),           ocl::KernelArg::Constant(Mat(1, 1, depth, Scalar::all(thresh))),           ocl::KernelArg::Constant(Mat(1, 1, depth, Scalar::all(maxval))),           ocl::KernelArg::Constant(Mat(1, 1, depth, Scalar::all(min_val))));    size_t globalsize[2] = { dst.cols * cn / kercn, dst.rows };    globalsize[1] = (globalsize[1] + stride_size - 1) / stride_size;    return k.run(2, globalsize, NULL, false);}

OCL_PERF_TEST_P(BlendLinearFixture, BlendLinear, ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES_134)){    Size_MatType_t params = GetParam();    const Size srcSize = get<0>(params);    const int srcType = get<1>(params);    const double eps = CV_MAT_DEPTH(srcType) <= CV_32S ? 1.0 : 0.2;    checkDeviceMaxMemoryAllocSize(srcSize, srcType);    UMat src1(srcSize, srcType), src2(srcSize, srcType), dst(srcSize, srcType);    UMat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);    declare.in(src1, src2, WARMUP_RNG).in(weights1, weights2, WARMUP_READ).out(dst);    randu(weights1, 0, 1);    randu(weights2, 0, 1);    OCL_TEST_CYCLE() cv::blendLinear(src1, src2, weights1, weights2, dst);    SANITY_CHECK(dst, eps);}

void PrintMat(CvMat *A){	int i, j;	for (i = 0; i < A->rows; i++){		printf("/n"); 		switch (CV_MAT_DEPTH(A->type)){			case CV_32F:			case CV_64F:				for (j = 0; j < A->cols; j++)					printf ("%8.3f", (float)cvGetReal2D(A, i, j));				break;			case CV_8U:			case CV_16U:				for(j = 0; j < A->cols; j++)					printf ("%6d",(int)cvGetReal2D(A, i, j));				break;			default:			break;		}	}	printf("/n");}

/*! Get new frame	/return <true> if video capture object is opened */bool ofxCv2FrameGrabber::getNewFrame(){	if (!cap.isOpened()) { return false; }		Mat frame;	cap >> frame;		if (frame.cols != cvImage.cols || 		frame.rows != cvImage.rows ||		frame.channels() != cvImage.channels() ||		frame.depth() != cvImage.depth())	{		cvImage.create(frame.rows, frame.cols, CV_MAKETYPE(CV_MAT_DEPTH(frame.depth()),frame.channels()));	}	cvtColor(frame, cvImage, CV_BGR2RGB);		textureIsDirty = true;		return true;}

static bool ocl_blendLinear( InputArray _src1, InputArray _src2, InputArray _weights1, InputArray _weights2, OutputArray _dst ){    int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);    char cvt[30];    ocl::Kernel k("blendLinear", ocl::imgproc::blend_linear_oclsrc,                  format("-D T=%s -D cn=%d -D convertToT=%s", ocl::typeToStr(depth),                         cn, ocl::convertTypeStr(CV_32F, depth, 1, cvt)));    if (k.empty())        return false;    UMat src1 = _src1.getUMat(), src2 = _src2.getUMat(), weights1 = _weights1.getUMat(),            weights2 = _weights2.getUMat(), dst = _dst.getUMat();    k.args(ocl::KernelArg::ReadOnlyNoSize(src1), ocl::KernelArg::ReadOnlyNoSize(src2),           ocl::KernelArg::ReadOnlyNoSize(weights1), ocl::KernelArg::ReadOnlyNoSize(weights2),           ocl::KernelArg::WriteOnly(dst));    size_t globalsize[2] = { (size_t)dst.cols, (size_t)dst.rows };    return k.run(2, globalsize, NULL, false);}

DLLEXP void DispCvArrMultiChannel( CvArr *a, char *varName /*= VAR_NAME(varName)*/ ){	CvMat tmpHeader, *m;	m = cvGetMat(a, &tmpHeader);	int cnNum = CV_MAT_CN(m->type), depth = CV_MAT_DEPTH(m->type);	CvMat **p = new CvMat *[4];	for (int i = 0; i < 4; i++)		p[i] = ( i >= cnNum ? NULL : 		cvCreateMat(m->rows, m->cols, CV_MAKETYPE(depth, 1)) );	cvSplit(m, p[0], p[1], p[2], p[3]);	for (int i = 0; i < cnNum; i++)	{		CString str;		str.Format("%s : channel %d", varName, i);		DispCvArr(p[i], str.GetBuffer());	}	for (int i = 0; i < cnNum; i++)		cvReleaseMat(&p[i]);	delete []p;}