void FastBGSubtract() //Silhouette_Final에 바로 실루엣 데이터를 써넣는다. { static UMat CL_Background_MOG; static Ptr<BackgroundSubtractor> pMOG2; //MOG2 Background subtractor if (pMOG2 == NULL) pMOG2 = createBackgroundSubtractorMOG2(200, 16.0, true); pMOG2->apply(CL_Current_Frame, CL_Background_MOG); CL_Background_MOG.copyTo(Silhouette_Final); for (int x = 0; x < Cols; x++) { for (int y = 0; y < Rows; y++) { if (Silhouette_Final.data[y*Cols + x] == 127) Silhouette_Final.data[y*Cols + x] = 0; } } }
// draw both pure-C++ and ocl square results onto a single image static UMat drawSquaresBoth( const UMat& image, const vector<vector<Point> >& sqs) { UMat imgToShow(Size(image.cols, image.rows), image.type()); image.copyTo(imgToShow); drawSquares(imgToShow, sqs); return imgToShow; }
UMat UMat::diag(const UMat& d) { CV_Assert( d.cols == 1 || d.rows == 1 ); int len = d.rows + d.cols - 1; UMat m(len, len, d.type(), Scalar(0)); UMat md = m.diag(); if( d.cols == 1 ) d.copyTo(md); else transpose(d, md); return m; }
bool BTVL1::ocl_readNextFrame(Ptr<FrameSource>& /*frameSource*/) { ucurFrame_.convertTo(at(storePos_, uframes_), CV_32F); if (storePos_ > 0) { opticalFlow_->calc(uprevFrame_, ucurFrame_, at(storePos_ - 1, uforwardMotions_)); opticalFlow_->calc(ucurFrame_, uprevFrame_, at(storePos_, ubackwardMotions_)); } ucurFrame_.copyTo(uprevFrame_); return true; }
static bool ocl_repeat(InputArray _src, int ny, int nx, OutputArray _dst) { UMat src = _src.getUMat(), dst = _dst.getUMat(); for (int y = 0; y < ny; ++y) for (int x = 0; x < nx; ++x) { Rect roi(x * src.cols, y * src.rows, src.cols, src.rows); UMat hdr(dst, roi); src.copyTo(hdr); } return true; }
void PedestrianDetector::detect(UMat frame, std::vector<Rect> &found){ UMat img_aux, img; //work begin // Change format of the image if (make_gray_) cvtColor(frame, img_aux, COLOR_BGR2GRAY); else frame.copyTo(img_aux); // Resize image if (abs(scale_ - 1.0) > 0.001) { Size sz((int)((double)img_aux.cols / resize_scale_), (int)((double)img_aux.rows / resize_scale_)); resize(img_aux, img, sz); } else { img = img_aux; } hog_.nlevels = nlevels_; //hog performance hog_.detectMultiScale(img, found, hit_threshold_, win_stride_, Size(0, 0), scale_, gr_threshold_); //hog_.detectMultiScale(img, found, hit_threshold_, win_stride_, Size(32, 32), scale_, gr_threshold_); // If padding is not Size(0,0), OpenCL is not used.. }
void FlowSourceOpenCV_sV::buildFlowOpenCV_3(cv::UMat& uprevgray, cv::UMat& ugray, std::string flowfilename) { dumpAlgosParams(); qDebug() << "Have OpenCL: " << cv::ocl::haveOpenCL() << " useOpenCL:" << cv::ocl::useOpenCL(); UMat uflow; if (algo == 1) { // DualTVL1 cv::Ptr<cv::DualTVL1OpticalFlow> tvl1 = cv::createOptFlow_DualTVL1(); tvl1->setLambda(lambda); tvl1->setTau(tau); tvl1->setScalesNumber(nscales); tvl1->setWarpingsNumber(warps); tvl1->setOuterIterations(iterations); tvl1->setEpsilon(epsilon); tvl1->calc( uprevgray, ugray, uflow ); } else { // _FARN_ calcOpticalFlowFarneback( uprevgray, ugray, uflow, pyrScale, //0.5, numLevels, //3, winSize, //15, numIters, //8, polyN, //5, polySigma, //1.2, flags //0 ); } Mat flow; uflow.copyTo(flow); qDebug() << "finished"; drawOptFlowMap(flow, flowfilename); }
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals) { std::vector<UMat> inputs; std::vector<UMat> outputs; inps.getUMatVector(inputs); outs.getUMatVector(outputs); for (size_t i = 0; i < inputs.size(); i++) { UMat srcBlob = inputs[i]; void *src_handle = inputs[i].handle(ACCESS_READ); void *dst_handle = outputs[i].handle(ACCESS_WRITE); if (src_handle != dst_handle) { MatShape outShape = shape(outputs[i]); UMat umat = srcBlob.reshape(1, (int)outShape.size(), &outShape[0]); umat.copyTo(outputs[i]); } } outs.assign(outputs); return true; }
void UMatToVector(const UMat & um, std::vector<Point2f> & v) const { v.resize(um.size().area()); um.copyTo(Mat(um.size(), CV_32FC2, &v[0])); }
bool SURF_OCL::computeDescriptors(const UMat &keypoints, OutputArray _descriptors) { int dsize = params->descriptorSize(); int nFeatures = keypoints.cols; if (nFeatures == 0) { _descriptors.release(); return true; } _descriptors.create(nFeatures, dsize, CV_32F); UMat descriptors; if( _descriptors.isUMat() ) descriptors = _descriptors.getUMat(); else descriptors.create(nFeatures, dsize, CV_32F); ocl::Kernel kerCalcDesc, kerNormDesc; if( dsize == 64 ) { kerCalcDesc.create("SURF_computeDescriptors64", ocl::xfeatures2d::surf_oclsrc, kerOpts); kerNormDesc.create("SURF_normalizeDescriptors64", ocl::xfeatures2d::surf_oclsrc, kerOpts); } else { CV_Assert(dsize == 128); kerCalcDesc.create("SURF_computeDescriptors128", ocl::xfeatures2d::surf_oclsrc, kerOpts); kerNormDesc.create("SURF_normalizeDescriptors128", ocl::xfeatures2d::surf_oclsrc, kerOpts); } size_t localThreads[] = {6, 6}; size_t globalThreads[] = {nFeatures*localThreads[0], localThreads[1]}; if(haveImageSupport) { kerCalcDesc.args(imgTex, img_rows, img_cols, ocl::KernelArg::ReadOnlyNoSize(keypoints), ocl::KernelArg::WriteOnlyNoSize(descriptors)); } else { kerCalcDesc.args(ocl::KernelArg::ReadOnlyNoSize(img), img_rows, img_cols, ocl::KernelArg::ReadOnlyNoSize(keypoints), ocl::KernelArg::WriteOnlyNoSize(descriptors)); } if(!kerCalcDesc.run(2, globalThreads, localThreads, true)) return false; size_t localThreads_n[] = {dsize, 1}; size_t globalThreads_n[] = {nFeatures*localThreads_n[0], localThreads_n[1]}; globalThreads[0] = nFeatures * localThreads[0]; globalThreads[1] = localThreads[1]; bool ok = kerNormDesc.args(ocl::KernelArg::ReadWriteNoSize(descriptors)). run(2, globalThreads_n, localThreads_n, true); if(ok && !_descriptors.isUMat()) descriptors.copyTo(_descriptors); return ok; }
void detectAndDraw( UMat& img, Mat& canvas, CascadeClassifier& cascade, double scale0) { if( ProfileTracker x = ProfileTrackParams(184, 0)) { int i = 0; double t = 0, scale=1; vector<Rect> faces, faces2; const static Scalar colors[] = { Scalar(0,0,255), Scalar(0,128,255), Scalar(0,255,255), Scalar(0,255,0), Scalar(255,128,0), Scalar(255,255,0), Scalar(255,0,0), Scalar(255,0,255) }; static UMat gray, smallImg; t = (double)getTickCount(); resize( img, smallImg, Size(), scale0, scale0, INTER_LINEAR ); cvtColor( smallImg, gray, COLOR_BGR2GRAY ); equalizeHist( gray, gray ); cascade.detectMultiScale( gray, faces, 1.1, 3, 0 //|CASCADE_FIND_BIGGEST_OBJECT //|CASCADE_DO_ROUGH_SEARCH |CASCADE_SCALE_IMAGE, Size(30, 30) ); flip(gray, gray, 1); cascade.detectMultiScale( gray, faces2, 1.1, 2, 0 //|CASCADE_FIND_BIGGEST_OBJECT //|CASCADE_DO_ROUGH_SEARCH |CASCADE_SCALE_IMAGE , Size(30, 30) ); for( vector<Rect>::const_iterator r = faces2.begin(); r !=faces2.end(); r++ ) faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y,r->width, r->height)); t = (double)getTickCount() - t; smallImg.copyTo(canvas); for( vector<Rect>::const_iterator r = faces.begin(); r !=faces.end(); r++, i++ ) { Point center; Scalar color = colors[i%8]; int radius; double aspect_ratio = (double)r->width/r->height; if( 0.75 < aspect_ratio && aspect_ratio < 1.3 ) { center.x = cvRound((r->x + r->width*0.5)*scale); center.y = cvRound((r->y + r->height*0.5)*scale); radius = cvRound((r->width + r->height)*0.25*scale); circle( canvas, center, radius, color, 3, 8, 0 ); } else rectangle( canvas, Point(cvRound(r->x*scale), cvRound(r->y*scale)), Point(cvRound((r->x + r->width-1)*scale),cvRound((r->y + r->height-1)*scale)), color, 3, 8, 0); } } }