void RhoanaBlocksGainCompensator::apply(int index, Point /*corner*/, InputOutputArray _image, InputArray /*mask*/) { CV_INSTRUMENT_REGION() ///CV_Assert(image.type() == CV_8UC3); CV_Assert(_image.type() == CV_8UC1); UMat u_gain_map; if (gain_maps_[index].size() == _image.size()) u_gain_map = gain_maps_[index]; else resize(gain_maps_[index], u_gain_map, _image.size(), 0, 0, INTER_LINEAR); Mat_<float> gain_map = u_gain_map.getMat(ACCESS_READ); Mat image = _image.getMat(); for (int y = 0; y < image.rows; ++y) { const float* gain_row = gain_map.ptr<float>(y); ///Point3_<uchar>* row = image.ptr<Point3_<uchar> >(y); uchar* row = image.ptr<uchar>(y); for (int x = 0; x < image.cols; ++x) { ///row[x].x = saturate_cast<uchar>(row[x].x * gain_row[x]); ///row[x].y = saturate_cast<uchar>(row[x].y * gain_row[x]); ///row[x].z = saturate_cast<uchar>(row[x].z * gain_row[x]); row[x] = saturate_cast<uchar>(row[x] * gain_row[x]); } } }
void fillOcclusion(InputOutputArray src_, int invalidvalue, int disp_or_depth) { CV_Assert(src_.channels() == 1); Mat src = src_.getMat(); if (disp_or_depth == FILL_DEPTH) { if (src.depth() == CV_8U) { fillOcclusionInv_<uchar>(src, (uchar)invalidvalue, 0); } else if (src.depth() == CV_16S) { fillOcclusionInv_<short>(src, (short)invalidvalue, 0); } else if (src.depth() == CV_16U) { fillOcclusionInv_<ushort>(src, (ushort)invalidvalue, 0); } else if (src.depth() == CV_32S) { fillOcclusionInv_<int>(src, (int)invalidvalue, 0); } else if (src.depth() == CV_32F) { fillOcclusionInv_<float>(src, (float)invalidvalue, 0.f); } else if (src.depth() == CV_64F) { fillOcclusionInv_ <double> (src, (double)invalidvalue, 0.f); } } else { if (src.depth() == CV_8U) { fillOcclusion_<uchar>(src, (uchar)invalidvalue, 255); } else if (src.depth() == CV_16S) { fillOcclusion_<short>(src, (short)invalidvalue, SHRT_MAX); } else if (src.depth() == CV_16U) { fillOcclusion_<ushort>(src, (ushort)invalidvalue, USHRT_MAX); } else if (src.depth() == CV_32S) { fillOcclusion_<int>(src, (int)invalidvalue, INT_MAX); } else if (src.depth() == CV_32F) { fillOcclusion_<float>(src, (float)invalidvalue, FLT_MAX); } else if (src.depth() == CV_64F) { fillOcclusion_<double>(src, (double)invalidvalue, DBL_MAX); } } }
// Generates the images needed for shadowMasks computation void GrayCodePattern_Impl::getImagesForShadowMasks( InputOutputArray blackImage, InputOutputArray whiteImage ) const { Mat& blackImage_ = *( Mat* ) blackImage.getObj(); Mat& whiteImage_ = *( Mat* ) whiteImage.getObj(); blackImage_ = Mat( params.height, params.width, CV_8U, Scalar( 0 ) ); whiteImage_ = Mat( params.height, params.width, CV_8U, Scalar( 255 ) ); }
void Blender::blend(InputOutputArray dst, InputOutputArray dst_mask) { UMat mask; compare(dst_mask_, 0, mask, CMP_EQ); dst_.setTo(Scalar::all(0), mask); dst.assign(dst_); dst_mask.assign(dst_mask_); dst_.release(); dst_mask_.release(); }
double mycalibrateCamera( InputArrayOfArrays _objectPoints, InputArrayOfArrays _imagePoints, Size imageSize, InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs, OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags, TermCriteria criteria ) { int rtype = CV_64F; Mat cameraMatrix = _cameraMatrix.getMat(); cameraMatrix = prepareCameraMatrix(cameraMatrix, rtype); Mat distCoeffs = _distCoeffs.getMat(); distCoeffs = prepareDistCoeffs(distCoeffs, rtype); if( !(flags & CALIB_RATIONAL_MODEL) ) distCoeffs = distCoeffs.rows == 1 ? distCoeffs.colRange(0, 5) : distCoeffs.rowRange(0, 5); int i; size_t nimages = _objectPoints.total(); CV_Assert( nimages > 0 ); Mat objPt, imgPt, npoints, rvecM((int)nimages, 3, CV_64FC1), tvecM((int)nimages, 3, CV_64FC1); collectCalibrationData( _objectPoints, _imagePoints, noArray(), objPt, imgPt, 0, npoints ); CvMat c_objPt = objPt, c_imgPt = imgPt, c_npoints = npoints; CvMat c_cameraMatrix = cameraMatrix, c_distCoeffs = distCoeffs; CvMat c_rvecM = rvecM, c_tvecM = tvecM; double reprojErr = cvCalibrateCamera2(&c_objPt, &c_imgPt, &c_npoints, imageSize, &c_cameraMatrix, &c_distCoeffs, &c_rvecM, &c_tvecM, flags, criteria ); bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed(); if( rvecs_needed ) _rvecs.create((int)nimages, 1, CV_64FC3); if( tvecs_needed ) _tvecs.create((int)nimages, 1, CV_64FC3); for( i = 0; i < (int)nimages; i++ ) { if( rvecs_needed ) { _rvecs.create(3, 1, CV_64F, i, true); Mat rv = _rvecs.getMat(i); memcpy(rv.data, rvecM.ptr<double>(i), 3*sizeof(double)); } if( tvecs_needed ) { _tvecs.create(3, 1, CV_64F, i, true); Mat tv = _tvecs.getMat(i); memcpy(tv.data, tvecM.ptr<double>(i), 3*sizeof(double)); } } cameraMatrix.copyTo(_cameraMatrix); distCoeffs.copyTo(_distCoeffs); return reprojErr; }
int cv::floodFill( InputOutputArray _image, InputOutputArray _mask, Point seedPoint, Scalar newVal, Rect* rect, Scalar loDiff, Scalar upDiff, int flags ) { CvConnectedComp ccomp; CvMat c_image = _image.getMat(), c_mask = _mask.getMat(); cvFloodFill(&c_image, seedPoint, newVal, loDiff, upDiff, &ccomp, flags, c_mask.data.ptr ? &c_mask : 0); if( rect ) *rect = ccomp.rect; return cvRound(ccomp.area); }
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); }
void reconstruct_(const T &input, OutputArray Rs, OutputArray Ts, InputOutputArray K, OutputArray points3d, const bool refinement=true) { // Initial reconstruction const int keyframe1 = 1, keyframe2 = 2; const int select_keyframes = 1; // enable automatic keyframes selection const int verbosity_level = -1; // mute libmv logs // Refinement parameters const int refine_intrinsics = ( !refinement ) ? 0 : SFM_REFINE_FOCAL_LENGTH | SFM_REFINE_PRINCIPAL_POINT | SFM_REFINE_RADIAL_DISTORTION_K1 | SFM_REFINE_RADIAL_DISTORTION_K2; // Camera data Matx33d Ka = K.getMat(); const double focal_length = Ka(0,0); const double principal_x = Ka(0,2), principal_y = Ka(1,2), k1 = 0, k2 = 0, k3 = 0; // Set reconstruction options libmv_ReconstructionOptions reconstruction_options(keyframe1, keyframe2, refine_intrinsics, select_keyframes, verbosity_level); libmv_CameraIntrinsicsOptions camera_instrinsic_options = libmv_CameraIntrinsicsOptions(SFM_DISTORTION_MODEL_POLYNOMIAL, focal_length, principal_x, principal_y, k1, k2, k3); //-- Instantiate reconstruction pipeline Ptr<BaseSFM> reconstruction = SFMLibmvEuclideanReconstruction::create(camera_instrinsic_options, reconstruction_options); //-- Run reconstruction pipeline reconstruction->run(input, K, Rs, Ts, points3d); }
void Utility::drawSegmentBorder(InputOutputArray imgInputOutput, Mat_<int> segment, Scalar color /*= Scalar(255, 255, 255)*/) { Mat img = imgInputOutput.getMat(); Mat_<uchar> mask(img.rows, img.cols); // ��־SuperPixel�߽�ľ��� mask.setTo(0); int rows = img.rows; int cols = img.cols; for (int i = 1; i < rows; i++) { int* pCurrentPoint = segment.ptr<int>(i)+1; // ָ��ǰ�� int* pUpperPoint = segment.ptr<int>(i-1)+1; // ָ������ĵ� for (int j = 1; j < cols; j++) { int cPoint = *pCurrentPoint; // ��ǰ���SuperPixelID int lPoint = *(pCurrentPoint-1); // ��ߵ��SuperPixelID int uPoint = *pUpperPoint; // ������SuperPixelID if (cPoint != lPoint || cPoint != uPoint) { mask(i, j) = 1; } pCurrentPoint++; pUpperPoint++; } } add(img, color, img, mask); }
void cv::gpu::equalizeHist(InputArray _src, OutputArray _dst, InputOutputArray _buf, Stream& _stream) { GpuMat src = _src.getGpuMat(); CV_Assert( src.type() == CV_8UC1 ); _dst.create(src.size(), src.type()); GpuMat dst = _dst.getGpuMat(); int intBufSize; nppSafeCall( nppsIntegralGetBufferSize_32s(256, &intBufSize) ); size_t bufSize = intBufSize + 2 * 256 * sizeof(int); ensureSizeIsEnough(1, static_cast<int>(bufSize), CV_8UC1, _buf); GpuMat buf = _buf.getGpuMat(); GpuMat hist(1, 256, CV_32SC1, buf.data); GpuMat lut(1, 256, CV_32SC1, buf.data + 256 * sizeof(int)); GpuMat intBuf(1, intBufSize, CV_8UC1, buf.data + 2 * 256 * sizeof(int)); gpu::calcHist(src, hist, _stream); cudaStream_t stream = StreamAccessor::getStream(_stream); NppStreamHandler h(stream); nppSafeCall( nppsIntegral_32s(hist.ptr<Npp32s>(), lut.ptr<Npp32s>(), 256, intBuf.ptr<Npp8u>()) ); hist::equalizeHist(src, dst, lut.ptr<int>(), stream); }
void cv::updateMotionHistory( InputArray _silhouette, InputOutputArray _mhi, double timestamp, double duration ) { Mat silhouette = _silhouette.getMat(); CvMat c_silhouette = silhouette, c_mhi = _mhi.getMat(); cvUpdateMotionHistory( &c_silhouette, &c_mhi, timestamp, duration ); }
void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage, const Scalar& _color, DrawMatchesFlags flags ) { CV_INSTRUMENT_REGION(); if( !(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) ) { if (image.type() == CV_8UC3 || image.type() == CV_8UC4) { image.copyTo(outImage); } else if( image.type() == CV_8UC1 ) { cvtColor( image, outImage, COLOR_GRAY2BGR ); } else { CV_Error( Error::StsBadArg, "Incorrect type of input image: " + typeToString(image.type()) ); } } RNG& rng=theRNG(); bool isRandColor = _color == Scalar::all(-1); CV_Assert( !outImage.empty() ); std::vector<KeyPoint>::const_iterator it = keypoints.begin(), end = keypoints.end(); for( ; it != end; ++it ) { Scalar color = isRandColor ? Scalar( rng(256), rng(256), rng(256), 255 ) : _color; _drawKeypoint( outImage, *it, color, flags ); } }
void cv::insertChannel(InputArray _src, InputOutputArray _dst, int coi) { Mat src = _src.getMat(), dst = _dst.getMat(); CV_Assert( src.size == dst.size && src.depth() == dst.depth() ); CV_Assert( 0 <= coi && coi < dst.channels() && src.channels() == 1 ); int ch[] = { 0, coi }; mixChannels(&src, 1, &dst, 1, ch, 1); }
double ConjGradSolverImpl::minimize(InputOutputArray x){ CV_Assert(_Function.empty()==false); dprintf(("termcrit:\n\ttype: %d\n\tmaxCount: %d\n\tEPS: %g\n",_termcrit.type,_termcrit.maxCount,_termcrit.epsilon)); Mat x_mat=x.getMat(); CV_Assert(MIN(x_mat.rows,x_mat.cols)==1); int ndim=MAX(x_mat.rows,x_mat.cols); CV_Assert(x_mat.type()==CV_64FC1); if(d.cols!=ndim){ d.create(1,ndim); r.create(1,ndim); r_old.create(1,ndim); minimizeOnTheLine_buf1.create(1,ndim); minimizeOnTheLine_buf2.create(1,ndim); } Mat_<double> proxy_x; if(x_mat.rows>1){ buf_x.create(1,ndim); Mat_<double> proxy(ndim,1,buf_x.ptr<double>()); x_mat.copyTo(proxy); proxy_x=buf_x; }else{ proxy_x=x_mat; } _Function->getGradient(proxy_x.ptr<double>(),d.ptr<double>()); d*=-1.0; d.copyTo(r); //here everything goes. check that everything is setted properly dprintf(("proxy_x\n"));print_matrix(proxy_x); dprintf(("d first time\n"));print_matrix(d); dprintf(("r\n"));print_matrix(r); for(int count=0;count<_termcrit.maxCount;count++){ minimizeOnTheLine(_Function,proxy_x,d,minimizeOnTheLine_buf1,minimizeOnTheLine_buf2); r.copyTo(r_old); _Function->getGradient(proxy_x.ptr<double>(),r.ptr<double>()); r*=-1.0; double r_norm_sq=norm(r); if(_termcrit.type==(TermCriteria::MAX_ITER+TermCriteria::EPS) && r_norm_sq<_termcrit.epsilon){ break; } r_norm_sq=r_norm_sq*r_norm_sq; double beta=MAX(0.0,(r_norm_sq-r.dot(r_old))/r_norm_sq); d=r+beta*d; } if(x_mat.rows>1){ Mat(ndim, 1, CV_64F, proxy_x.ptr<double>()).copyTo(x); } return _Function->calc(proxy_x.ptr<double>()); }
static void fftShift(InputOutputArray _out) { Mat out = _out.getMat(); if(out.rows == 1 && out.cols == 1) { // trivially shifted. return; } std::vector<Mat> planes; split(out, planes); int xMid = out.cols >> 1; int yMid = out.rows >> 1; bool is_1d = xMid == 0 || yMid == 0; if(is_1d) { xMid = xMid + yMid; for(size_t i = 0; i < planes.size(); i++) { Mat tmp; Mat half0(planes[i], Rect(0, 0, xMid, 1)); Mat half1(planes[i], Rect(xMid, 0, xMid, 1)); half0.copyTo(tmp); half1.copyTo(half0); tmp.copyTo(half1); } } else { for(size_t i = 0; i < planes.size(); i++) { // perform quadrant swaps... Mat tmp; Mat q0(planes[i], Rect(0, 0, xMid, yMid)); Mat q1(planes[i], Rect(xMid, 0, xMid, yMid)); Mat q2(planes[i], Rect(0, yMid, xMid, yMid)); Mat q3(planes[i], Rect(xMid, yMid, xMid, yMid)); q0.copyTo(tmp); q3.copyTo(q0); tmp.copyTo(q3); q1.copyTo(tmp); q2.copyTo(q1); tmp.copyTo(q2); } } merge(planes, out); }
void setDepthMaxValue(InputOutputArray src) { Mat s = src.getMat(); if (s.depth() == CV_8U)s.setTo(UCHAR_MAX); else if (s.depth() == CV_16U)s.setTo(USHRT_MAX); else if (s.depth() == CV_16S)s.setTo(SHRT_MAX); else if (s.depth() == CV_32S)s.setTo(INT_MAX); else if (s.depth() == CV_32F)s.setTo(FLT_MAX); else if (s.depth() == CV_64F)s.setTo(DBL_MAX); }
static inline void _drawMatch( InputOutputArray outImg, InputOutputArray outImg1, InputOutputArray outImg2 , const KeyPoint& kp1, const KeyPoint& kp2, const Scalar& matchColor, DrawMatchesFlags flags ) { RNG& rng = theRNG(); bool isRandMatchColor = matchColor == Scalar::all(-1); Scalar color = isRandMatchColor ? Scalar( rng(256), rng(256), rng(256), 255 ) : matchColor; _drawKeypoint( outImg1, kp1, color, flags ); _drawKeypoint( outImg2, kp2, color, flags ); Point2f pt1 = kp1.pt, pt2 = kp2.pt, dpt2 = Point2f( std::min(pt2.x+outImg1.size().width, float(outImg.size().width-1)), pt2.y ); line( outImg, Point(cvRound(pt1.x*draw_multiplier), cvRound(pt1.y*draw_multiplier)), Point(cvRound(dpt2.x*draw_multiplier), cvRound(dpt2.y*draw_multiplier)), color, 1, LINE_AA, draw_shift_bits ); }
void extractLibmvReconstructionData(InputOutputArray K, OutputArray Rs, OutputArray Ts, OutputArray points3d) { getCameras(Rs, Ts); getPoints(points3d); getIntrinsics().copyTo(K.getMat()); }
void reconstruct(const std::vector<cv::String> images, OutputArray Ps, OutputArray points3d, InputOutputArray K, bool is_projective) { const int nviews = static_cast<int>(images.size()); CV_Assert( nviews >= 2 ); Matx33d Ka = K.getMat(); const int depth = Mat(Ka).depth(); // Projective reconstruction if ( is_projective ) { std::vector<Mat> Rs, Ts; reconstruct(images, Rs, Ts, Ka, points3d, is_projective); // From Rs and Ts, extract Ps const int nviews_est = Rs.size(); Ps.create(nviews_est, 1, depth); Matx34d P; for (size_t i = 0; i < nviews_est; ++i) { projectionFromKRt(Ka, Rs[i], Vec3d(Ts[i]), P); Mat(P).copyTo(Ps.getMatRef(i)); } Mat(Ka).copyTo(K.getMat()); } // Affine reconstruction else { // TODO: implement me CV_Error(Error::StsNotImplemented, "Affine reconstruction not yet implemented"); } }
void DensePyrLkOptFlowEstimatorGpu::run( InputArray frame0, InputArray frame1, InputOutputArray flowX, InputOutputArray flowY, OutputArray errors) { frame0_.upload(frame0.getMat()); frame1_.upload(frame1.getMat()); optFlowEstimator_.winSize = winSize_; optFlowEstimator_.maxLevel = maxLevel_; if (errors.needed()) { optFlowEstimator_.dense(frame0_, frame1_, flowX_, flowY_, &errors_); errors_.download(errors.getMatRef()); } else optFlowEstimator_.dense(frame0_, frame1_, flowX_, flowY_); flowX_.download(flowX.getMatRef()); flowY_.download(flowY.getMatRef()); }
void removeRows(InputOutputArray _src, cv::Range range) { CV_Assert( range.start >= 0 && range.end < _src.getMat().rows ); Mat src = _src.getMat(); int type = src.type(); // if(src.data != dst.data || src.step != dst.step) // { for(int i = range.start; i <= range.end; ++i) { // cout << i << endl; removeRow(src, src, range.start); // cout << "src: " << endl << src << endl; } src.copyTo(_src); // } return; }
static void _prepareImgAndDrawKeypoints( InputArray img1, const std::vector<KeyPoint>& keypoints1, InputArray img2, const std::vector<KeyPoint>& keypoints2, InputOutputArray _outImg, Mat& outImg1, Mat& outImg2, const Scalar& singlePointColor, DrawMatchesFlags flags ) { Mat outImg; Size img1size = img1.size(), img2size = img2.size(); Size size( img1size.width + img2size.width, MAX(img1size.height, img2size.height) ); if( !!(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) ) { outImg = _outImg.getMat(); if( size.width > outImg.cols || size.height > outImg.rows ) CV_Error( Error::StsBadSize, "outImg has size less than need to draw img1 and img2 together" ); outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) ); outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) ); } else { const int cn1 = img1.channels(), cn2 = img2.channels(); const int out_cn = std::max(3, std::max(cn1, cn2)); _outImg.create(size, CV_MAKETYPE(img1.depth(), out_cn)); outImg = _outImg.getMat(); outImg = Scalar::all(0); outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) ); outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) ); _prepareImage(img1, outImg1); _prepareImage(img2, outImg2); } // draw keypoints if( !(flags & DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS) ) { Mat _outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) ); drawKeypoints( _outImg1, keypoints1, _outImg1, singlePointColor, flags | DrawMatchesFlags::DRAW_OVER_OUTIMG ); Mat _outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) ); drawKeypoints( _outImg2, keypoints2, _outImg2, singlePointColor, flags | DrawMatchesFlags::DRAW_OVER_OUTIMG ); } }
void cv::cornerSubPix( InputArray _image, InputOutputArray _corners, Size winSize, Size zeroZone, TermCriteria criteria ) { Mat corners = _corners.getMat(); int ncorners = corners.checkVector(2); CV_Assert( ncorners >= 0 && corners.depth() == CV_32F ); Mat image = _image.getMat(); CvMat c_image = image; cvFindCornerSubPix( &c_image, (CvPoint2D32f*)corners.data, ncorners, winSize, zeroZone, criteria ); }
static bool ocl_MultiBandBlender_feed(InputArray _src, InputArray _weight, InputOutputArray _dst, InputOutputArray _dst_weight) { String buildOptions = "-D DEFINE_feed"; ocl::buildOptionsAddMatrixDescription(buildOptions, "src", _src); ocl::buildOptionsAddMatrixDescription(buildOptions, "weight", _weight); ocl::buildOptionsAddMatrixDescription(buildOptions, "dst", _dst); ocl::buildOptionsAddMatrixDescription(buildOptions, "dstWeight", _dst_weight); ocl::Kernel k("feed", ocl::stitching::multibandblend_oclsrc, buildOptions); if (k.empty()) return false; UMat src = _src.getUMat(); k.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::ReadOnly(_weight.getUMat()), ocl::KernelArg::ReadWrite(_dst.getUMat()), ocl::KernelArg::ReadWrite(_dst_weight.getUMat()) ); size_t globalsize[2] = {(size_t)src.cols, (size_t)src.rows }; return k.run(2, globalsize, NULL, false); }
static bool ocl_updateMotionHistory( InputArray _silhouette, InputOutputArray _mhi, float timestamp, float delbound ) { ocl::Kernel k("updateMotionHistory", ocl::video::updatemotionhistory_oclsrc); if (k.empty()) return false; UMat silh = _silhouette.getUMat(), mhi = _mhi.getUMat(); k.args(ocl::KernelArg::ReadOnlyNoSize(silh), ocl::KernelArg::ReadWrite(mhi), timestamp, delbound); size_t globalsize[2] = { silh.cols, silh.rows }; return k.run(2, globalsize, NULL, false); }
void randu(InputOutputArray dst) { if (dst.depth() == CV_8U) cv::randu(dst, 0, 256); else if (dst.depth() == CV_8S) cv::randu(dst, -128, 128); else if (dst.depth() == CV_16U) cv::randu(dst, 0, 1024); else if (dst.depth() == CV_32F || dst.depth() == CV_64F) cv::randu(dst, -1.0, 1.0); else if (dst.depth() == CV_16S || dst.depth() == CV_32S) cv::randu(dst, -4096, 4096); else CV_Error(Error::StsUnsupportedFormat, "Unsupported format"); }
void SparsePyrLkOptFlowEstimatorGpu::run( InputArray frame0, InputArray frame1, InputArray points0, InputOutputArray points1, OutputArray status, OutputArray errors) { frame0_.upload(frame0.getMat()); frame1_.upload(frame1.getMat()); points0_.upload(points0.getMat()); if (errors.needed()) { run(frame0_, frame1_, points0_, points1_, status_, errors_); errors_.download(errors.getMatRef()); } else run(frame0_, frame1_, points0_, points1_, status_); points1_.download(points1.getMatRef()); status_.download(status.getMatRef()); }
void CustomPattern::drawOrientation(InputOutputArray image, InputArray tvec, InputArray rvec, InputArray cameraMatrix, InputArray distCoeffs, double axis_length, double axis_width) { Point3f ptrCtr3d = Point3f((img_roi.cols * pxSize)/2, (img_roi.rows * pxSize)/2, 0); vector<Point3f> axis(4); axis[0] = ptrCtr3d; axis[1] = Point3f(axis_length * pxSize, 0, 0) + ptrCtr3d; axis[2] = Point3f(0, axis_length * pxSize, 0) + ptrCtr3d; axis[3] = Point3f(0, 0, -axis_length * pxSize) + ptrCtr3d; vector<Point2f> proj_axis; projectPoints(axis, rvec, tvec, cameraMatrix, distCoeffs, proj_axis); Mat img = image.getMat(); line(img, proj_axis[0], proj_axis[1], CV_RGB(255, 0, 0), axis_width); line(img, proj_axis[0], proj_axis[2], CV_RGB(0, 255, 0), axis_width); line(img, proj_axis[0], proj_axis[3], CV_RGB(0, 0, 255), axis_width); img.copyTo(image); }
void CustomPattern::drawOrientation(InputOutputArray image, InputArray tvec, InputArray rvec, InputArray cameraMatrix, InputArray distCoeffs, double axis_length, int axis_width) { Point3f ptrCtr3d = Point3f(float((img_roi.cols * pxSize)/2.0), float((img_roi.rows * pxSize)/2.0), 0); vector<Point3f> axis(4); float alen = float(axis_length * pxSize); axis[0] = ptrCtr3d; axis[1] = Point3f(alen, 0, 0) + ptrCtr3d; axis[2] = Point3f(0, alen, 0) + ptrCtr3d; axis[3] = Point3f(0, 0, -alen) + ptrCtr3d; vector<Point2f> proj_axis; projectPoints(axis, rvec, tvec, cameraMatrix, distCoeffs, proj_axis); Mat img = image.getMat(); line(img, proj_axis[0], proj_axis[1], Scalar(0, 0, 255), axis_width); // red line(img, proj_axis[0], proj_axis[2], Scalar(0, 255, 0), axis_width); // green line(img, proj_axis[0], proj_axis[3], Scalar(255, 0, 0), axis_width); // blue img.copyTo(image); }
/* * Functions to draw keypoints and matches. */ static inline void _drawKeypoint( InputOutputArray img, const KeyPoint& p, const Scalar& color, DrawMatchesFlags flags ) { CV_Assert( !img.empty() ); Point center( cvRound(p.pt.x * draw_multiplier), cvRound(p.pt.y * draw_multiplier) ); if( !!(flags & DrawMatchesFlags::DRAW_RICH_KEYPOINTS) ) { int radius = cvRound(p.size/2 * draw_multiplier); // KeyPoint::size is a diameter // draw the circles around keypoints with the keypoints size circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits ); // draw orientation of the keypoint, if it is applicable if( p.angle != -1 ) { float srcAngleRad = p.angle*(float)CV_PI/180.f; Point orient( cvRound(cos(srcAngleRad)*radius ), cvRound(sin(srcAngleRad)*radius ) ); line( img, center, center+orient, color, 1, LINE_AA, draw_shift_bits ); } #if 0 else { // draw center with R=1 int radius = 1 * draw_multiplier; circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits ); } #endif } else { // draw center with R=3 int radius = 3 * draw_multiplier; circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits ); } }