GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); cv::Size size = GET_PARAM(1); cv::Size templ_size = GET_PARAM(2); int cn = GET_PARAM(3); int method = GET_PARAM(4); cv::Mat image_host(size, CV_MAKE_TYPE(CV_32F, cn)); fill(image_host, 0, 255); cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_32F, cn)); fill(templ_host, 0, 255); cv::gpu::GpuMat image(image_host); cv::gpu::GpuMat templ(templ_host); cv::gpu::GpuMat dst; cv::gpu::matchTemplate(image, templ, dst, method); TEST_CYCLE() { cv::gpu::matchTemplate(image, templ, dst, method); } };
TEST(DomainTransformTest, SplatSurfaceAccuracy) { static int dtModes[] = {DTF_NC, DTF_RF, DTF_IC}; RNG rnd(0); for (int i = 0; i < 15; i++) { Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024)); int guideCn = rnd.uniform(1, 4); Mat guide(sz, CV_MAKE_TYPE(CV_32F, guideCn)); randu(guide, 0, 255); Scalar surfaceValue; int srcCn = rnd.uniform(1, 4); rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255); Mat src(sz, CV_MAKE_TYPE(CV_8U, srcCn), surfaceValue); double sigma_s = rnd.uniform(1.0, 100.0); double sigma_r = rnd.uniform(1.0, 100.0); int mode = dtModes[i%3]; Mat res; dtFilter(guide, src, res, sigma_s, sigma_r, mode, 1); double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels(); EXPECT_LE(normL1, 1.0/64); } }
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; }
GPU_PERF_TEST(HistEven_FourChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); cv::Size size = GET_PARAM(1); int depth = GET_PARAM(2); cv::Mat src_host(size, CV_MAKE_TYPE(depth, 4)); fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat hist[4]; cv::gpu::GpuMat buf; int histSize[] = {30, 30, 30, 30}; int lowerLevel[] = {0, 0, 0, 0}; int upperLevel[] = {180, 180, 180, 180}; cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel); TEST_CYCLE() { cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel); } }
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::Kernel k("threshold", ocl::imgproc::threshold_oclsrc, format("-D %s -D T=%s -D T1=%s%s", thresholdMap[thresh_type], ocl::typeToStr(ktype), ocl::typeToStr(depth), 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); 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)))); size_t globalsize[2] = { dst.cols * cn / kercn, dst.rows }; return k.run(2, globalsize, NULL, false); }
void grayDctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize) { CV_Assert( src.type() == CV_MAKE_TYPE(CV_32F, 1) ); int npixels = (src.rows - psize)*(src.cols - psize); std::vector <Mat> patches; for (int i = 0; i < npixels; ++i) patches.push_back( Mat(psize, psize, CV_32FC1) ); parallel_for_( cv::Range(0, npixels), grayDctDenoisingInvoker(src, patches, sigma, psize) ); Mat res( src.size(), CV_32FC1, 0.0f ), num( src.size(), CV_32FC1, 0.0f ); for (int k = 0; k < npixels; ++k) { int i = k / (src.cols - psize); int j = k % (src.cols - psize); res( Rect(j, i, psize, psize) ) += patches[k]; num( Rect(j, i, psize, psize) ) += Mat::ones(psize, psize, CV_32FC1); } res /= num; res.convertTo( dst, src.type() ); }
static bool sumTemplate(InputArray _src, UMat & result) { int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); int wdepth = CV_32F, wtype = CV_MAKE_TYPE(wdepth, cn); size_t wgs = ocl::Device::getDefault().maxWorkGroupSize(); int wgs2_aligned = 1; while (wgs2_aligned < (int)wgs) wgs2_aligned <<= 1; wgs2_aligned >>= 1; char cvt[40]; ocl::Kernel k("calcSum", ocl::imgproc::match_template_oclsrc, format("-D CALC_SUM -D T=%s -D T1=%s -D WT=%s -D cn=%d -D convertToWT=%s -D WGS=%d -D WGS2_ALIGNED=%d", ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(wtype), cn, ocl::convertTypeStr(depth, wdepth, cn, cvt), (int)wgs, wgs2_aligned)); if (k.empty()) return false; UMat src = _src.getUMat(); result.create(1, 1, CV_32FC1); ocl::KernelArg srcarg = ocl::KernelArg::ReadOnlyNoSize(src), resarg = ocl::KernelArg::PtrWriteOnly(result); k.args(srcarg, src.cols, (int)src.total(), resarg); size_t globalsize = wgs; return k.run(1, &globalsize, &wgs, false); }
int imdecodeJPEG(const unsigned char* buff, int buff_size, Mat& dest) { int w,h,c; getHeader((uchar*)buff,buff_size,w,h,c); dest = Mat::zeros(Size(w,h),CV_MAKE_TYPE(CV_8U,c)); jpeg_decode((uchar*)buff,buff_size,dest.data,w,h); return 0; }
int imdecodeJPEG(const vector<uchar>& buff, Mat& dest) { uchar* dst = (uchar*)&buff[0]; int w,h,c; getHeader((uchar*)dst,buff.size(),w,h,c); dest = Mat::zeros(Size(w,h),CV_MAKE_TYPE(CV_8U,c)); jpeg_decode(dst,buff.size(),dest.data,dest.cols,dest.rows); return 0; }
static bool ocl_Laplacian5(InputArray _src, OutputArray _dst, const Mat & kd, const Mat & ks, double scale, double delta, int borderType, int depth, int ddepth) { int iscale = cvRound(scale), idelta = cvRound(delta); bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0, floatCoeff = std::fabs(delta - idelta) > DBL_EPSILON || std::fabs(scale - iscale) > DBL_EPSILON; int cn = _src.channels(), wdepth = std::max(depth, floatCoeff ? CV_32F : CV_32S), kercn = 1; if (!doubleSupport && wdepth == CV_64F) return false; char cvt[2][40]; ocl::Kernel k("sumConvert", ocl::imgproc::laplacian5_oclsrc, format("-D srcT=%s -D WT=%s -D dstT=%s -D coeffT=%s -D wdepth=%d " "-D convertToWT=%s -D convertToDT=%s%s", ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), ocl::typeToStr(CV_MAKE_TYPE(wdepth, kercn)), ocl::typeToStr(CV_MAKE_TYPE(ddepth, kercn)), ocl::typeToStr(wdepth), wdepth, ocl::convertTypeStr(depth, wdepth, kercn, cvt[0]), ocl::convertTypeStr(wdepth, ddepth, kercn, cvt[1]), doubleSupport ? " -D DOUBLE_SUPPORT" : "")); if (k.empty()) return false; UMat d2x, d2y; sepFilter2D(_src, d2x, depth, kd, ks, Point(-1, -1), 0, borderType); sepFilter2D(_src, d2y, depth, ks, kd, Point(-1, -1), 0, borderType); UMat dst = _dst.getUMat(); ocl::KernelArg d2xarg = ocl::KernelArg::ReadOnlyNoSize(d2x), d2yarg = ocl::KernelArg::ReadOnlyNoSize(d2y), dstarg = ocl::KernelArg::WriteOnly(dst, cn, kercn); if (wdepth >= CV_32F) k.args(d2xarg, d2yarg, dstarg, (float)scale, (float)delta); else k.args(d2xarg, d2yarg, dstarg, iscale, idelta); size_t globalsize[] = { dst.cols * cn / kercn, dst.rows }; return k.run(2, globalsize, NULL, false); }
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 (tegra::useTegra() && 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 CV_IPP_CHECK() { if (ksize < 0) { if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType)) { CV_IMPL_ADD(CV_IMPL_IPP); return; } } else if (0 < ksize) { if (IPPDerivSobel(_src, _dst, ddepth, dx, dy, ksize, scale, delta, borderType)) { CV_IMPL_ADD(CV_IMPL_IPP); 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 ); }
UMat& UMat::setTo(InputArray _value, InputArray _mask) { bool haveMask = !_mask.empty(); #ifdef HAVE_OPENCL int tp = type(), cn = CV_MAT_CN(tp), d = CV_MAT_DEPTH(tp); if( dims <= 2 && cn <= 4 && CV_MAT_DEPTH(tp) < CV_64F && ocl::useOpenCL() ) { Mat value = _value.getMat(); CV_Assert( checkScalar(value, type(), _value.kind(), _InputArray::UMAT) ); int kercn = haveMask || cn == 3 ? cn : std::max(cn, ocl::predictOptimalVectorWidth(*this)), kertp = CV_MAKE_TYPE(d, kercn); double buf[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; convertAndUnrollScalar(value, tp, (uchar *)buf, kercn / cn); int scalarcn = kercn == 3 ? 4 : kercn, rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1; String opts = format("-D dstT=%s -D rowsPerWI=%d -D dstST=%s -D dstT1=%s -D cn=%d", ocl::memopTypeToStr(kertp), rowsPerWI, ocl::memopTypeToStr(CV_MAKETYPE(d, scalarcn)), ocl::memopTypeToStr(d), kercn); ocl::Kernel setK(haveMask ? "setMask" : "set", ocl::core::copyset_oclsrc, opts); if( !setK.empty() ) { ocl::KernelArg scalararg(0, 0, 0, 0, buf, CV_ELEM_SIZE(d) * scalarcn); UMat mask; if( haveMask ) { mask = _mask.getUMat(); CV_Assert( mask.size() == size() && mask.type() == CV_8UC1 ); ocl::KernelArg maskarg = ocl::KernelArg::ReadOnlyNoSize(mask), dstarg = ocl::KernelArg::ReadWrite(*this); setK.args(maskarg, dstarg, scalararg); } else { ocl::KernelArg dstarg = ocl::KernelArg::WriteOnly(*this, cn, kercn); setK.args(dstarg, scalararg); } size_t globalsize[] = { cols * cn / kercn, (rows + rowsPerWI - 1) / rowsPerWI }; if( setK.run(2, globalsize, NULL, false) ) { CV_IMPL_ADD(CV_IMPL_OCL); return *this; } } } #endif Mat m = getMat(haveMask ? ACCESS_RW : ACCESS_WRITE); m.setTo(_value, _mask); return *this; }
void Classifier::init(const std::string& model_def, const std::string& trained_weights, const std::string& mean_file, const std::string& label_file, const int &gpu_id) { if(gpu_id>=0) { caffe::Caffe::set_mode(caffe::Caffe::GPU); caffe::Caffe::SetDevice(gpu_id); } else caffe::Caffe::set_mode(caffe::Caffe::CPU); /* Load the network. */ net_.reset(new caffe::Net<float>(model_def, caffe::TEST)); net_->CopyTrainedLayersFrom(trained_weights); CHECK_EQ(net_->num_inputs(), 1) << "Network should have exactly one input."; CHECK_EQ(net_->num_outputs(), 1) << "Network should have exactly one output."; caffe::Blob<float>* input_layer = net_->input_blobs()[0]; num_channels_ = input_layer->channels(); CHECK(num_channels_ == 3 || num_channels_ == 1) << "Input layer should have 1 or 3 channels."; input_geometry_ = cv::Size(input_layer->width(), input_layer->height()); /* Load the binaryproto mean file. */ if(mean_file!="") SetMean(mean_file); else { mean_ = cv::Mat::zeros(input_geometry_, CV_MAKE_TYPE(CV_32F, num_channels_)); } /* Load labels. */ caffe::Blob<float>* output_layer = net_->output_blobs()[0]; if(label_file!="") { std::ifstream labels(label_file.c_str()); CHECK(labels) << "Unable to open labels file " << label_file; std::string line; while (std::getline(labels, line)) labels_.push_back(std::string(line)); CHECK_EQ(labels_.size(), output_layer->channels()) << "Number of labels is different from the output layer dimension."; } else { for (int i = 0; i < output_layer->channels(); ++i) { std::stringstream ss; ss << i; labels_.push_back(ss.str()); } } is_ready = true; }
cv::Mat RawImageToCvMat(const Dtype *raw, const cv::Size &sz, const int depth = CV_8U, const int chn = 1) { Dtype *_raw; size_t msz = sz.width * sz.height * chn * sizeof(Dtype); _raw = (Dtype *) ::operator new(msz); memcpy(_raw, raw, msz); cv::Mat img(sz, CV_MAKE_TYPE(depth, chn), _raw, cv::Mat::AUTO_STEP); return img; }
static bool matchTemplateNaive_CCORR(InputArray _image, InputArray _templ, OutputArray _result) { int type = _image.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); int wdepth = CV_32F, wtype = CV_MAKE_TYPE(wdepth, cn); ocl::Device dev = ocl::Device::getDefault(); int pxPerWIx = (cn==1 && dev.isIntel() && (dev.type() & ocl::Device::TYPE_GPU)) ? 4 : 1; int rated_cn = cn; int wtype1 = wtype; if (pxPerWIx!=1) { rated_cn = pxPerWIx; type = CV_MAKE_TYPE(depth, rated_cn); wtype1 = CV_MAKE_TYPE(wdepth, rated_cn); } char cvt[40]; char cvt1[40]; const char* convertToWT1 = ocl::convertTypeStr(depth, wdepth, cn, cvt); const char* convertToWT = ocl::convertTypeStr(depth, wdepth, rated_cn, cvt1); ocl::Kernel k("matchTemplate_Naive_CCORR", ocl::imgproc::match_template_oclsrc, format("-D CCORR -D T=%s -D T1=%s -D WT=%s -D WT1=%s -D convertToWT=%s -D convertToWT1=%s -D cn=%d -D PIX_PER_WI_X=%d", ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(wtype1), ocl::typeToStr(wtype), convertToWT, convertToWT1, cn, pxPerWIx)); if (k.empty()) return false; UMat image = _image.getUMat(), templ = _templ.getUMat(); _result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32FC1); UMat result = _result.getUMat(); k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)); size_t globalsize[2] = { (result.cols+pxPerWIx-1)/pxPerWIx, result.rows}; return k.run(2, globalsize, NULL, false); }
TensorWrapper::operator cv::Mat() { if (this->tensorPtr == nullptr) { return cv::Mat(); } THByteTensor *tensorPtr = static_cast<THByteTensor *>(this->tensorPtr); int numberOfDims = tensorPtr->nDimension; // THTensor stores its dimensions sizes under long *. // In a constructor for cv::Mat, we need const int *. // We can't guarantee int and long to be equal. // So we somehow need to static_cast THTensor sizes. // TODO: we should somehow get rid of array allocation std::array<int, 3> size; std::copy(tensorPtr->size, tensorPtr->size + tensorPtr->nDimension, size.begin()); // Same thing for stride values. std::array<size_t, 3> stride; std::copy(tensorPtr->stride, tensorPtr->stride + tensorPtr->nDimension, stride.begin()); int depth = this->typeCode; // Determine the number of channels. int numChannels; // cv::Mat() takes stride values in bytes, so we have to multiply by the element size: size_t sizeMultiplier = cv::getElemSize(depth); if (tensorPtr->nDimension <= 2) { // If such tensor is passed, assume that it is single-channel: numChannels = 1; } else { // Otherwise depend on the 3rd dimension: numChannels = tensorPtr->size[2]; numberOfDims = 2; } std::for_each(stride.begin(), stride.end(), [sizeMultiplier] (size_t & x) { x *= sizeMultiplier; }); return cv::Mat( numberOfDims, size.data(), CV_MAKE_TYPE(depth, numChannels), tensorPtr->storage->data, stride.data() ); }
vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end) { vector<MatType> v; v.reserve((depth_end - depth_start + 1) * (cn_end - cn_start + 1)); for (int depth = depth_start; depth <= depth_end; ++depth) { for (int cn = cn_start; cn <= cn_end; ++cn) { v.push_back(MatType(CV_MAKE_TYPE(depth, cn))); } } return v; }
/*! This function implements simple dct-based image denoising, * link: http://www.ipol.im/pub/art/2011/ys-dct/ * * \param src : source image (rgb, or gray) * \param dst : destination image * \param sigma : expected noise standard deviation * \param psize : size of block side where dct is computed */ void dctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize) { CV_Assert( src.channels() == 3 || src.channels() == 1 ); int xtype = CV_MAKE_TYPE( CV_32F, src.channels() ); Mat img( src.size(), xtype ); src.convertTo(img, xtype); if ( img.type() == CV_32FC3 ) rgbDctDenoising( img, img, sigma, psize ); else if ( img.type() == CV_32FC1 ) grayDctDenoising( img, img, sigma, psize ); else CV_Error_( CV_StsNotImplemented, ("Unsupported source image format (=%d)", img.type()) ); img.convertTo( dst, src.type() ); }
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); }
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] = { static_cast<size_t>(dst.cols * cn / kercn), static_cast<size_t>(dst.rows) }; globalsize[1] = (globalsize[1] + stride_size - 1) / stride_size; return k.run(2, globalsize, NULL, false); }
void rgbDctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize) { CV_Assert( src.type() == CV_MAKE_TYPE(CV_32F, 3) ); cv::Matx33f mt(cvInvSqrt(3.0f), cvInvSqrt(3.0f), cvInvSqrt(3.0f), cvInvSqrt(2.0f), 0.0f, -cvInvSqrt(2.0f), cvInvSqrt(6.0f), -2.0f*cvInvSqrt(6.0f), cvInvSqrt(6.0f)); cv::transform(src, dst, mt); std::vector <Mat> mv; split(dst, mv); for (size_t i = 0; i < mv.size(); ++i) grayDctDenoising(mv[i], mv[i], sigma, psize); merge(mv, dst); cv::transform( dst, dst, mt.inv() ); }
static bool matchTemplateNaive_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result) { int type = _image.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); int wdepth = CV_32F, wtype = CV_MAKE_TYPE(wdepth, cn); char cvt[40]; ocl::Kernel k("matchTemplate_Naive_SQDIFF", ocl::imgproc::match_template_oclsrc, format("-D SQDIFF -D T=%s -D T1=%s -D WT=%s -D convertToWT=%s -D cn=%d", ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(wtype), ocl::convertTypeStr(depth, wdepth, cn, cvt), cn)); if (k.empty()) return false; UMat image = _image.getUMat(), templ = _templ.getUMat(); _result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F); UMat result = _result.getUMat(); k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)); size_t globalsize[2] = { result.cols, result.rows }; return k.run(2, globalsize, NULL, false); }
void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst, float h, float hForColorComponents, int templateWindowSize, int searchWindowSize) { int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); if (type != CV_8UC3 && type != CV_8UC4) { CV_Error(Error::StsBadArg, "Type of input image should be CV_8UC3!"); return; } CV_OCL_RUN(_src.dims() <= 2 && (_dst.isUMat() || _src.isUMat()), ocl_fastNlMeansDenoisingColored(_src, _dst, h, hForColorComponents, templateWindowSize, searchWindowSize)) Mat src = _src.getMat(); _dst.create(src.size(), type); Mat dst = _dst.getMat(); Mat src_lab; cvtColor(src, src_lab, COLOR_LBGR2Lab); Mat l(src.size(), CV_8U); Mat ab(src.size(), CV_8UC2); Mat l_ab[] = { l, ab }; int from_to[] = { 0,0, 1,1, 2,2 }; mixChannels(&src_lab, 1, l_ab, 2, from_to, 3); fastNlMeansDenoising(l, l, h, templateWindowSize, searchWindowSize); fastNlMeansDenoising(ab, ab, hForColorComponents, templateWindowSize, searchWindowSize); Mat l_ab_denoised[] = { l, ab }; Mat dst_lab(src.size(), CV_MAKE_TYPE(depth, 3)); mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3); cvtColor(dst_lab, dst, COLOR_Lab2LBGR, cn); }
cuda::GpuMat TensorWrapper::toGpuMat(int depth) { if (this->tensorPtr == nullptr or this->tensorPtr->nDimension == 0) { return cuda::GpuMat(); } THCudaTensor *tensorPtr = reinterpret_cast<THCudaTensor *>(this->tensorPtr); assert(tensorPtr->nDimension <= 3); int numChannels = 1; if (tensorPtr->nDimension == 3) { numChannels = tensorPtr->size[2]; } return cuda::GpuMat( tensorPtr->size[0], tensorPtr->size[1], (depth == -1 ? CV_32FC(numChannels) : CV_MAKE_TYPE(depth, numChannels)), tensorPtr->storage->data + tensorPtr->storageOffset * cv::getElemSize(CV_32F), tensorPtr->stride[0] * sizeof(float) ); }
bool TextureUpdate::getImageFormat(const Image::ImageFormatProperties& fmtSrc, Image::ImageFormatProperties& fmtDst, bool use_gpu, int& umatConvertCode, GLenum& glFormat, GLenum& glDatatype) { bool ret = true; // determine datatype switch(fmtSrc.depth) { case CV_8U: glDatatype = GL_UNSIGNED_BYTE; break; case CV_16U: glDatatype = GL_UNSIGNED_SHORT; break; case CV_32F: glDatatype = GL_FLOAT; break; case CV_64F: glDatatype = GL_DOUBLE; break; default: // assume unsigned byte glDatatype = GL_UNSIGNED_BYTE; // Log Error ? ret = false; break; } // determine image properties switch (fmtSrc.imageFormat) { case Image::LUMINANCE: glFormat = GL_LUMINANCE; fmtDst.channels = 1; break; case Image::RGB: glFormat = use_gpu ? GL_RGBA : GL_RGB; fmtDst.channels = use_gpu ? 4 : 3; fmtDst.imageFormat = use_gpu ? Image::RGBA : Image::RGB; umatConvertCode = cv::COLOR_RGB2RGBA; break; #ifndef GL_BGR_EXT case Image::BGR: fmtDst.channels = use_gpu ? 4 : 3; glFormat = image_isOnGPU ? GL_RGBA : GL_RGB; fmtDst.imageFormat = use_gpu ? Image::RGBA : Image::BGR; umatConvertCode = cv::COLOR_BGR2RGBA; break; case Image::BGRA: fmt.channels = 4; glFormat = use_gpu ? GL_RGBA : GL_BGRA; fmtDst.imageFormat = use_gpu ? Image::RGBA : Image::BGRA; umatConvertCode = cv::COLOR_BGRA2RGBA; break; #else case Image::BGR: fmtDst.channels = use_gpu ? 4 : 3; glFormat = use_gpu ? GL_RGBA : GL_BGR_EXT; fmtDst.imageFormat = use_gpu ? Image::RGBA : Image::BGR; umatConvertCode = cv::COLOR_BGR2RGBA; break; case Image::BGRA: fmtDst.channels = 4; glFormat = use_gpu ? GL_RGBA : GL_BGRA_EXT; fmtDst.imageFormat = use_gpu ? Image::RGBA : Image::BGRA; umatConvertCode = cv::COLOR_BGRA2RGBA; break; #endif case Image::RGBA: fmtDst.channels = 4; glFormat = GL_RGBA; fmtDst.imageFormat = Image::RGBA; break; default: // Log Error ? ret = false; break; } // update dependent parameters fmtDst.bitsPerPixel = fmtSrc.bitsPerPixel / fmtSrc.channels * fmtDst.channels; fmtDst.matType = CV_MAKE_TYPE(fmtDst.depth, fmtDst.channels); return ret; }
static bool ocl_Laplacian5(InputArray _src, OutputArray _dst, const Mat & kd, const Mat & ks, double scale, double delta, int borderType, int depth, int ddepth) { const size_t tileSizeX = 16; const size_t tileSizeYmin = 8; const ocl::Device dev = ocl::Device::getDefault(); int stype = _src.type(); int sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype), esz = CV_ELEM_SIZE(stype); bool doubleSupport = dev.doubleFPConfig() > 0; if (!doubleSupport && (sdepth == CV_64F || ddepth == CV_64F)) return false; Mat kernelX = kd.reshape(1, 1); if (kernelX.cols % 2 != 1) return false; Mat kernelY = ks.reshape(1, 1); if (kernelY.cols % 2 != 1) return false; CV_Assert(kernelX.cols == kernelY.cols); size_t wgs = dev.maxWorkGroupSize(); size_t lmsz = dev.localMemSize(); size_t src_step = _src.step(), src_offset = _src.offset(); const size_t tileSizeYmax = wgs / tileSizeX; // workaround for Nvidia: 3 channel vector type takes 4*elem_size in local memory int loc_mem_cn = dev.vendorID() == ocl::Device::VENDOR_NVIDIA && cn == 3 ? 4 : cn; if (((src_offset % src_step) % esz == 0) && ( (borderType == BORDER_CONSTANT || borderType == BORDER_REPLICATE) || ((borderType == BORDER_REFLECT || borderType == BORDER_WRAP || borderType == BORDER_REFLECT_101) && (_src.cols() >= (int) (kernelX.cols + tileSizeX) && _src.rows() >= (int) (kernelY.cols + tileSizeYmax))) ) && (tileSizeX * tileSizeYmin <= wgs) && (LAPLACIAN_LOCAL_MEM(tileSizeX, tileSizeYmin, kernelX.cols, loc_mem_cn * 4) <= lmsz) ) { Size size = _src.size(), wholeSize; Point origin; int dtype = CV_MAKE_TYPE(ddepth, cn); int wdepth = CV_32F; size_t tileSizeY = tileSizeYmax; while ((tileSizeX * tileSizeY > wgs) || (LAPLACIAN_LOCAL_MEM(tileSizeX, tileSizeY, kernelX.cols, loc_mem_cn * 4) > lmsz)) { tileSizeY /= 2; } size_t lt2[2] = { tileSizeX, tileSizeY}; size_t gt2[2] = { lt2[0] * (1 + (size.width - 1) / lt2[0]), lt2[1] }; char cvt[2][40]; const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", "BORDER_WRAP", "BORDER_REFLECT_101" }; String opts = cv::format("-D BLK_X=%d -D BLK_Y=%d -D RADIUS=%d%s%s" " -D convertToWT=%s -D convertToDT=%s" " -D %s -D srcT1=%s -D dstT1=%s -D WT1=%s" " -D srcT=%s -D dstT=%s -D WT=%s" " -D CN=%d ", (int)lt2[0], (int)lt2[1], kernelX.cols / 2, ocl::kernelToStr(kernelX, wdepth, "KERNEL_MATRIX_X").c_str(), ocl::kernelToStr(kernelY, wdepth, "KERNEL_MATRIX_Y").c_str(), ocl::convertTypeStr(sdepth, wdepth, cn, cvt[0]), ocl::convertTypeStr(wdepth, ddepth, cn, cvt[1]), borderMap[borderType], ocl::typeToStr(sdepth), ocl::typeToStr(ddepth), ocl::typeToStr(wdepth), ocl::typeToStr(CV_MAKETYPE(sdepth, cn)), ocl::typeToStr(CV_MAKETYPE(ddepth, cn)), ocl::typeToStr(CV_MAKETYPE(wdepth, cn)), cn); ocl::Kernel k("laplacian", ocl::imgproc::laplacian5_oclsrc, opts); if (k.empty()) return false; UMat src = _src.getUMat(); _dst.create(size, dtype); UMat dst = _dst.getUMat(); int src_offset_x = static_cast<int>((src_offset % src_step) / esz); int src_offset_y = static_cast<int>(src_offset / src_step); src.locateROI(wholeSize, origin); k.args(ocl::KernelArg::PtrReadOnly(src), (int)src_step, src_offset_x, src_offset_y, wholeSize.height, wholeSize.width, ocl::KernelArg::WriteOnly(dst), static_cast<float>(scale), static_cast<float>(delta)); return k.run(2, gt2, lt2, false); } int iscale = cvRound(scale), idelta = cvRound(delta); bool floatCoeff = std::fabs(delta - idelta) > DBL_EPSILON || std::fabs(scale - iscale) > DBL_EPSILON; int wdepth = std::max(depth, floatCoeff ? CV_32F : CV_32S), kercn = 1; if (!doubleSupport && wdepth == CV_64F) return false; char cvt[2][40]; ocl::Kernel k("sumConvert", ocl::imgproc::laplacian5_oclsrc, format("-D ONLY_SUM_CONVERT " "-D srcT=%s -D WT=%s -D dstT=%s -D coeffT=%s -D wdepth=%d " "-D convertToWT=%s -D convertToDT=%s%s", ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)), ocl::typeToStr(CV_MAKE_TYPE(wdepth, kercn)), ocl::typeToStr(CV_MAKE_TYPE(ddepth, kercn)), ocl::typeToStr(wdepth), wdepth, ocl::convertTypeStr(depth, wdepth, kercn, cvt[0]), ocl::convertTypeStr(wdepth, ddepth, kercn, cvt[1]), doubleSupport ? " -D DOUBLE_SUPPORT" : "")); if (k.empty()) return false; UMat d2x, d2y; sepFilter2D(_src, d2x, depth, kd, ks, Point(-1, -1), 0, borderType); sepFilter2D(_src, d2y, depth, ks, kd, Point(-1, -1), 0, borderType); UMat dst = _dst.getUMat(); ocl::KernelArg d2xarg = ocl::KernelArg::ReadOnlyNoSize(d2x), d2yarg = ocl::KernelArg::ReadOnlyNoSize(d2y), dstarg = ocl::KernelArg::WriteOnly(dst, cn, kercn); if (wdepth >= CV_32F) k.args(d2xarg, d2yarg, dstarg, (float)scale, (float)delta); else k.args(d2xarg, d2yarg, dstarg, iscale, idelta); size_t globalsize[] = { dst.cols * cn / kercn, dst.rows }; return k.run(2, globalsize, NULL, false); }
static bool ocl_Canny(InputArray _src, const UMat& dx_, const UMat& dy_, OutputArray _dst, float low_thresh, float high_thresh, int aperture_size, bool L2gradient, int cn, const Size & size) { CV_INSTRUMENT_REGION_OPENCL() UMat map; const ocl::Device &dev = ocl::Device::getDefault(); int max_wg_size = (int)dev.maxWorkGroupSize(); int lSizeX = 32; int lSizeY = max_wg_size / 32; if (lSizeY == 0) { lSizeX = 16; lSizeY = max_wg_size / 16; } if (lSizeY == 0) { lSizeY = 1; } if (aperture_size == 7) { low_thresh = low_thresh / 16.0f; high_thresh = high_thresh / 16.0f; } if (L2gradient) { low_thresh = std::min(32767.0f, low_thresh); high_thresh = std::min(32767.0f, high_thresh); if (low_thresh > 0) low_thresh *= low_thresh; if (high_thresh > 0) high_thresh *= high_thresh; } int low = cvFloor(low_thresh), high = cvFloor(high_thresh); if (!useCustomDeriv && aperture_size == 3 && !_src.isSubmatrix()) { /* stage1_with_sobel: Sobel operator Calc magnitudes Non maxima suppression Double thresholding */ char cvt[40]; ocl::Kernel with_sobel("stage1_with_sobel", ocl::imgproc::canny_oclsrc, format("-D WITH_SOBEL -D cn=%d -D TYPE=%s -D convert_floatN=%s -D floatN=%s -D GRP_SIZEX=%d -D GRP_SIZEY=%d%s", cn, ocl::memopTypeToStr(_src.depth()), ocl::convertTypeStr(_src.depth(), CV_32F, cn, cvt), ocl::typeToStr(CV_MAKE_TYPE(CV_32F, cn)), lSizeX, lSizeY, L2gradient ? " -D L2GRAD" : "")); if (with_sobel.empty()) return false; UMat src = _src.getUMat(); map.create(size, CV_32S); with_sobel.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnlyNoSize(map), (float) low, (float) high); size_t globalsize[2] = { (size_t)size.width, (size_t)size.height }, localsize[2] = { (size_t)lSizeX, (size_t)lSizeY }; if (!with_sobel.run(2, globalsize, localsize, false)) return false; } else { /* stage1_without_sobel: Calc magnitudes Non maxima suppression Double thresholding */ double scale = 1.0; if (aperture_size == 7) { scale = 1 / 16.0; } UMat dx, dy; if (!useCustomDeriv) { Sobel(_src, dx, CV_16S, 1, 0, aperture_size, scale, 0, BORDER_REPLICATE); Sobel(_src, dy, CV_16S, 0, 1, aperture_size, scale, 0, BORDER_REPLICATE); } else { dx = dx_; dy = dy_; } ocl::Kernel without_sobel("stage1_without_sobel", ocl::imgproc::canny_oclsrc, format("-D WITHOUT_SOBEL -D cn=%d -D GRP_SIZEX=%d -D GRP_SIZEY=%d%s", cn, lSizeX, lSizeY, L2gradient ? " -D L2GRAD" : "")); if (without_sobel.empty()) return false; map.create(size, CV_32S); without_sobel.args(ocl::KernelArg::ReadOnlyNoSize(dx), ocl::KernelArg::ReadOnlyNoSize(dy), ocl::KernelArg::WriteOnly(map), low, high); size_t globalsize[2] = { (size_t)size.width, (size_t)size.height }, localsize[2] = { (size_t)lSizeX, (size_t)lSizeY }; if (!without_sobel.run(2, globalsize, localsize, false)) return false; } int PIX_PER_WI = 8; /* stage2: hysteresis (add weak edges if they are connected with strong edges) */ int sizey = lSizeY / PIX_PER_WI; if (sizey == 0) sizey = 1; size_t globalsize[2] = { (size_t)size.width, ((size_t)size.height + PIX_PER_WI - 1) / PIX_PER_WI }, localsize[2] = { (size_t)lSizeX, (size_t)sizey }; ocl::Kernel edgesHysteresis("stage2_hysteresis", ocl::imgproc::canny_oclsrc, format("-D STAGE2 -D PIX_PER_WI=%d -D LOCAL_X=%d -D LOCAL_Y=%d", PIX_PER_WI, lSizeX, sizey)); if (edgesHysteresis.empty()) return false; edgesHysteresis.args(ocl::KernelArg::ReadWrite(map)); if (!edgesHysteresis.run(2, globalsize, localsize, false)) return false; // get edges ocl::Kernel getEdgesKernel("getEdges", ocl::imgproc::canny_oclsrc, format("-D GET_EDGES -D PIX_PER_WI=%d", PIX_PER_WI)); if (getEdgesKernel.empty()) return false; _dst.create(size, CV_8UC1); UMat dst = _dst.getUMat(); getEdgesKernel.args(ocl::KernelArg::ReadOnly(map), ocl::KernelArg::WriteOnlyNoSize(dst)); return getEdgesKernel.run(2, globalsize, NULL, false); }
inline size_t oclMat::elemSize() const { return CV_ELEM_SIZE((CV_MAKE_TYPE(type(), oclchannels()))); }
inline int oclMat::ocltype() const { return CV_MAKE_TYPE(depth(), oclchannels()); }
/* Convert QImage to cv::Mat */ cv::Mat image2Mat(const QImage &img, int requiredMatType, MatColorOrder requriedOrder) { int targetDepth = CV_MAT_DEPTH(requiredMatType); int targetChannels = CV_MAT_CN(requiredMatType); Q_ASSERT(targetChannels==CV_CN_MAX || targetChannels==1 || targetChannels==3 || targetChannels==4); Q_ASSERT(targetDepth==CV_8U || targetDepth==CV_16U || targetDepth==CV_32F); if (img.isNull()) return cv::Mat(); //Find the closest image format that can be used in image2Mat_shared() QImage::Format format = findClosestFormat(img.format()); QImage image = (format==img.format()) ? img : img.convertToFormat(format); MatColorOrder srcOrder; cv::Mat mat0 = image2Mat_shared(image, &srcOrder); //Adjust mat channells if needed. cv::Mat mat_adjustCn; const float maxAlpha = targetDepth==CV_8U ? 255 : (targetDepth==CV_16U ? 65535 : 1.0); if (targetChannels == CV_CN_MAX) targetChannels = mat0.channels(); switch(targetChannels) { case 1: if (mat0.channels() == 3) { cv::cvtColor(mat0, mat_adjustCn, CV_RGB2GRAY); } else if (mat0.channels() == 4) { if (srcOrder == MCO_BGRA) cv::cvtColor(mat0, mat_adjustCn, CV_BGRA2GRAY); else if (srcOrder == MCO_RGBA) cv::cvtColor(mat0, mat_adjustCn, CV_RGBA2GRAY); else//MCO_ARGB cv::cvtColor(argb2bgra(mat0), mat_adjustCn, CV_BGRA2GRAY); } break; case 3: if (mat0.channels() == 1) { cv::cvtColor(mat0, mat_adjustCn, requriedOrder == MCO_BGR ? CV_GRAY2BGR : CV_GRAY2RGB); } else if (mat0.channels() == 3) { if (requriedOrder != srcOrder) cv::cvtColor(mat0, mat_adjustCn, CV_RGB2BGR); } else if (mat0.channels() == 4) { if (srcOrder == MCO_ARGB) { mat_adjustCn = cv::Mat(mat0.rows, mat0.cols, CV_MAKE_TYPE(mat0.type(), 3)); int ARGB2RGB[] = {1,0, 2,1, 3,2}; int ARGB2BGR[] = {1,2, 2,1, 3,0}; cv::mixChannels(&mat0, 1, &mat_adjustCn, 1, requriedOrder == MCO_BGR ? ARGB2BGR : ARGB2RGB, 3); } else if (srcOrder == MCO_BGRA) { cv::cvtColor(mat0, mat_adjustCn, requriedOrder == MCO_BGR ? CV_BGRA2BGR : CV_BGRA2RGB); } else {//RGBA cv::cvtColor(mat0, mat_adjustCn, requriedOrder == MCO_BGR ? CV_RGBA2BGR : CV_RGBA2RGB); } } break; case 4: if (mat0.channels() == 1) { if (requriedOrder == MCO_ARGB) { cv::Mat alphaMat(mat0.rows, mat0.cols, CV_MAKE_TYPE(mat0.type(), 1), cv::Scalar(maxAlpha)); mat_adjustCn = cv::Mat(mat0.rows, mat0.cols, CV_MAKE_TYPE(mat0.type(), 4)); cv::Mat in[] = {alphaMat, mat0}; int from_to[] = {0,0, 1,1, 1,2, 1,3}; cv::mixChannels(in, 2, &mat_adjustCn, 1, from_to, 4); } else if (requriedOrder == MCO_RGBA) { cv::cvtColor(mat0, mat_adjustCn, CV_GRAY2RGBA); } else {//MCO_BGRA cv::cvtColor(mat0, mat_adjustCn, CV_GRAY2BGRA); } } else if (mat0.channels() == 3) { if (requriedOrder == MCO_ARGB) { cv::Mat alphaMat(mat0.rows, mat0.cols, CV_MAKE_TYPE(mat0.type(), 1), cv::Scalar(maxAlpha)); mat_adjustCn = cv::Mat(mat0.rows, mat0.cols, CV_MAKE_TYPE(mat0.type(), 4)); cv::Mat in[] = {alphaMat, mat0}; int from_to[] = {0,0, 1,1, 2,2, 3,3}; cv::mixChannels(in, 2, &mat_adjustCn, 1, from_to, 4); } else if (requriedOrder == MCO_RGBA) { cv::cvtColor(mat0, mat_adjustCn, CV_RGB2RGBA); } else {//MCO_BGRA cv::cvtColor(mat0, mat_adjustCn, CV_RGB2BGRA); } } else if (mat0.channels() == 4) { if (srcOrder != requriedOrder) mat_adjustCn = adjustChannelsOrder(mat0, srcOrder, requriedOrder); } break; default: break; } //Adjust depth if needed. if (targetDepth == CV_8U) return mat_adjustCn.empty() ? mat0.clone() : mat_adjustCn; if (mat_adjustCn.empty()) mat_adjustCn = mat0; cv::Mat mat_adjustDepth; mat_adjustCn.convertTo(mat_adjustDepth, CV_MAKE_TYPE(targetDepth, mat_adjustCn.channels()), targetDepth == CV_16U ? 255.0 : 1/255.0); return mat_adjustDepth; }