// buf must be fftwf_malloc'd with size `sizeof(float) * fftLen` // // im should be approx offset from fix by hint. Point phaseCorr(const float *fix, const float *im, const Size &imSz, const fftwf_plan &plan, float *buf, const Point2f &hint, double &bestSqDist, const Mat &mask, Point &maxLoc, float &conf, const ConfGetter getConf, const char *saveIm) { unsigned fftLen = getFFTLen(imSz); for (unsigned i = 0; i < fftLen; i += 2) { float a = fix[i] * im[i] + fix[i + 1] * im[i + 1]; float b = fix[i + 1] * im[i] - fix[i] * im[i + 1]; float norm = sqrt(a * a + b * b); buf[i] = (norm != 0) ? (a / norm) : 0; buf[i + 1] = (norm != 0) ? (b / norm) : 0; //printf("wow %f, %f, %f, %f, %f, %f, %f, %f\n", fix[i], fix[i+1], im[i], im[i+1], a, b, buf[i], buf[i + 1]); } fftwf_execute_dft_c2r(plan, (fftwf_complex *)buf, buf); Mat bufMat(imSz.height, imSz.width + 2, CV_32FC1, buf); // bufMat = abs(bufMat); blur(bufMat, bufMat, Size(21, 21)); if (saveIm) { saveFloatIm(saveIm, bufMat); } minMaxLoc(bufMat, NULL, NULL, NULL, &maxLoc, mask); // there are four potential shifts corresponding to one peak // we choose the shift that is closest to the microscope's guess for the offset between the two Point bestPt; bestSqDist = 1e99; for (int dx = -imSz.width; dx <= 0; dx += imSz.width) { for (int dy = -imSz.height; dy <= 0; dy += imSz.height) { Point curPt(maxLoc.x + dx, maxLoc.y + dy); double curSqDist = getSqDist(curPt, hint); if (curSqDist < bestSqDist) { bestSqDist = curSqDist; bestPt = curPt; } } } conf = getConf(bufMat, maxLoc, bestSqDist); return bestPt; }
/* Draws the heatmap on top of a frame. The frame must be the same size as * the heatmap. */ void AttentionMap::overlay(unsigned char* pDestImage, int imageWidth, int imageHeight) { update(); // Make sure all values are capped at one m_heatmap = min(m_ones, m_heatmap); Mat temp_map; blur(m_heatmap, temp_map, Size(15, 15)); for (int r = 0; r < m_heatmap.rows; ++r) { //Vec3b* f_ptr = (Vec3b *)pDestImage; float* h_ptr = temp_map.ptr<float>(r); for (int c = 0; c < m_heatmap.cols; ++c) { const float heat_mix = h_ptr[c]; if (heat_mix > 0.0) { // in BGR const Vec3b i_color = Vec3b(pDestImage[0], pDestImage[1], pDestImage[2]); const Vec3b heat_color = hsv_to_bgr(interpolate_hsv(g_heat_color2, g_heat_color1, heat_mix)); const float heat_mix2 = std::min(heat_mix, g_max_transparency); const Vec3b final_color = interpolate(i_color, heat_color, heat_mix2); //f_ptr[c] = final_color; pDestImage[0] = final_color[0]; pDestImage[1] = final_color[1]; pDestImage[2] = final_color[2]; } pDestImage+=3; } pDestImage += (imageWidth - m_heatmap.cols) *3; } fade(); }
void *readImage(FILE *inf, int opt, FILE *outf){ int width, height; int max; int r,c; int pixel; // Process the pgm file as a bufft // I.e., eat the header eatLine(inf); eatLine(inf); fscanf(inf,"%d",&width); // the first integer on line 1 is the width fscanf(inf,"%d",&height); // second is the height fscanf(inf,"%d",&max); // third is max number of pixels float *array = malloc(sizeof(float)*width*height); int p; // iterate through rows and columns // scan in graymap values, convert to pixels // fill array with pixel values for (r=0; r < height; r++) { for (c=0; c < width; c++) { fscanf(inf,"%d",&pixel); p = c + r*width; array[p] = (float)pixel/(float)max; } } // Select function to call // switch (opt) { case(ASCII): echoASCII(array,height,width,outf); break; case(INV): invert(array,height,width,outf); case(BLUR): blur(array,height,width,outf); } // exit(-1); }
void captcha(unsigned char im[70*200], unsigned char l[6]) { unsigned i; unsigned char swr[200]; uint8_t s1,s2; int f=open("/dev/urandom",O_RDONLY); read(f,l,5); read(f,swr,200); read(f,dr,sizeof(dr)); read(f,&s1,1); read(f,&s2,1); close(f); memset(im,0xff,200*70); s1=s1&0x7f; s2=s2&0x3f; int p=30; for (i = 0; i < 5; i++) { l[i] = l[i] % NUM_GLYPHS; p=letter(l[i],p,im,swr,s1,s2); l[i] = letters[l[i]]; } line(im,swr,s1); dots(im); blur(im); l[5] = 0; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; /* Setting mandatory output values */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Getting run_mode - we won't display a dialog if * we are in NONINTERACTIVE mode */ run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_progress_init ("My Blur..."); /* Let's time blur * * GTimer timer = g_timer_new time (); */ blur (drawable); /* g_print ("blur() took %g seconds.\n", g_timer_elapsed (timer)); * g_timer_destroy (timer); */ gimp_displays_flush (); gimp_drawable_detach (drawable); }
static void apply_paint_maskfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) { SkMaskFilter* maskFilter = paint.getMaskFilter(); if (maskFilter != nullptr) { SkMaskFilter::BlurRec blurRec; if (maskFilter->asABlur(&blurRec)) { Json::Value blur(Json::objectValue); blur[SKJSONCANVAS_ATTRIBUTE_SIGMA] = Json::Value(blurRec.fSigma); switch (blurRec.fStyle) { case SkBlurStyle::kNormal_SkBlurStyle: blur[SKJSONCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKJSONCANVAS_BLURSTYLE_NORMAL); break; case SkBlurStyle::kSolid_SkBlurStyle: blur[SKJSONCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKJSONCANVAS_BLURSTYLE_SOLID); break; case SkBlurStyle::kOuter_SkBlurStyle: blur[SKJSONCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKJSONCANVAS_BLURSTYLE_OUTER); break; case SkBlurStyle::kInner_SkBlurStyle: blur[SKJSONCANVAS_ATTRIBUTE_STYLE] = Json::Value(SKJSONCANVAS_BLURSTYLE_INNER); break; default: SkASSERT(false); } switch (blurRec.fQuality) { case SkBlurQuality::kLow_SkBlurQuality: blur[SKJSONCANVAS_ATTRIBUTE_QUALITY] = Json::Value(SKJSONCANVAS_BLURQUALITY_LOW); break; case SkBlurQuality::kHigh_SkBlurQuality: blur[SKJSONCANVAS_ATTRIBUTE_QUALITY] = Json::Value(SKJSONCANVAS_BLURQUALITY_HIGH); break; default: SkASSERT(false); } (*target)[SKJSONCANVAS_ATTRIBUTE_BLUR] = blur; } else { Json::Value jsonMaskFilter; flatten(maskFilter, &jsonMaskFilter, sendBinaries); (*target)[SKJSONCANVAS_ATTRIBUTE_MASKFILTER] = jsonMaskFilter; } } }
int main(int argc, char** argv){ float dur, time; if(argc == 3){ dur = (float) atof(argv[1]); time = (float) atof(argv[2]); } else { Usage(argv[0]); exit(1); } SndRTIO input(1, SND_INPUT); SndRTIO output(1, SND_OUTPUT); HammingTable window(1024, 0.54f); SndIn in(&input); PVA anal(&window, &in); PVBlur blur(&anal, time); PVS synth(&window, &blur); output.SetOutput(1, &synth); int end = dur*DEF_SR/DEF_VECSIZE; for(int i=0; i<end; i++){ input.Read(); in.DoProcess(); anal.DoProcess(); blur.DoProcess(); synth.DoProcess(); output.Write(); } return 0; }
vector< vector< Point> > BlobDetection::detectContours(Mat frame, Ptr< BackgroundSubtractor>& pMOG2Pointer , Mat& fgMaskMOG2) { vector< vector< Point> > result; cvNamedWindow("Original" , CV_WINDOW_NORMAL); cvNamedWindow("Blurred" , CV_WINDOW_NORMAL); //cvNamedWindow("fgMaskMOG2X" , CV_WINDOW_NORMAL); cvNamedWindow("Background Subtracted", CV_WINDOW_NORMAL); cvNamedWindow("Shadow Removed" , CV_WINDOW_NORMAL); Mat fgMaskMOG2X = fgMaskMOG2.clone(); Mat ContourImg; Ptr< BackgroundSubtractor> pMOG2 = pMOG2Pointer; Mat element = getStructuringElement(MORPH_RECT, Size(7, 7), Point(3, 3)); imshow("Original", frame); //PreProcess blur(frame, frame, Size(4, 4)); imshow("Blurred", frame); //Background subtraction pMOG2->operator()(frame, fgMaskMOG2X, -1); //imshow("fgMaskMOG2X", frame); morphologyEx(fgMaskMOG2X, frame, CV_MOP_CLOSE, element); imshow("Background Subtracted", frame); threshold(frame, frame, 180, 255, CV_THRESH_BINARY); imshow("Shadow Removed", frame); cvWaitKey(1); ContourImg = frame.clone(); findContours(ContourImg, result, // a vector of contours CV_RETR_EXTERNAL, // retrieve the external contours CV_CHAIN_APPROX_NONE); // all pixels of each contours fgMaskMOG2 = fgMaskMOG2X.clone(); return result; }
void hysteresis(Mat img, Size size, String name, FileData &fd) { blur(img,img,size); Rgb rgb; Hsl hsl; int r,g,b; vector<double> HSL; double h,s,l; String pix; String hslStr; deque<String> colorWindow; deque<String> hslVec; for(int i=0; i<img.rows; i++) { for(int j=0; j<img.cols; j++) { r = img.at<Vec3b>(i,j)[2]; g = img.at<Vec3b>(i,j)[1]; b = img.at<Vec3b>(i,j)[0]; HSL = hsl.rgb2hsl(r,g,b); h = HSL[0]; s = ip::roundDecimal(HSL[1],2); l = ip::roundDecimal(HSL[2],2); pix = rgb.checkBlack(r,g,b); if(pix=="OTHER") { pix = rgb.calcColor(r,g,b); } colorWindow.push_back(pix); hslStr = ip::toString(h)+";"+ip::toString(s)+";"+ip::toString(l); hslVec.push_back(hslStr); } fd.windowVec.push_back(colorWindow); fd.hslMat.push_back(hslVec); colorWindow.clear(); hslVec.clear(); } Intensity in; in.calcMainColorMatrix(fd.getImage(), fd.windowVec, fd.hslMat, fd.filename, fd); //rule5(fd); cout << "Done!" << endl; colorWindow.clear(); colorWindow.shrink_to_fit(); hslVec.clear(); hslVec.shrink_to_fit(); }
void* threadBlur(void* argument) { // unpacking arguments args* image = (args*)argument; struct image* img = image->img; struct pixel* pixels = image->pixels; int firstLine = image->firstLine; int lastLine = image->lastLine; int i; int j; for (i=firstLine; i<=lastLine; i++) { if (i<img->height) { for (j=0; j<img->width; j++) { img->pixels[i * img->width +j] = blur(img,pixels,j,i); } } } pthread_exit(NULL); }
void Objectness::nonMaxSup(CMat &matchCost1f, ValStructVec<float, Point> &matchCost, int NSS, int maxPoint, bool fast) { const int _h = matchCost1f.rows, _w = matchCost1f.cols; Mat isMax1u = Mat::ones(_h, _w, CV_8U), costSmooth1f; ValStructVec<float, Point> valPnt; matchCost.reserve(_h * _w); valPnt.reserve(_h * _w); if (fast) { blur(matchCost1f, costSmooth1f, Size(3, 3)); for (int r = 0; r < _h; r++) { const float* d = matchCost1f.ptr<float>(r); const float* ds = costSmooth1f.ptr<float>(r); for (int c = 0; c < _w; c++) if (d[c] >= ds[c]) valPnt.pushBack(d[c], Point(c, r)); } } else { for (int r = 0; r < _h; r++) { const float* d = matchCost1f.ptr<float>(r); for (int c = 0; c < _w; c++) valPnt.pushBack(d[c], Point(c, r)); } } valPnt.sort(); for (int i = 0; i < valPnt.size(); i++) { Point &pnt = valPnt[i]; if (isMax1u.at<byte>(pnt)) { matchCost.pushBack(valPnt(i), pnt); for (int dy = -NSS; dy <= NSS; dy++) for (int dx = -NSS; dx <= NSS; dx++) { Point neighbor = pnt + Point(dx, dy); if (!CHK_IND(neighbor)) continue; isMax1u.at<byte>(neighbor) = false; } } if (matchCost.size() >= maxPoint) return; } }
vector<Point> convexHullExtraction(Mat src) { Mat src_gray; cvtColor(src, src_gray, CV_BGR2GRAY); blur(src_gray, src_gray, Size(3, 3)); // Convex Hull implementation Mat src_copy = src.clone(); Mat dst; vector<vector<Point> > contours; vector<Vec4i> hierarchy; // Find contours threshold(src_gray, dst, 200, 255, THRESH_BINARY); findContours(dst, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0)); // Find the convex hull object for each contour vector<vector<Point> >hull(1); convexHull(Mat(contours[1]), hull[0], false); // Draw contours + hull results if (convexShow) { RNG rng; Mat drawing = Mat::zeros(dst.size(), CV_8UC3); for (int i = 0; i< contours.size(); i++) { if (i == 1) drawContours(drawing, contours, i, Scalar(255, 255, 0), 1, 8, vector<Vec4i>(), 0, Point()); if (i == 0) drawContours(drawing, hull, i, Scalar(255, 255, 255), 1, 8, vector<Vec4i>(), 0, Point()); } // Show in a window namedWindow("Hull demo", CV_WINDOW_AUTOSIZE); imshow("Hull demo", drawing); if (save) imwrite("Hull.jpg", drawing); waitKey(0); } return hull[0]; }
void Img::boundarize() { Mat image_gray, canny_output, nonzeros; int thresh = 100; vector<vector<Point> > contours; vector<Vec4i> hierarchy; RNG rng(12345); cvtColor( this->image, image_gray, CV_BGR2GRAY ); blur( image_gray, image_gray, Size(3,3) ); Canny( image_gray, canny_output, thresh, thresh*2, 3 ); findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); this->image = Mat::zeros( canny_output.size(), CV_8UC3 ); for( unsigned int i = 0; i< contours.size(); i++ ) { Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( this->image, contours, i, color, 2, 8, hierarchy, 0, Point() ); } cvtColor( this->image, this->image, CV_BGR2GRAY ); threshold( this->image, this->image, 0, 255,0 ); findNonZero(this->image, nonzeros); this->points = nonzeros.rows; delete [] vx; delete [] vy; std::cout << "\n[+] Initiallizing vectors : "<<points<<" points detected"; vx = new int[points+1]; std::cout << "\n[+] Vx initiallized"; vy = new int[points+1]; std::cout << "\n[+] Vy Initiallized"; this->sampling(); }
Mat BookSegmenter::CannyThreshold(Mat src_gray){ int lowThreshold = 30; int ratio = 3; int kernel_size = 3; /// Reduce noise with a kernel 3x3 Mat detected_edges; blur(src_gray, detected_edges, Size(3, 3)); /// Canny detector Canny(detected_edges, detected_edges, lowThreshold, lowThreshold * ratio, kernel_size); /// Using Canny's output as a mask, we display our result //Mat dst = Scalar::all(0); //src_gray.copyTo( dst, detected_edges); //imshow("Canny", detected_edges); return detected_edges; }
void Filter::applyFilter() { configureSpinBox(); switch(currentFilter){ case FILTER_HOMOGENEOUS: blur(originalImage, image, ksize); ui->filteredImage->setPixmap(ImageHandler::getQPixmap(image)); break; case FILTER_GAUSSIAN: GaussianBlur(originalImage, image, ksize, 0, 0); ui->filteredImage->setPixmap(ImageHandler::getQPixmap(image)); break; case FILTER_MEDIAN: medianBlur(originalImage, image, ksize.height); ui->filteredImage->setPixmap(ImageHandler::getQPixmap(image)); break; case FILTER_BILATERAL: bilateralFilter(originalImage, image, 5, sigma, sigma); break; } }
void imageblurgm_draw(SkScalar fSigmaX, SkScalar fSigmaY, SkCanvas* canvas) { SkPaint paint; SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY)); paint.setImageFilter(blur); canvas->saveLayer(nullptr, &paint); const char* str = "The quick brown fox jumped over the lazy dog."; SkRandom rand; SkPaint textPaint; textPaint.setAntiAlias(true); sk_tool_utils::set_portable_typeface(&textPaint); for (int i = 0; i < 25; ++i) { int x = rand.nextULessThan(WIDTH); int y = rand.nextULessThan(HEIGHT); textPaint.setColor(sk_tool_utils::color_to_565(rand.nextBits(24) | 0xFF000000)); textPaint.setTextSize(rand.nextRangeScalar(0, 300)); canvas->drawText(str, strlen(str), SkIntToScalar(x), SkIntToScalar(y), textPaint); } canvas->restore(); }
/* * add_mi does the work necessary to set up an mspectrum object for modeling. * - an entry in the m_State object is made for the parent ion M+H * once an mspectrum has been added, the original mspectrum is no longer * needed for modeling, as all of the work associated with a spectrum * is only done once, prior to modeling sequences. */ bool mscore_tandem::add_mi(mspectrum &_s) { if (!mscore::add_mi(_s)) return false; if (m_vmiType.size() == 0) { m_vmiType.reserve((long)m_vSpec.size()); m_pplType = new unsigned long *[m_vSpec.size()+1]; size_t a = 0; while(a < m_vSpec.size()+1) { m_pplType[a] = NULL; a++; } } /* * use blur to improve accuracy at the edges of the fragment ion m/z error range */ blur(_s.m_vMI); return true; }
void Target::tuneThreshold(Mat imgInput) { Mat src_gray, src = imgInput, detected_edges,dst; namedWindow("Control", CV_WINDOW_AUTOSIZE); int lowThreshold = 30; int upThreshold = 100; cvCreateTrackbar("LowThreshold", "Control", &lowThreshold, 255); cvCreateTrackbar("UppThreshold", "Control", &upThreshold, 1000); cvtColor(src, src_gray, CV_BGR2GRAY); while (waitKey(30) != 27) { blur(src_gray, detected_edges, Size(3, 3)); Canny(detected_edges, detected_edges, lowThreshold, upThreshold, 3); dst = Scalar::all(0); // src.copyTo(dst, detected_edges); imshow("Control", dst); } }
// gliese581h suggested filling a cv::Mat with descriptors to enable BFmatcher compatibility // speed-ups and enhancements by gliese581h void LUCIDImpl::compute(InputArray _src, std::vector<KeyPoint> &keypoints, OutputArray _desc) { cv::Mat src_input = _src.getMat(); if (src_input.empty()) return; CV_Assert(src_input.depth() == CV_8U && src_input.channels() == 3); Mat_<Vec3b> src; blur(src_input, src, cv::Size(b_kernel, b_kernel)); int x, y, j, d, p, m = (l_kernel*2+1)*(l_kernel*2+1)*3, width = src.cols, height = src.rows, r, c; Mat_<uchar> desc(static_cast<int>(keypoints.size()), m); for (std::size_t i = 0; i < keypoints.size(); ++i) { x = static_cast<int>(keypoints[i].pt.x)-l_kernel, y = static_cast<int>(keypoints[i].pt.y)-l_kernel, d = x+2*l_kernel, p = y+2*l_kernel, j = x, r = static_cast<int>(i), c = 0; while (x <= d) { Vec3b &pix = src((y < 0 ? height+y : y >= height ? y-height : y), (x < 0 ? width+x : x >= width ? x-width : x)); desc(r, c++) = pix[0]; desc(r, c++) = pix[1]; desc(r, c++) = pix[2]; ++x; if (x > d) { if (y < p) { ++y; x = j; } else break; } } } if (_desc.needed()) sort(desc, _desc, SORT_EVERY_ROW | SORT_ASCENDING); }
/* Update video */ void osd_update_video(void) { /* Wait for VSync */ if(option.vsync) vsync(); /* Update the palette */ if(option.video_depth == 8) update_palette(); /* Use the blur effect */ if(option.blur) { blur((uint16 *)&sms_bmp->line[bitmap.viewport.y][bitmap.viewport.x * bitmap.granularity], bitmap.viewport.w, bitmap.viewport.h, (bitmap.width-bitmap.viewport.w) * bitmap.granularity ); } if(option.fps) msg_print(2, 2, "%d", frame_rate); if(msg_enable) msg_print(4, bitmap.viewport.h - 12, "%s", msg); blitter_proc(sms_bmp, screen); }
void CmSaliencyGC::HistgramGMMs() { // Color quantization Mat _colorNums1f, _binBGR3f; CmColorQua::D_Quantize(_img3f, _HistBinIdx1i, _binBGR3f, _colorNums1f); //CmShow::HistBins(_binBGR3f, _colorNums1i, _nameNE + "_QT.jpg", true); _colorNums1f.convertTo(_colorNums1f, CV_32F); // Train GMMs Mat gmmIdx1i; _gmm.BuildGMMs(_binBGR3f, gmmIdx1i, _colorNums1f); _NUM = _gmm.RefineGMMs(_binBGR3f, gmmIdx1i, _colorNums1f); _PixelSalCi1f.resize(_NUM); _HistBinSalCi1f.resize(_NUM); _gmmClrs.resize(_NUM); _gmmW.resize(_NUM); _csd.resize(_NUM); _gu.resize(_NUM); _fSal.resize(_NUM); // Assign GMM color means and weights for (int i = 0; i < _NUM; i++) _gmmClrs[i] = _gmm.getMean(i), _gmmW[i] = _gmm.getWeight(i); // Assign GMMs for each components _gmm.GetProbs(_binBGR3f, _HistBinSalCi1f); #pragma omp parallel for for (int c = 0; c < _NUM; c++){ _PixelSalCi1f[c].create(_img3f.size(), CV_32FC1); float *prob = (float*)(_HistBinSalCi1f[c].data); for (int y = 0; y < _HistBinIdx1i.rows; y++){ const int *_idx = _HistBinIdx1i.ptr<int>(y); float* probCI = _PixelSalCi1f[c].ptr<float>(y); for (int x = 0; x < _HistBinIdx1i.cols; x++) probCI[x] = prob[_idx[x]]; } blur(_PixelSalCi1f[c], _PixelSalCi1f[c], Size(3, 3)); } }
void GrabCutMF::runGrabCutOpenCV(CStr &wkDir) { CStr imgDir = wkDir + "Imgs/", salDir = wkDir + "Sal/"; vecS namesNE; int imgNum = CmFile::GetNamesNE(imgDir + "*.jpg", namesNE); CmFile::MkDir(salDir); // Number of labels CmTimer tm("Time"); tm.Start(); for (int i = 0; i < imgNum; i++){ printf("Processing %d/%d: %s.jpg%20s\r\n", i, imgNum, _S(namesNE[i]), ""); CmFile::Copy(imgDir + namesNE[i] + ".jpg", salDir + namesNE[i] + ".jpg"); CmFile::Copy(imgDir + namesNE[i] + ".png", salDir + namesNE[i] + "_GT.png"); Mat imMat3u = imread(imgDir + namesNE[i] + ".jpg"); Mat gt1u = imread(imgDir + namesNE[i] + ".png", CV_LOAD_IMAGE_GRAYSCALE); //imwrite(imgDir + namesNE[i] + ".bmp", gt1u); blur(gt1u, gt1u, Size(3,3)); Rect wkRect = CmCv::GetMaskRange(gt1u, 1, 128); // Prepare data for OneCut //Mat rectImg = Mat::ones(gt1u.size(), CV_8U)*255; //rectImg(wkRect) = 0; //imwrite(salDir + namesNE[i] + ".bmp", imMat3u); //imwrite(salDir + namesNE[i] + "_t.bmp", rectImg); Mat res1u, bgModel, fgModel; grabCut(imMat3u, res1u, wkRect, bgModel, fgModel, 1, GC_INIT_WITH_RECT); grabCut(imMat3u, res1u, wkRect, bgModel, fgModel, 5); compare(res1u, GC_PR_FGD, res1u, CMP_EQ); imwrite(salDir + namesNE[i] + "_GC.png", res1u); } tm.Stop(); double avgTime = tm.TimeInSeconds()/imgNum; printf("Speed: %gs, %gfps\t\t\n", avgTime, 1/avgTime); CmEvaluation::EvalueMask(imgDir + "*.png", salDir, "GC", ""); }
void ContourThread::run() { int tresh = 50; Mat src; Mat src_gray; Mat drawing; RNG rng(12345); Mat canny_output; vector<vector<Point>> contours; vector<Vec4i> hierarchy; while(true) { cap >> src; drawing = Mat::zeros(src.size() , CV_8UC3); cvtColor(src,src_gray,COLOR_BGR2GRAY); blur(src_gray,src_gray,Size(3,3)); Canny(src_gray,canny_output,tresh,tresh*2,3); findContours(canny_output,contours,hierarchy,RETR_TREE,CHAIN_APPROX_SIMPLE,Point(0,0)); for(int i=0; i<contours.size(); i++) { Scalar color = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255)); drawContours(drawing,contours,i,color,2,8,hierarchy,0,Point()); } emit NewImgContours(&drawing); contours.clear(); hierarchy.clear(); waitKey(30); } return; }
/* * processFrame * * uses sequential images to detect motion in the left and right halves of the frame. * * preconditions: frame must be a valid Mat object representing a single frame from * from a VideoCapture object * postconditions: sets left and right paddles according to motion detected in the * left and right halves of the frame, respectively */ void MotionPaddleDetector::processFrame(Mat& frame) { Mat frame2, gray, gray2, thres, diff; // use sequential images (frame and frame2) for motion detection // read in frame and convert to grayscale m_vid->read(frame); flip(frame, frame, 1); cvtColor(frame, gray, COLOR_BGR2GRAY); // read in frame2 and convert to grayscale m_vid->read(frame2); flip(frame2, frame2, 1); cvtColor(frame2, gray2, COLOR_BGR2GRAY); // create difference image of frame1 and frame2 after being converted to // grayscale images absdiff(gray, gray2, diff); // threshold difference threshold(diff, thres, THRESHOLD_SENSITIVITY, 255, THRESH_BINARY); // blur the image. output will be an intensity image blur(thres, thres, cv::Size(BLUR_SIZE, BLUR_SIZE)); // threshold intensity image to get binary image (after blurring) threshold(thres, thres, THRESHOLD_SENSITIVITY, 255, THRESH_BINARY); // split threshold (now binary image) into left and right halves int x = thres.cols / 2; int y = thres.rows; Mat thresholdLeft(thres, Rect(0, 0, x, y)); Mat thresholdRight(thres, Rect(x, 0, x, y)); // detect motion in each half of the binary image detectMotion(thresholdLeft, frame, IS_RED); detectMotion(thresholdRight, frame, IS_BLUE); }
void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; static const SkScalar kX = 0; static const SkScalar kY = 0; const SkRect bmpRect = SkRect::MakeXYWH(kX, kY, SkIntToScalar(fCheckerboard.width()), SkIntToScalar(fCheckerboard.height())); const SkImageFilter::CropRect cropRect(bmpRect.makeInset(10.f, 10.f)); const SkImageFilter::CropRect cropRectLarge(bmpRect); SkAutoTUnref<SkImageFilter> noOpCropped(SkOffsetImageFilter::Create(0, 0, nullptr, &cropRect)); SkImageFilter* input = fIsExpanded ? noOpCropped.get() : nullptr; const SkImageFilter::CropRect* crop = fIsExpanded ? &cropRectLarge : fIsCropped ? &cropRect : nullptr; SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY, input, crop)); paint.setImageFilter(blur); for (int i = 0; i < loops; i++) { canvas->drawBitmap(fCheckerboard, kX, kY, &paint); } }
void captcha_render(unsigned char im[70*200], const unsigned char lts[6]) { unsigned i; unsigned char swr[200]; uint8_t s1,s2; int f=open("/dev/urandom",O_RDONLY); read(f,swr,200); read(f,dr,sizeof(dr)); read(f,&s1,1); read(f,&s2,1); close(f); memset(im,0xff,200*70); s1=s1&0x7f; s2=s2&0x3f; int p=30; for (i = 0; i < 5; i++) { unsigned l; for (l = 0; l < sizeof(letters) / sizeof(*letters) - 1; l++) if (letters[l] == lts[i]) break; if (l == sizeof(letters) / sizeof(*letters) - 1) l = 0; p = letter(l,p,im,swr,s1,s2); } line(im,swr,s1); dots(im); blur(im); }
void GoalPostDetector::CannyThreshold() { /// Reduce noise with a kernel 3x3 Mat greyMat; cv::cvtColor(originalImg, greyMat, CV_BGR2GRAY); cv::equalizeHist(greyMat, greyMat); //normalize the image, if lighting conditions are changing Mat detected_edges; blur( greyMat, detected_edges, Size(3,3) ); /// Canny detector Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernelSize ); /// Using Canny's output as a mask, we display our result img = Scalar::all(0); greyMat.copyTo( img, detected_edges); cv::threshold(img, img, 0, 255, cv::THRESH_BINARY); }
virtual void onDraw(SkCanvas* canvas) { if (!fInitialized) { this->make_bitmap(); fInitialized = true; } canvas->clear(0x00000000); { SkAutoTUnref<SkImageFilter> bitmapSource(new SkBitmapSource(fBitmap)); SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); SkAutoTUnref<SkImageFilter> blur(new SkBlurImageFilter(4.0f, 4.0f, bitmapSource)); SkAutoTUnref<SkImageFilter> erode(new SkErodeImageFilter(4, 4, blur)); SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode)); SkAutoTUnref<SkImageFilter> merge(new SkMergeImageFilter(blur, color)); SkPaint paint; paint.setImageFilter(merge); canvas->drawPaint(paint); } { SkAutoTUnref<SkImageFilter> morph(new SkDilateImageFilter(5, 5)); SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0, 0, SK_Scalar1, 0, 0, 0, 0, 0, SK_Scalar1, 0, 0, 0, 0, 0, SkFloatToScalar(0.5f), 0 }; SkAutoTUnref<SkColorFilter> matrixFilter(new SkColorMatrixFilter(matrix)); SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph)); SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode)); SkAutoTUnref<SkImageFilter> blendColor(new SkXfermodeImageFilter(mode, colorMorph)); SkPaint paint; paint.setImageFilter(blendColor); canvas->drawBitmap(fBitmap, 100, 0, &paint); } }
std::vector<cv::Mat> ObjectSelector::getObjects(cv::Mat * src, cv::Point2f p) { std::vector<std::vector<cv::Point> > contours; std::vector<cv::Vec4i> hierarchy; cv::Mat canny_output; cv::Mat src_gray; cvtColor( *src, src_gray, CV_BGR2GRAY ); blur( src_gray, src_gray, cv::Size(3,3) ); /// Detect edges using canny Canny( src_gray, canny_output, thresh, thresh*2, 3 ); /// Find contours findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); std::priority_queue<TestedContour> results; for( int i = 0; i< contours.size(); i++ ) results.push(TestedContour(i,-pointPolygonTest(contours[i],p,true))); std::vector<cv::Mat> retVal; for(int i = 0; i < maxRet && !results.empty(); i++) { TestedContour c = results.top(); results.pop(); cv::Rect br = boundingRect( contours[c.Id()] ); cv::Mat mask = cv::Mat::zeros(src->size(), CV_8UC1); std::vector<std::vector<cv::Point> > hull; hull.push_back(std::vector<cv::Point>()); convexHull(contours[c.Id()],hull[0],1,true); drawContours( mask, hull, 0, cv::Scalar(255), CV_FILLED ); cv::Mat tmp = cv::Mat::zeros(br.size(), CV_8UC3); src->copyTo(tmp, mask); retVal.push_back(cv::Mat(tmp,br)); } return retVal; }
void create_shadow(void) { glViewport(0,0,SIZE,SIZE); glScissor(0,0,SIZE,SIZE); glEnable(GL_SCISSOR_TEST); glBindTexture(GL_TEXTURE_2D,shadow_id); glClearColor(1,1,1,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1,-1,1,-100,100); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(light[0],light[1],light[2], mesh[0],mesh[1],mesh[2], 0,0,1); glColor3f(0.4,0.4,0.4); glTranslatef(mesh[0],mesh[1],mesh[2]); glRotatef(angle,0,0,1); glRotatef(angle / 3,1,0,0); glCallList(mesh_id); glColor3f(1,1,1); if(my_blur) { glReadPixels(0,0,SIZE,SIZE,GL_RGB,GL_UNSIGNED_BYTE,image); blur(image,SIZE); glTexSubImage2D(GL_TEXTURE_2D,0,0,0,SIZE,SIZE,GL_RGB, GL_UNSIGNED_BYTE,image); } else { glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,SIZE,SIZE); } glDisable(GL_SCISSOR_TEST); glViewport(0,0,WIDTH,HEIGHT); }