int getPegthresholdFromUser(IplImage *img, Gui *gui, string message, int pegThreshVal, Rect r, cv::Mat &fgMaskPeg) { cv::Mat element[1]; int count = 0; element[0] = getStructuringElement(MORPH_ELLIPSE, Size(8, 8), Point(0, 0)); window_name = gui->windowName(); cvDestroyWindow(window_name.c_str()); cvNamedWindow(window_name.c_str(), CV_WINDOW_AUTOSIZE); cvMoveWindow(window_name.c_str(), 100, 100); img0 = (IplImage *)cvClone(img); char TrackbarName[50]; sprintf(TrackbarName, "thresh x %d", slider_max); slider_val = pegThreshVal; createTrackbar(TrackbarName, window_name, &slider_val, slider_max, 0); Mat src, im1, im3; src = Mat(img0); im1 = Mat::zeros(src.size(), src.type()); cvtColor(src, im3, CV_BGR2HSV); vector<vector<Point> > pegsI; while (1) { pegsI.clear(); Mat channel[3]; split(im3, channel); //Mat fgMaskRing; inRange(channel[2], slider_val, 255, fgMaskPeg); // ROI for (int y = 0; y < fgMaskPeg.rows; y++) { for (int x = 0; x < fgMaskPeg.cols; x++) { if (!(x >= r.tl().x && x <= r.br().x && y >= r.tl().y && y <= r.br().y)) { fgMaskPeg.at<uchar>(Point(x, y)) = 0; } } } erode(fgMaskPeg, fgMaskPeg, element[0]); dilate(fgMaskPeg, fgMaskPeg, element[0]); erode(fgMaskPeg, fgMaskPeg, element[0]); dilate(fgMaskPeg, fgMaskPeg, element[0]); //p.copyTo(p, fgMaskPeg); for (int y = 0; y < src.rows; y++) { for (int x = 0; x < src.cols; x++) { if (fgMaskPeg.at<uchar>(Point(x, y))) { im1.at<Vec3b>(Point(x, y)) = src.at<Vec3b>(Point(x, y)); } else { im1.at<Vec3b>(Point(x, y)) = Vec3b(0,0,0); } } } Mat mask = fgMaskPeg.clone(); vector<Vec4i> hierarchy_ring; //imshow("Initial mask", initial_ring_mask); findContours(mask, pegsI, hierarchy_ring, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0)); count = pegsI.size(); cout << "count Pegs->" << count << endl; cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.5, 0.5, 0, 1, 8); putText(im1, message.c_str(), cvPoint(0, 60), CV_FONT_HERSHEY_SIMPLEX, .7, Scalar(255, 255, 0), 1); imshow(window_name.c_str(), im1); char key = cvWaitKey(40); if ((key == '\r' || key == '\n' || key == '\r\n')) { if (count == 12) { break; } } count = 0; } cvReleaseImage(&img0); return slider_val; }
void close(int h,int w,int win){ dilate(h,w,win); erode(h,w,win); }
void open(int h,int w,int win){ erode(h,w,win); dilate(h,w,win); }
void OpenniFilter::cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud) { if (!viewer.wasStopped()) { if (cloud->isOrganized()) { // initialize all the Mats to store intermediate steps int cloudHeight = cloud->height; int cloudWidth = cloud->width; rgbFrame = Mat(cloudHeight, cloudWidth, CV_8UC3); drawing = Mat(cloudHeight, cloudWidth, CV_8UC3, NULL); grayFrame = Mat(cloudHeight, cloudWidth, CV_8UC1, NULL); hsvFrame = Mat(cloudHeight, cloudWidth, CV_8UC3, NULL); contourMask = Mat(cloudHeight, cloudWidth, CV_8UC1, NULL); if (!cloud->empty()) { for (int h = 0; h < rgbFrame.rows; h ++) { for (int w = 0; w < rgbFrame.cols; w++) { pcl::PointXYZRGBA point = cloud->at(w, cloudHeight-h-1); Eigen::Vector3i rgb = point.getRGBVector3i(); rgbFrame.at<Vec3b>(h,w)[0] = rgb[2]; rgbFrame.at<Vec3b>(h,w)[1] = rgb[1]; rgbFrame.at<Vec3b>(h,w)[2] = rgb[0]; } } // do the filtering int xPos = 0; int yPos = 0; mtx.lock(); xPos = mouse_x; yPos = mouse_y; mtx.unlock(); // color filtering based on what is chosen by users cvtColor(rgbFrame, hsvFrame, CV_RGB2HSV); Vec3b pixel = hsvFrame.at<Vec3b>(xPos,yPos); int hueLow = pixel[0] < iHueDev ? pixel[0] : pixel[0] - iHueDev; int hueHigh = pixel[0] > 255 - iHueDev ? pixel[0] : pixel[0] + iHueDev; // inRange(hsvFrame, Scalar(hueLow, pixel[1]-20, pixel[2]-20), Scalar(hueHigh, pixel[1]+20, pixel[2]+20), grayFrame); inRange(hsvFrame, Scalar(hueLow, iLowS, iLowV), Scalar(hueHigh, iHighS, iHighV), grayFrame); // removes small objects from the foreground by morphological opening erode(grayFrame, grayFrame, getStructuringElement(MORPH_ELLIPSE, Size(5,5))); dilate(grayFrame, grayFrame, getStructuringElement(MORPH_ELLIPSE, Size(5,5))); // morphological closing (removes small holes from the foreground) dilate(grayFrame, grayFrame, getStructuringElement(MORPH_ELLIPSE, Size(5,5))); erode(grayFrame, grayFrame, getStructuringElement(MORPH_ELLIPSE, Size(5,5))); // gets contour from the grayFrame and keeps the largest contour Mat cannyOutput; vector<vector<Point> > contours; vector<Vec4i> hierarchy; int thresh = 100; Canny(grayFrame, cannyOutput, thresh, thresh * 2, 3); findContours(cannyOutput, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0)); int largestContourArea, largestContourIndex = 0; int defaultContourArea = 1000; // 1000 seems to work find in most cases... cannot prove this vector<vector<Point> > newContours; for (int i = 0; i < contours.size(); i++) { double area = contourArea(contours[i], false); if (area > defaultContourArea) newContours.push_back(contours[i]); } // draws the largest contour: drawing = Mat::zeros(cannyOutput.size(), CV_8UC3); for (int i = 0; i < newContours.size(); i++) drawContours(drawing, newContours, i, Scalar(255, 255, 255), CV_FILLED, 8, hierarchy, 0, Point()); // gets the filter by setting everything within the contour to be 1. inRange(drawing, Scalar(1, 1, 1), Scalar(255, 255, 255), contourMask); // filters the point cloud based on contourMask // again go through the point cloud and filter out unnecessary points pcl::PointCloud<pcl::PointXYZRGBA>::Ptr resultCloud (new pcl::PointCloud<pcl::PointXYZRGBA>); pcl::PointXYZRGBA newPoint; for (int h = 0; h < contourMask.rows; h ++) { for (int w = 0; w < contourMask.cols; w++) { if (contourMask.at<uchar>(h,w) > 0) { newPoint = cloud->at(w,h); resultCloud->push_back(newPoint); } } } if (xPos == 0 && yPos == 0) viewer.showCloud(cloud); else viewer.showCloud(resultCloud); imshow("tracker", rgbFrame); imshow("filtered result", contourMask); char key = waitKey(1); if (key == 27) { interface->stop(); return; } } else cout << "Warning: Point Cloud is empty" << endl; } else cout << "Warning: Point Cloud is not organized" << endl; } }
// display function should be good enough void OpenRadar::DrawRadarData() { int usualColor[15] = {16777215,255,128,65280,32768, 16711680,16711935,8421376,65535,32896 }; /*<usual color*/ CvPoint pt1, pt2; cvZero(RadarImage); cvCircle(RadarImage, cvPoint(DisplayDx,DisplayDy),3, CV_RGB(0,255,255), -1, 8,0); int x,y; unsigned char * pPixel = 0; int colorIndex = 0, colorRGB; int R = 255, G = 0, B = 0; for (int i = 0; i < RadarDataCnt;i++) { if (RadarRho[i] < 0) { //change color colorRGB = usualColor[colorIndex]; R = colorRGB/65536; G = (colorRGB%65536)/256; B = colorRGB%256; colorIndex = (colorIndex + 1)%10; } else { x = (int)(RadarRho[i]*cos(RadarTheta[i])/DisplayRatio) + DisplayDx; y = (int)(-RadarRho[i]*sin(RadarTheta[i])/DisplayRatio)+ DisplayDy; if (x >= 0 && x < RadarImageWdith && y >= 0 && y < RadarImageHeight) { pPixel = (unsigned char*)RadarImage->imageData + y*RadarImage->widthStep + 3*x; pPixel[0] = B; pPixel[1] = G; pPixel[2] = R; } } } pt1.x = DisplayDx; pt1.y = DisplayDy; pt2.x = DisplayDx+line_length*v_scale*sin(v_angle + 0.5*M_PI); pt2.y = DisplayDy+line_length*v_scale*cos(v_angle + 0.5*M_PI); cvLine(RadarImage, pt1, pt2, CV_RGB(255,255,255),2,8,0); pt2.x = DisplayDx+line_length*cos(-(-120 + skip_bin_idx * polarH_resolution)* M_PI/180 ); pt2.y = DisplayDy+line_length*sin(-(-120 + skip_bin_idx * polarH_resolution)* M_PI/180 ); cvLine(RadarImage, pt1, pt2, CV_RGB(0,255,0),1,8,0); pt2.x = DisplayDx+line_length*cos(-(-120 + (polarH_length-skip_bin_idx) * polarH_resolution)* M_PI/180 ); pt2.y = DisplayDy+line_length*sin(-(-120 + (polarH_length-skip_bin_idx) * polarH_resolution)* M_PI/180 ); //pt2.x = DisplayDx+line_length*cos(0.25*M_PI); //pt2.y = DisplayDy+line_length*sin(0.25*M_PI); //cout<< line_length <<endl; //cout<< pt1.x <<" , " << pt1.y <<endl; //cout<< pt2.x <<" , " << pt2.y <<endl; cvLine(RadarImage, pt1, pt2, CV_RGB(0,255,0),1,8,0); float angle; int line_length2; for (int i=0; i<polarH_length;i++) { angle = (-30+i*polarH_resolution)*M_PI/180; line_length2 = H[i]/10; pt2.x = DisplayDx+line_length2*sin(angle); pt2.y = DisplayDy+line_length2*cos(angle); cvCircle(RadarImage, pt2, 2, CV_RGB(255,255,255),1,8,0); } //////////////////////////////////////////////////////////////////////////////////// // mine //////////////////////////////////////////////////////////////////////////////////// Mat binImg = Mat::zeros(RadarImageHeight,RadarImageWdith,CV_8UC1); vector< Point> centerRaw; centerRaw.clear(); for (int i = 0; i < RadarDataCnt;i++) { if (RadarRho[i] > 200) { x = (int)(RadarRho[i]*cos(RadarTheta[i])/DisplayRatio) + DisplayDx; y = (int)(-RadarRho[i]*sin(RadarTheta[i])/DisplayRatio)+ DisplayDy; //centerRaw.push_back(Point(x,y)); //cout<<"P:" <<centerRaw[i].x<<","<<centerRaw[i].y<<endl; if (x >= 0 && x < RadarImageWdith && y >= 0 && y < RadarImageHeight) { circle( binImg,Point(x,y),1,Scalar(255),-1); } } } imshow("binImg",binImg); Mat element = getStructuringElement(MORPH_RECT, Size(1,2)); Mat element2 = getStructuringElement(MORPH_RECT, Size(10,10)); erode(binImg, binImg, element); morphologyEx(binImg, binImg, MORPH_OPEN, element); dilate(binImg, binImg, element2); morphologyEx(binImg, binImg, MORPH_CLOSE, element2); imshow("dilate",binImg); vector< vector<Point> > contours; vector< vector<Point> > filterContours; vector< Vec4i > hierarchy; vector< Point2f> center; vector< float > radius; vector<Point2f> realPoint; findContours(binImg, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); center.resize(contours.size()); radius.resize(contours.size()); //realPoint.resize(contours.size()); for(int i = 0; i< contours.size(); i++) { minEnclosingCircle(Mat(contours[i]),center[i],radius[i]);//对轮廓进行多变形逼近 circle(binImg,center[i],650/DisplayRatio,Scalar(255),1); //cout<<"No."<<i<<" | P: "<< center[i].x<<","<<center[i].y<<endl; float realX = (center[i].x - DisplayDx) * DisplayRatio; float realY = (center[i].y - DisplayDy) * DisplayRatio; realPoint.push_back(Point2f(realX,realY)); //cout<<"No."<<i<<" | P: "<< realPoint[i].x<<","<<realPoint[i].y<<endl; } imshow("findContours",binImg); // colar map Mat mapImg = Mat::zeros(RadarImageHeight,RadarImageWdith,CV_8UC3); circle(mapImg, Point(DisplayDx,DisplayDy),3, CV_RGB(255,255,255),-1); line(mapImg, Point(DisplayDx,DisplayDy), Point(DisplayDx+40,DisplayDy), Scalar(0,0,255),1); line(mapImg, Point(DisplayDx,DisplayDy), Point(DisplayDx,DisplayDy+40), Scalar(0,255,0),1); for(int i = 0; i< center.size(); i++) { circle(mapImg,center[i],650/DisplayRatio,Scalar(255,255,0),1,CV_AA); circle(mapImg,center[i],100/DisplayRatio,Scalar(0,255,255),-1); } imshow("Map",mapImg); //////////////////////////////////// ukftest::laserPoint msg; vector <float> xvec; vector <float> yvec; for(int i = 0 ; i < realPoint.size(); i++) { // cm xvec.push_back(realPoint[i].x/10.0f); yvec.push_back(realPoint[i].y/10.0f); } // msg msg.header.stamp = ros::Time::now(); msg.header.frame_id = "hokuyo_laser"; msg.x =xvec; msg.y =yvec; if(realPoint.size() >0) msg.isBlocking = 1; else msg.isBlocking = 0; pub_xy. publish(msg); }
/* ------------------------------------------------------------------------------------------------------ Creates a byte from the waveform 0..255 new byte -1 continue -2 error -3 no more bytes --------------------------------------------------------------------------------------------------------- */ int byte_decode(int restart, int new_file) { static int t,t_active,t_byte; static int byte,n_bytes,c[6]; int i,j,k,d[7],sampleval; double x; // t = number of samples read // t_byte = sample where byte starts // t_active is > 0 when a signal has been detected if(restart) { t = t_active = 0; update_progress(0.0); update_status("Attente du signal..."); } // process next sample t++; sampleval = next_sample(new_file); if (sampleval == 40000) { return -3; } x = (double)sampleval / 32768.0; x = filter(x); x = dilate(x); x = median(x); x = make_decision(x,d); b_median(d); update_level(x); // print_deep_debug("t: %d, d6 %d, d5 %d, x %0.5f\n", t, d[6], d[5], x); // activation test if(d[6] && t_active == 0) { print_deep_debug(" - act - "); t_active = t; t_byte = 0; n_bytes = 0; update_status("Analyse du signal..."); } if(t_active == 0) return -1; // deactivation test after a long period of inactivity if(t > t_active + 10000) { update_status("Désactivation pour cause d'inactivité"); return -2; } // new byte? if(t_byte == 0 && d[5]) { // new byte print_deep_debug(" -- new byte -- "); t_active = t_byte = t; n_bytes++; byte = 0; for(i = 0;i < 6;i++) c[i] = 0; } // processing a byte? if(t_byte > 0) { j = (t - t_byte) / 88; // bit number; the duration of a bit is very close to 2ms=88.2 samples if(j >= 10) { // end of the byte print_deep_debug(" [b = %d ] ", byte); if((byte & 1) == 0) { // first bit (lsb) must be a one print_debug("Bad byte start"); return -2; } if(byte >= 512) { // last bit (msb) must be a zero print_debug("Bad byte finish"); return -2; } byte >>= 1; t_byte = 0; if(n_bytes > 5) { return byte; } if(byte != 0xAA) { // bad synchronization byte print_debug("Bad synchronization byte."); return -2; } print_debug("Found good synchronization byte."); return -1; // discard synchronization byte }
Stitcher::Status Stitcher::composePanorama(InputArrayOfArrays images, OutputArray pano) { CV_INSTRUMENT_REGION(); LOGLN("Warping images (auxiliary)... "); std::vector<UMat> imgs; images.getUMatVector(imgs); if (!imgs.empty()) { CV_Assert(imgs.size() == imgs_.size()); UMat img; seam_est_imgs_.resize(imgs.size()); for (size_t i = 0; i < imgs.size(); ++i) { imgs_[i] = imgs[i]; resize(imgs[i], img, Size(), seam_scale_, seam_scale_, INTER_LINEAR_EXACT); seam_est_imgs_[i] = img.clone(); } std::vector<UMat> seam_est_imgs_subset; std::vector<UMat> imgs_subset; for (size_t i = 0; i < indices_.size(); ++i) { imgs_subset.push_back(imgs_[indices_[i]]); seam_est_imgs_subset.push_back(seam_est_imgs_[indices_[i]]); } seam_est_imgs_ = seam_est_imgs_subset; imgs_ = imgs_subset; } UMat pano_; #if ENABLE_LOG int64 t = getTickCount(); #endif std::vector<Point> corners(imgs_.size()); std::vector<UMat> masks_warped(imgs_.size()); std::vector<UMat> images_warped(imgs_.size()); std::vector<Size> sizes(imgs_.size()); std::vector<UMat> masks(imgs_.size()); // Prepare image masks for (size_t i = 0; i < imgs_.size(); ++i) { masks[i].create(seam_est_imgs_[i].size(), CV_8U); masks[i].setTo(Scalar::all(255)); } // Warp images and their masks Ptr<detail::RotationWarper> w = warper_->create(float(warped_image_scale_ * seam_work_aspect_)); for (size_t i = 0; i < imgs_.size(); ++i) { Mat_<float> K; cameras_[i].K().convertTo(K, CV_32F); K(0,0) *= (float)seam_work_aspect_; K(0,2) *= (float)seam_work_aspect_; K(1,1) *= (float)seam_work_aspect_; K(1,2) *= (float)seam_work_aspect_; corners[i] = w->warp(seam_est_imgs_[i], K, cameras_[i].R, INTER_LINEAR, BORDER_REFLECT, images_warped[i]); sizes[i] = images_warped[i].size(); w->warp(masks[i], K, cameras_[i].R, INTER_NEAREST, BORDER_CONSTANT, masks_warped[i]); } LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec"); // Compensate exposure before finding seams exposure_comp_->feed(corners, images_warped, masks_warped); for (size_t i = 0; i < imgs_.size(); ++i) exposure_comp_->apply(int(i), corners[i], images_warped[i], masks_warped[i]); // Find seams std::vector<UMat> images_warped_f(imgs_.size()); for (size_t i = 0; i < imgs_.size(); ++i) images_warped[i].convertTo(images_warped_f[i], CV_32F); seam_finder_->find(images_warped_f, corners, masks_warped); // Release unused memory seam_est_imgs_.clear(); images_warped.clear(); images_warped_f.clear(); masks.clear(); LOGLN("Compositing..."); #if ENABLE_LOG t = getTickCount(); #endif UMat img_warped, img_warped_s; UMat dilated_mask, seam_mask, mask, mask_warped; //double compose_seam_aspect = 1; double compose_work_aspect = 1; bool is_blender_prepared = false; double compose_scale = 1; bool is_compose_scale_set = false; std::vector<detail::CameraParams> cameras_scaled(cameras_); UMat full_img, img; for (size_t img_idx = 0; img_idx < imgs_.size(); ++img_idx) { LOGLN("Compositing image #" << indices_[img_idx] + 1); #if ENABLE_LOG int64 compositing_t = getTickCount(); #endif // Read image and resize it if necessary full_img = imgs_[img_idx]; if (!is_compose_scale_set) { if (compose_resol_ > 0) compose_scale = std::min(1.0, std::sqrt(compose_resol_ * 1e6 / full_img.size().area())); is_compose_scale_set = true; // Compute relative scales //compose_seam_aspect = compose_scale / seam_scale_; compose_work_aspect = compose_scale / work_scale_; // Update warped image scale float warp_scale = static_cast<float>(warped_image_scale_ * compose_work_aspect); w = warper_->create(warp_scale); // Update corners and sizes for (size_t i = 0; i < imgs_.size(); ++i) { // Update intrinsics cameras_scaled[i].ppx *= compose_work_aspect; cameras_scaled[i].ppy *= compose_work_aspect; cameras_scaled[i].focal *= compose_work_aspect; // Update corner and size Size sz = full_img_sizes_[i]; if (std::abs(compose_scale - 1) > 1e-1) { sz.width = cvRound(full_img_sizes_[i].width * compose_scale); sz.height = cvRound(full_img_sizes_[i].height * compose_scale); } Mat K; cameras_scaled[i].K().convertTo(K, CV_32F); Rect roi = w->warpRoi(sz, K, cameras_scaled[i].R); corners[i] = roi.tl(); sizes[i] = roi.size(); } } if (std::abs(compose_scale - 1) > 1e-1) { #if ENABLE_LOG int64 resize_t = getTickCount(); #endif resize(full_img, img, Size(), compose_scale, compose_scale, INTER_LINEAR_EXACT); LOGLN(" resize time: " << ((getTickCount() - resize_t) / getTickFrequency()) << " sec"); } else img = full_img; full_img.release(); Size img_size = img.size(); LOGLN(" after resize time: " << ((getTickCount() - compositing_t) / getTickFrequency()) << " sec"); Mat K; cameras_scaled[img_idx].K().convertTo(K, CV_32F); #if ENABLE_LOG int64 pt = getTickCount(); #endif // Warp the current image w->warp(img, K, cameras_[img_idx].R, INTER_LINEAR, BORDER_REFLECT, img_warped); LOGLN(" warp the current image: " << ((getTickCount() - pt) / getTickFrequency()) << " sec"); #if ENABLE_LOG pt = getTickCount(); #endif // Warp the current image mask mask.create(img_size, CV_8U); mask.setTo(Scalar::all(255)); w->warp(mask, K, cameras_[img_idx].R, INTER_NEAREST, BORDER_CONSTANT, mask_warped); LOGLN(" warp the current image mask: " << ((getTickCount() - pt) / getTickFrequency()) << " sec"); #if ENABLE_LOG pt = getTickCount(); #endif // Compensate exposure exposure_comp_->apply((int)img_idx, corners[img_idx], img_warped, mask_warped); LOGLN(" compensate exposure: " << ((getTickCount() - pt) / getTickFrequency()) << " sec"); #if ENABLE_LOG pt = getTickCount(); #endif img_warped.convertTo(img_warped_s, CV_16S); img_warped.release(); img.release(); mask.release(); // Make sure seam mask has proper size dilate(masks_warped[img_idx], dilated_mask, Mat()); resize(dilated_mask, seam_mask, mask_warped.size(), 0, 0, INTER_LINEAR_EXACT); bitwise_and(seam_mask, mask_warped, mask_warped); LOGLN(" other: " << ((getTickCount() - pt) / getTickFrequency()) << " sec"); #if ENABLE_LOG pt = getTickCount(); #endif if (!is_blender_prepared) { blender_->prepare(corners, sizes); is_blender_prepared = true; } LOGLN(" other2: " << ((getTickCount() - pt) / getTickFrequency()) << " sec"); LOGLN(" feed..."); #if ENABLE_LOG int64 feed_t = getTickCount(); #endif // Blend the current image blender_->feed(img_warped_s, mask_warped, corners[img_idx]); LOGLN(" feed time: " << ((getTickCount() - feed_t) / getTickFrequency()) << " sec"); LOGLN("Compositing ## time: " << ((getTickCount() - compositing_t) / getTickFrequency()) << " sec"); } #if ENABLE_LOG int64 blend_t = getTickCount(); #endif UMat result, result_mask; blender_->blend(result, result_mask); LOGLN("blend time: " << ((getTickCount() - blend_t) / getTickFrequency()) << " sec"); LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec"); // Preliminary result is in CV_16SC3 format, but all values are in [0,255] range, // so convert it to avoid user confusing result.convertTo(pano, CV_8U); return OK; }
Result CalSpermCount::calNum(Mat img) { Mat tmp, tmp_back; // int col = 800, row = 600; Size dsize = Size(nshowcol, nshowrow); Mat image2show = Mat(dsize,CV_8U); GaussianBlur(img,img,cv::Size(5,5), 1.5); if(nShowMidRst) ShowImage("after filtering", img); //cvSmooth(img, img, CV_MEDIAN, 3, 0, 0, 0); //中值滤波,消除小的噪声; //Mat element(9,9,CV_8U,Scalar(1)); Mat element = getStructuringElement(MORPH_RECT,Size(10,10)); erode(img, tmp,element); //ShowImage("erode",tmp); dilate(tmp,tmp_back,element); ::resize(tmp_back, image2show,dsize); //cvNamedWindow("dilate"); //imshow("dilate", image2show); //ShowImage("dilate",tmp_back); morphologyEx(img,dst_gray,MORPH_TOPHAT,element); //morphologyEx(img,dst_gray,MORPH_BLACKHAT,cv::Mat()); //dst_gray = img; //绘制直方图 Histgram1D hist; hist.stretch(dst_gray,0.01f); if(nShowMidRst) ShowImage("Histogram", hist.getHistogramImage(dst_gray, 1)); Mat tmpImage; //::equalizeHist(dst_gray,tmpImage); //ShowImage("拉伸后", tmpImage); //ShowImage("拉伸后Histogram", hist.getHistogramImage(tmpImage, 1)); if(nShowMidRst) { ShowImage("Picture EQ", hist.stretch(dst_gray, 50)); ShowImage("after draw, Histogram", hist.getHistogramImage(hist.stretch(dst_gray,50), 1)); } dst_gray = hist.stretch(dst_gray, 50); //dst_gray = ::equalizeHist(dst_gray,dst_gray); //dst_gray = tmp_back - img ; //dst_gray = img ; ::resize(dst_gray, image2show,dsize); #if 0 // No GUI if(nShowMidRst) cvNamedWindow(WINDOWNAME); ::createTrackbar("filter pattern",WINDOWNAME,&g_nThresholdType,4,on_Theshold); createTrackbar("theshold value",WINDOWNAME,&g_nThresholdValue,255,on_Theshold); #endif //初始化自定义回调函数 on_Theshold(0,0); //adaptiveThreshold(dst_gray,dstimgbw,255,adaptive_method,CV_THRESH_BINARY,blocksize,0); //cvAdaptiveThreshold(img, dst_bw,255,adaptive_method,//自适应阀值,blocksize为奇数 // CV_THRESH_BINARY,blocksize,offset); // ::resize(dstimgbw, image2show,dsize); // cvNamedWindow("src2"); // imshow("src2", image2show); // waitKey(0); vector<vector<Point> > contours; findContours(dstimgbw,contours,CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); Mat rst(img.size(),CV_8U,Scalar(0)); drawContours(rst,contours,-1,255,1); int cmin = minArea; int cmax = maxArea; vector<vector<Point> >::iterator itc = contours.begin(); int i = 0; result.LittleNum = 0; result.AimNum = 0; result.LargeNum = 0; fallcount = contours.size(); while(itc!=contours.end()) { if(itc->size() < cmin ) { result.LittleNum ++; itc = contours.erase(itc); //i++; } else if(itc->size() > cmax) { itc = contours.erase(itc); result.LargeNum ++; } else { result.AimNum ++; cout <<i<<" = "<< itc->size()<<endl; i++; ++itc; } } Mat rst2(img.size(),CV_8UC3,Scalar(0,0,0)); drawContours(rst2,contours,-1,cv::Scalar(255,255,255),1); char sz1[MAX_PATH],sz2[MAX_PATH],sz3[MAX_PATH]; char sz4[MAX_PATH]; char szError[MAX_PATH] = " "; fcount = fratio * result.AimNum; if(result.LittleNum/fallcount > fminRatio || result.LargeNum/fallcount > fmaxRatio) sprintf(szError,"Sample is dirty"); sprintf(sz1,"Aim Num = %d", result.AimNum); sprintf(sz2,"Little Num=%d", result.LittleNum); sprintf(sz3,"Large Num=%d", result.LargeNum); sprintf(sz4,"Count =%3.3f", fcount); putText(rst2,sz1,cv::Point(10,10),cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(255,0,0), 2); putText(rst2,sz2,cv::Point(10,30),cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(255,0,0), 2); putText(rst2,sz3,cv::Point(10,50),cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(255,0,0), 2); putText(rst2,sz4,cv::Point(10,70),cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(255,0,255), 2); putText(rst2,szError,cv::Point(10,90),cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(0,0,255), 2); cout << "Aim Num = "<<result.AimNum<<endl; cout << "Little Num = "<<result.LittleNum<<endl; cout << "Large Num = "<<result.LargeNum<<endl; cout << "Count = "<<fcount<<endl; cout << "all = "<<contours.size()<<endl; ShowImage("result",rst2); //waitKey(0); return result; }
void KinectController::updateAnalisys(ofxKinect & kinect, float bbX, float bbY, float bbZ, float bbW, float bbH, float bbD){ if(kinect.isFrameNew()){ static int counter = 0; int w = 640; int h = 480; #if ANGLE_FROM_ACCEL //ofVec3f worldOffset(worldX,worldY,worldZ); ofMatrix4x4 m = camTransform.getModelViewMatrix(); int i = 0; for(int y = 0; y < h; y +=step) { for(int x = 0; x < w; x +=step) { const short & distance = kinect.getRawDepthPixelsRef()[x+y*w]; //if(distance > 0) { const ofVec3f & v = kinect.getWorldCoordinateAt(x, y, distance); /*if(correctAngle){ v = v*m; } if(!applyBB || insideBB3D(v,ofVec3f(bbX,bbY,bbZ), ofVec3f(bbW, bbH, bbD))){*/ mesh.getVertices()[i] = v; /*}else{ mesh.getVertices()[i].set(0,0,0); }*/ //} i++; } } #elif ANGLE_FROM_PCL_GROUND_PLANE pcl::PointCloud<pcl::PointXYZ>::Ptr pcPtr = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>); for(int y = 0; y < h; y += step) { for(int x = 0; x < w; x += step) { //if(kinect.getDistanceAt(x, y) > 0) { float z = kinect.getDistanceAt(x, y); pcPtr->push_back(pcl::PointXYZ(x,y,z)); //} } } pcPtr->width=640; pcPtr->height=480; pcl::ModelCoefficients::Ptr planeCoeffs = fitPlane<pcl::PointXYZ>(pcPtr,10,5); plane.set(planeCoeffs->values[0],planeCoeffs->values[1],planeCoeffs->values[2],planeCoeffs->values[3]); for(int i=0;i<pcPtr->points.size();i++){ ofVec3f v(pcPtr->points[i].x,pcPtr->points[i].y,pcPtr->points[i].z); if(plane.distanceToPoint(v)>60) mesh.addVertex( kinect.getWorldCoordinateAt(v.x, v.y, v.z) ); } //pcPtr = findAndSubtractPlane<pcl::PointXYZ>(pcPtr,60,5); //ofxPCL::toOf(pcPtr,mesh,1,1,1); #elif CV_ANALISYS cv::Mat backgroundMat = toCv(background); if(captureBg>0){ backgroundMat += toCv(kinect.getDistancePixelsRef()); captureBg--; }else if(captureBg==0){ backgroundMat /= 10; cv::GaussianBlur(backgroundMat,backgroundMat,Size(11,11),10); captureBg=-1; }else{ // difference threshold cv::Mat diffMat = toCv(diff); cv::Mat currentMat = toCv(kinect.getDistancePixelsRef()); cv::Mat gaussCurrentMat = toCv(gaussCurrent); cv::GaussianBlur(currentMat,gaussCurrentMat,Size(11,11),10); cv::absdiff(backgroundMat, gaussCurrentMat, diffMat); //diffMat = toCv(background) - toCv(kinect.getDistancePixelsRef()); threshold(diff,thresPix,.001); thres8Bit = thresPix; cv::Mat kernel; cv::Mat thresMat = toCv(thres8Bit); cv::Point anchor(-1,-1); erode(toCv(thres8Bit),thresMat,kernel,anchor,10); dilate(toCv(thres8Bit),thresMat,kernel,anchor,5); cv::Mat fgMat = toCv(fg); bgSubstractor(toCv(thres8Bit),fgMat); contourFinder.findContours(fg); for(int i=0;i<oscContours.size();i++){ oscContours[i]->newFrame(frame); } polylines = contourFinder.getPolylines(); for(int i=0;i<(int)polylines.size();i++){ ofPoint centroid = polylines[i].getCentroid2D(); polylines[i] = polylines[i].getResampledByCount(16); float z = kinect.getDistanceAt(centroid); for(int j=0;j<oscContours.size();j++){ oscContours[j]->sendBlob(polylines[i],z); } } frame++; if(recording){ //convertColor(kinect.getDepthPixelsRef(),rgbDepth,CV_GRAY2RGB); recorder.addFrame(kinect.getRawDepthPixelsRef()); } } #endif } }
void camera_contours_display(int num, Straightener & straight) { int c; IplImage* color_img; CvCapture* cv_cap = cvCaptureFromCAM(num); cvNamedWindow("Video", 0); // create window resizeWindow("Video", 700,700); for(;;) { color_img = cvQueryFrame(cv_cap); // get frame if(color_img != 0) { Mat cam_mat(color_img); Mat result; cam_mat.copyTo(result); if(straight.doAll(cam_mat, result)) { ///Apply blur blur(result, result, Size(3,3)); ///Apply Canny to destination Matrix Canny(result, result, 50, 50, 3); /// Vectors for storing contours vector<vector<Point> > contours; //contours of the paper sheet vector<vector<Point> > approx_contours; //approx contours of the paper sheet vector<Vec4i> hierarchy; int erosion_type = 2; int erosion_size = 3; Mat element = getStructuringElement(erosion_type, Size( 2*erosion_size + 1, 2*erosion_size+1), Point( erosion_size, erosion_size)); dilate(result, result, element); /// Cut 20 px from each side to avoid paper borders detection result = result(Rect(10, 10, result.cols-20, result.rows-20)); findContours(result, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point(0, 0)); /// Draw contours Mat drawing = Mat::zeros( result.size(), CV_8UC3 ); /// https://github.com/Itseez/opencv/blob/master/samples/cpp/contours2.cpp // approx_contours.resize(contours.size()); for(unsigned int i = 0; i < contours.size(); i++) { /// Area of more than 20 and no parent if(contourArea(contours[i]) > 20 && hierarchy[i][3] == -1) { vector<Point> tmp_contour; approxPolyDP(Mat(contours[i]), tmp_contour, 3, true); approx_contours.push_back(tmp_contour); } } for(unsigned int i=0; i < approx_contours.size(); i++) { Scalar color; if(approx_contours[i].size() == 4) { color = Scalar( 255, 255, 255); drawContours( drawing, approx_contours, i, color, 1, 8, NULL, 0, Point() ); } else { color = Scalar( 0, 255, 0); drawContours( drawing, approx_contours, i, color, 1, 8, NULL, 0, Point() ); } } imshow("Video", drawing); } } c = cvWaitKey(10); // wait 10 ms or for key stroke if(c == 27) break; // if ESC, break and quit } /* clean up */ cvReleaseCapture( &cv_cap ); cvDestroyWindow("Video"); }
void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners, int maxCorners, double qualityLevel, double minDistance, InputArray _mask, int blockSize, bool useHarrisDetector, double harrisK ) { Mat image = _image.getMat(), mask = _mask.getMat(); CV_Assert( qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0 ); CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()) ); Mat eig, tmp; if( useHarrisDetector ) cornerHarris( image, eig, blockSize, 3, harrisK ); else cornerMinEigenVal( image, eig, blockSize, 3 ); double maxVal = 0; minMaxLoc( eig, 0, &maxVal, 0, 0, mask ); threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO ); dilate( eig, tmp, Mat()); Size imgsize = image.size(); vector<const float*> tmpCorners; // collect list of pointers to features - put them into temporary image for( int y = 1; y < imgsize.height - 1; y++ ) { const float* eig_data = (const float*)eig.ptr(y); const float* tmp_data = (const float*)tmp.ptr(y); const uchar* mask_data = mask.data ? mask.ptr(y) : 0; for( int x = 1; x < imgsize.width - 1; x++ ) { float val = eig_data[x]; if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) ) tmpCorners.push_back(eig_data + x); } } sort( tmpCorners, greaterThanPtr<float>() ); vector<Point2f> corners; size_t i, j, total = tmpCorners.size(), ncorners = 0; if(minDistance >= 1) { // Partition the image into larger grids int w = image.cols; int h = image.rows; const int cell_size = cvRound(minDistance); const int grid_width = (w + cell_size - 1) / cell_size; const int grid_height = (h + cell_size - 1) / cell_size; std::vector<std::vector<Point2f> > grid(grid_width*grid_height); minDistance *= minDistance; for( i = 0; i < total; i++ ) { int ofs = (int)((const uchar*)tmpCorners[i] - eig.data); int y = (int)(ofs / eig.step); int x = (int)((ofs - y*eig.step)/sizeof(float)); bool good = true; int x_cell = x / cell_size; int y_cell = y / cell_size; int x1 = x_cell - 1; int y1 = y_cell - 1; int x2 = x_cell + 1; int y2 = y_cell + 1; // boundary check x1 = std::max(0, x1); y1 = std::max(0, y1); x2 = std::min(grid_width-1, x2); y2 = std::min(grid_height-1, y2); for( int yy = y1; yy <= y2; yy++ ) { for( int xx = x1; xx <= x2; xx++ ) { vector <Point2f> &m = grid[yy*grid_width + xx]; if( m.size() ) { for(j = 0; j < m.size(); j++) { float dx = x - m[j].x; float dy = y - m[j].y; if( dx*dx + dy*dy < minDistance ) { good = false; goto break_out; } } } } } break_out: if(good) { // printf("%d: %d %d -> %d %d, %d, %d -- %d %d %d %d, %d %d, c=%d\n", // i,x, y, x_cell, y_cell, (int)minDistance, cell_size,x1,y1,x2,y2, grid_width,grid_height,c); grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x, (float)y)); corners.push_back(Point2f((float)x, (float)y)); ++ncorners; if( maxCorners > 0 && (int)ncorners == maxCorners ) break; } } } else { for( i = 0; i < total; i++ ) { int ofs = (int)((const uchar*)tmpCorners[i] - eig.data); int y = (int)(ofs / eig.step); int x = (int)((ofs - y*eig.step)/sizeof(float)); corners.push_back(Point2f((float)x, (float)y)); ++ncorners; if( maxCorners > 0 && (int)ncorners == maxCorners ) break; } } Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F); /* for( i = 0; i < total; i++ ) { int ofs = (int)((const uchar*)tmpCorners[i] - eig.data); int y = (int)(ofs / eig.step); int x = (int)((ofs - y*eig.step)/sizeof(float)); if( minDistance > 0 ) { for( j = 0; j < ncorners; j++ ) { float dx = x - corners[j].x; float dy = y - corners[j].y; if( dx*dx + dy*dy < minDistance ) break; } if( j < ncorners ) continue; } corners.push_back(Point2f((float)x, (float)y)); ++ncorners; if( maxCorners > 0 && (int)ncorners == maxCorners ) break; } */ }
vector<Point2f> find_corners(Mat &src, unsigned int rows, unsigned int cols) { vector<cv::Vec4i> slines; vector<par_line> par_lines; vector<par_line> borders; bool new_corners = false; vector<Point2f> corners; vector<Point2f> quad_pts; Mat temp; blur(src, temp, Size(5,5)); Canny(temp, temp, 100, 100, 3); int erosion_type = 1; int erosion_size = 1; Mat element = getStructuringElement( erosion_type, Size( 2*erosion_size + 1, 2*erosion_size+1 ), Point( erosion_size, erosion_size ) ); dilate(temp, temp, element); HoughLinesP(temp, slines, 1, CV_PI/360, 120,100, 10); if ( slines.size() < 4 ) { ///cout << "Hough: Znaleziono mniej niż 4 linie."; new_corners = false; } else { for( unsigned int i = 0; i < slines.size(); i++ ) { Vec4i l = slines[i]; par_line tmp_line; /// Pionowa linia - b na dużą wartość if( abs(l[2]-l[0]) == 0 ){ // znak (chyba) OK tmp_line.b = -(l[3]-l[1])/abs(l[3]-l[1])*1.e15; } else { tmp_line.b = l[1] - (double)(l[3]-l[1])/((double)(l[2]-l[0]))*l[0]; } tmp_line.atana = atan2((double)(l[3]-l[1]),((double)(l[2]-l[0]))); tmp_line.len = sqrt(pow( (double)(l[0]-l[2]), 2.0 ) + pow( (double)(l[1]-l[3]), 2.0 )); par_lines.push_back(tmp_line); } /// Uśrednione linie będące krawędziami kartki /// Dla każdej linii znajdź taką, która mieści się w zakresie +- 10 stopni /// Pierwsza linia trafia od razu borders.push_back(par_lines[0]); for( unsigned int i = 1; i < par_lines.size(); i++ ) { bool found_similiar = false; for ( unsigned int j = 0; j < borders.size(); j++ ) { /// Nowy odcinek podobny do któregoś z istniejących if ( abs(abs(par_lines[i].atana) - abs(borders[j].atana)) < 10.0*3.14159/180.0 && abs(par_lines[i].b - borders[j].b) < 150.0 ) { /// Nowa wartość jako średnia ważona borders[j].atana = (borders[j].atana*borders[j].len + par_lines[i].atana*par_lines[i].len) / (borders[j].len + par_lines[i].len); borders[j].b = (borders[j].b*borders[j].len + par_lines[i].b*par_lines[i].len) / (borders[j].len + par_lines[i].len); /// Zapisz nową długość uśrednionej prostej borders[j].len = borders[j].len + par_lines[i].len; found_similiar = true; } } /// Jeżeli żaden element nie był podobny, dodaj nową krawędź if ( !found_similiar ) { borders.push_back(par_lines[i]); } } if ( borders.size() < 4 ) { ///cout << "Zbudowano mniej niż 3 boki obwiedni."; new_corners = false; } else { // usuwanie najkrótszych linii while(borders.size() > 4) { unsigned char i = 0; double minlen = 1.e30; // nieskończoność for(unsigned char j = 0; j < borders.size(); j++) { if(borders[i].len > borders[j].len) { i = j; minlen = borders[j].len; } } borders.erase(borders.begin()+i); } /// Znajdź narożniki for (unsigned int i = 0; i < borders.size(); i++){ for (unsigned int j = i+1; j < borders.size(); j++){ /// Znajdź przecięcie między nierównoległymi do siebie brzegami kartki if( abs(abs(borders[i].atana)-abs(borders[j].atana)) > 45.0*3.14159/180.0 ) { Point2f p; p.x = (borders[i].b - borders[j].b) / ((tan(borders[j].atana) - tan(borders[i].atana))); p.y = p.x * tan(borders[i].atana) + borders[i].b; corners.push_back(p); } } } if ( corners.size() < 4 ) { new_corners = false; } else { /// Oblicz środek masy Point2f center(0,0); for ( unsigned int i = 0; i < corners.size(); i++ ) { center += corners[i]; } center *= (1. / corners.size()); /// Posortuj narożniki sortCorners(corners, center); new_corners = true; } } } /// Jeżeli to pierwszy przebieg, skopiuj narożniki if( corners_old.size() == 0 ) { corners_old = corners; } /// Jeżeli są nowe narożniki if( new_corners ) { /// Co 20 klatkę odświeżaj narożniki, aby uniknąć przekrzywienia po obrocie i powrocie if( refresh_corners > 20 ){ corners_old = corners; refresh_corners = 0; } else { refresh_corners += 1; bool close_corner_found [4]; for( int i = 0; i < 4; i++ ) { close_corner_found[i] = false; Point2f c = corners_old[i]; for( int j = 0; j < 4; j++ ) { Point2f k = corners[j]; if( abs(k.y - c.y) < 100 && abs(k.x - c.x) < 100 ) { close_corner_found[i] = true; } } } if ( close_corner_found[0] && close_corner_found[1] && close_corner_found[2] && close_corner_found[3] ) { corners_old = corners; } } } if( corners_old.size() == 4 ) { return corners_old; } else { vector<Point2f> empty; empty.clear(); return empty; } }
int main(int argc, char ** argv) { acc_init(acc_device_cuda); acc_set_device_num(0, acc_device_cuda); // Keep track of the start time of the program long long program_start_time = get_time(); // Let the user specify the number of frames to process int num_frames = 1; if (argc != 3){ fprintf(stderr, "usage: %s <input file> <num of frames>", argv[0]); exit(1); } num_frames = atoi(argv[2]); // Open video file char *video_file_name; video_file_name = argv[1]; avi_t *cell_file = AVI_open_input_file(video_file_name, 1); if (cell_file == NULL) { AVI_print_error("Error with AVI_open_input_file"); return -1; } int i, j, *crow, *ccol, pair_counter = 0, x_result_len = 0, Iter = 20, ns = 4, k_count = 0, n; MAT *cellx, *celly, *A; double *GICOV_spots, *t, *G, *x_result, *y_result, *V, *QAX_CENTERS, *QAY_CENTERS; double threshold = 1.8, radius = 10.0, delta = 3.0, dt = 0.01, b = 5.0; // Extract a cropped version of the first frame from the video file MAT *image_chopped = get_frame(cell_file, 0, 1, 0); printf("Detecting cells in frame 0\n"); // Get gradient matrices in x and y directions MAT *grad_x = gradient_x(image_chopped); MAT *grad_y = gradient_y(image_chopped); m_free(image_chopped); // Get GICOV matrix corresponding to image gradients long long GICOV_start_time = get_time(); /* MAT *gicov = ellipsematching(grad_x, grad_y); // Square GICOV values MAT *max_gicov = m_get(gicov->m, gicov->n); for (i = 0; i < gicov->m; i++) { for (j = 0; j < gicov->n; j++) { double val = m_get_val(gicov, i, j); m_set_val(max_gicov, i, j, val * val); } } */ MAT *gicov = GICOV(grad_x, grad_y); long long GICOV_end_time = get_time(); // Dilate the GICOV matrix long long dilate_start_time = get_time(); //MAT *strel = structuring_element_f(12); //MAT *img_dilated = dilate_f(gicov, strel); MAT *img_dilated = dilate(gicov); long long dilate_end_time = get_time(); // Find possible matches for cell centers based on GICOV and record the rows/columns in which they are found pair_counter = 0; crow = (int *) malloc(gicov->m * gicov->n * sizeof(int)); ccol = (int *) malloc(gicov->m * gicov->n * sizeof(int)); for (i = 0; i < gicov->m; i++) { for (j = 0; j < gicov->n; j++) { if (!(m_get_val(gicov,i,j) == 0.0) && (m_get_val(img_dilated,i,j) == m_get_val(gicov,i,j))) { crow[pair_counter] = i; ccol[pair_counter] = j; pair_counter++; } } } GICOV_spots = (double *) malloc(sizeof(double)*pair_counter); for (i = 0; i < pair_counter; i++) GICOV_spots[i] = sqrt(m_get_val(gicov, crow[i], ccol[i])); G = (double *) calloc(pair_counter, sizeof(double)); x_result = (double *) calloc(pair_counter, sizeof(double)); y_result = (double *) calloc(pair_counter, sizeof(double)); x_result_len = 0; for (i = 0; i < pair_counter; i++) { if ((crow[i] > 29) && (crow[i] < BOTTOM - TOP + 39)) { x_result[x_result_len] = ccol[i]; y_result[x_result_len] = crow[i] - 40; G[x_result_len] = GICOV_spots[i]; x_result_len++; } } // Make an array t which holds each "time step" for the possible cells t = (double *) malloc(sizeof(double) * 36); for (i = 0; i < 36; i++) { t[i] = (double)i * 2.0 * PI / 36.0; } // Store cell boundaries (as simple circles) for all cells cellx = m_get(x_result_len, 36); celly = m_get(x_result_len, 36); for(i = 0; i < x_result_len; i++) { for(j = 0; j < 36; j++) { m_set_val(cellx, i, j, x_result[i] + radius * cos(t[j])); m_set_val(celly, i, j, y_result[i] + radius * sin(t[j])); } } A = TMatrix(9,4); V = (double *) malloc(sizeof(double) * pair_counter); QAX_CENTERS = (double * )malloc(sizeof(double) * pair_counter); QAY_CENTERS = (double *) malloc(sizeof(double) * pair_counter); memset(V, 0, sizeof(double) * pair_counter); memset(QAX_CENTERS, 0, sizeof(double) * pair_counter); memset(QAY_CENTERS, 0, sizeof(double) * pair_counter); // For all possible results, find the ones that are feasibly leukocytes and store their centers k_count = 0; for (n = 0; n < x_result_len; n++) { if ((G[n] < -1 * threshold) || G[n] > threshold) { MAT * x, *y; VEC * x_row, * y_row; x = m_get(1, 36); y = m_get(1, 36); x_row = v_get(36); y_row = v_get(36); // Get current values of possible cells from cellx/celly matrices x_row = get_row(cellx, n, x_row); y_row = get_row(celly, n, y_row); uniformseg(x_row, y_row, x, y); // Make sure that the possible leukocytes are not too close to the edge of the frame if ((m_min(x) > b) && (m_min(y) > b) && (m_max(x) < cell_file->width - b) && (m_max(y) < cell_file->height - b)) { MAT * Cx, * Cy, *Cy_temp, * Ix1, * Iy1; VEC *Xs, *Ys, *W, *Nx, *Ny, *X, *Y; Cx = m_get(1, 36); Cy = m_get(1, 36); Cx = mmtr_mlt(A, x, Cx); Cy = mmtr_mlt(A, y, Cy); Cy_temp = m_get(Cy->m, Cy->n); for (i = 0; i < 9; i++) m_set_val(Cy, i, 0, m_get_val(Cy, i, 0) + 40.0); // Iteratively refine the snake/spline for (i = 0; i < Iter; i++) { int typeofcell; if(G[n] > 0.0) typeofcell = 0; else typeofcell = 1; splineenergyform01(Cx, Cy, grad_x, grad_y, ns, delta, 2.0 * dt, typeofcell); } X = getsampling(Cx, ns); for (i = 0; i < Cy->m; i++) m_set_val(Cy_temp, i, 0, m_get_val(Cy, i, 0) - 40.0); Y = getsampling(Cy_temp, ns); Ix1 = linear_interp2(grad_x, X, Y); Iy1 = linear_interp2(grad_x, X, Y); Xs = getfdriv(Cx, ns); Ys = getfdriv(Cy, ns); Nx = v_get(Ys->dim); for (i = 0; i < Ys->dim; i++) v_set_val(Nx, i, v_get_val(Ys, i) / sqrt(v_get_val(Xs, i)*v_get_val(Xs, i) + v_get_val(Ys, i)*v_get_val(Ys, i))); Ny = v_get(Xs->dim); for (i = 0; i < Xs->dim; i++) v_set_val(Ny, i, -1.0 * v_get_val(Xs, i) / sqrt(v_get_val(Xs, i)*v_get_val(Xs, i) + v_get_val(Ys, i)*v_get_val(Ys, i))); W = v_get(Nx->dim); for (i = 0; i < Nx->dim; i++) v_set_val(W, i, m_get_val(Ix1, 0, i) * v_get_val(Nx, i) + m_get_val(Iy1, 0, i) * v_get_val(Ny, i)); V[n] = mean(W) / std_dev(W); //get means of X and Y values for all "snaxels" of the spline contour, thus finding the cell centers QAX_CENTERS[k_count] = mean(X); QAY_CENTERS[k_count] = mean(Y) + TOP; k_count++; // Free memory v_free(W); v_free(Ny); v_free(Nx); v_free(Ys); v_free(Xs); m_free(Iy1); m_free(Ix1); v_free(Y); v_free(X); m_free(Cy_temp); m_free(Cy); m_free(Cx); } // Free memory v_free(y_row); v_free(x_row); m_free(y); m_free(x); } } // Free memory free(V); free(ccol); free(crow); free(GICOV_spots); free(t); free(G); free(x_result); free(y_result); m_free(A); m_free(celly); m_free(cellx); m_free(img_dilated); m_free(gicov); m_free(grad_y); m_free(grad_x); // Report the total number of cells detected printf("Cells detected: %d\n\n", k_count); // Report the breakdown of the detection runtime printf("Detection runtime\n"); printf("-----------------\n"); printf("GICOV computation: %.5f seconds\n", ((float) (GICOV_end_time - GICOV_start_time)) / (1000*1000)); printf(" GICOV dilation: %.5f seconds\n", ((float) (dilate_end_time - dilate_start_time)) / (1000*1000)); printf(" Total: %.5f seconds\n", ((float) (get_time() - program_start_time)) / (1000*1000)); // Now that the cells have been detected in the first frame, // track the ellipses through subsequent frames if (num_frames > 1) printf("\nTracking cells across %d frames\n", num_frames); else printf("\nTracking cells across 1 frame\n"); long long tracking_start_time = get_time(); int num_snaxels = 20; ellipsetrack(cell_file, QAX_CENTERS, QAY_CENTERS, k_count, radius, num_snaxels, num_frames); printf(" Total: %.5f seconds\n", ((float) (get_time() - tracking_start_time)) / (float) (1000*1000*num_frames)); // Report total program execution time printf("\nTotal application run time: %.5f seconds\n", ((float) (get_time() - program_start_time)) / (1000*1000)); return 0; }
void GrabCutMF::Demo(CStr &wkDir, float w1, float w2, float w3, float alpha, float beta, float gama, float mu) { CStr imgDir = wkDir + "Imgs/", salDir = wkDir + "Sal4N/", iluDir = wkDir + "Ilu4N/"; vecS namesNE; int imgNum = CmFile::GetNamesNE(imgDir + "*.jpg", namesNE); CmFile::MkDir(salDir); CmFile::MkDir(iluDir); printf("w1 = %g, w2 = %g, w3 = %g, alpha = %g, beta = %g, gama = %g, mu = %g\n", w1, w2, w3, alpha, beta, gama, mu); // Number of labels //const int M = 2; CmTimer tm("Time"), tmIni("TimeIni"), tmRef("TimeRef"); double maxWeight = 2; // 2: 0.958119, 1: 0.953818, tm.Start(); #pragma omp parallel for for (int i = 0; i < imgNum; i++){ printf("Processing %d/%d: %s%s.jpg%20s\r\n", i, imgNum, _S(imgDir), _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"), imMat3f, imMat3u, gt1u; Mat _gt1u = imread(imgDir + namesNE[i] + ".png", CV_LOAD_IMAGE_GRAYSCALE); if(_gt1u.rows == 0 && _gt1u.cols == 0) { cout<<"Error: unable to open "<<(imgDir + namesNE[i] + ".png")<<endl; continue; } blur(_gt1u, _gt1u, Size(3,3)); Mat _res1u = Mat::zeros(_imMat3u.size(), CV_8U); Rect wkRect = CmCv::GetMaskRange(_gt1u, 30, 200); _imMat3u(wkRect).copyTo(imMat3u); _gt1u(wkRect).copyTo(gt1u); imMat3u.convertTo(imMat3f, CV_32FC3, 1/255.0); Rect rect = CmCv::GetMaskRange(gt1u, 5, 128); Mat edge1u; // Use an edge map to expand the background mask in flat (no edge) region CmCv::CannySimpleRGB(imMat3u, edge1u, 120, 1200, 5); dilate(edge1u, edge1u, Mat(), Point(-1, -1), 3); Mat borderMask1u(imMat3u.size(), CV_8U), tmpMask; memset(borderMask1u.data, 255, borderMask1u.step.p[0] * borderMask1u.rows); borderMask1u(rect) = Scalar(0); getGrabMask(edge1u, borderMask1u); //* The Mean field based GrabCut //tmIni.Start(); GrabCutMF cutMF(imMat3f, imMat3u, salDir + namesNE[i], w1, w2, w3, alpha, beta, gama, mu); //Mat borderMask1u = CmCv::getGrabMask(imMat3u, rect), tmpMask; imwrite(salDir + namesNE[i] + "_BM.png", borderMask1u); imwrite(salDir + namesNE[i] + ".jpg", imMat3u); //imwrite(salDir + namesNE[i] + "_GT.png", gt1u); cutMF.initialize(rect, borderMask1u, (float)maxWeight, true); //cutMF.setGrabReg(rect, CmCv::getGrabMask(imMat3u, rect)); //tmIni.Stop(); //tmRef.Start(); cutMF.refine(); //tmRef.Stop(); Mat res1u = cutMF.drawResult(), invRes1u; res1u.copyTo(_res1u(wkRect)); imwrite(salDir + namesNE[i] + "_GCMF1.png", _res1u); //if (sum(res1u).val[0] < EPS){ // printf("%s.jpg don't contains a salient object\n", _S(namesNE[i])); // continue; //} dilate(res1u(rect), tmpMask, Mat(), Point(-1, -1), 10); bitwise_not(tmpMask, borderMask1u(rect)); getGrabMask(edge1u, borderMask1u); //blur(res1u, invRes1u, Size(3, 3)); // //PointSeti hullPnts; //convexHullOfMask(invRes1u, hullPnts); //fillConvexPoly(invRes1u, hullPnts, 255); //bitwise_not(invRes1u, invRes1u); //bitwise_or(invRes1u, borderMask1u, borderMask1u); imwrite(salDir + namesNE[i] + "_MB2.png", borderMask1u); //double w = maxWeight - (maxWeight-1)*sum(res1u).val[0]/(borderMask1u.rows*borderMask1u.cols*255 - sum(borderMask1u).val[0]); cutMF.initialize(rect, borderMask1u, 2); cutMF.refine(); //printf("weight = %g\n", w); //imshow("Result", res1u); //imshow("Possible", borderMask1u); //imshow("Image", imMat3f); //waitKey(0); res1u = cutMF.drawResult(); Rect rectRes = CmCv::GetMaskRange(res1u, 5, 128); if (rectRes.width * 1.1 < rect.width || rectRes.height * 1.1 < rect.height){ // Too short result printf("%s.jpg contains a small object\n", _S(namesNE[i])); memset(borderMask1u.data, 255, borderMask1u.step.p[0] * borderMask1u.rows); borderMask1u(rect) = Scalar(0); cutMF.initialize(rect, borderMask1u, 2); cutMF.refine(); res1u = cutMF.drawResult(); imwrite(salDir + namesNE[i] + "_MB2.png", borderMask1u); CmFile::Copy2Dir(salDir + namesNE[i] + "*.*", iluDir); imwrite(iluDir + namesNE[i] + "_GCMF.png", _res1u); } res1u.copyTo(_res1u(wkRect)); imwrite(salDir + namesNE[i] + "_GCMF.png", _res1u); } tm.Stop(); double avgTime = tm.TimeInSeconds()/imgNum; printf("Speed: %gs, %gfps\t\t\n", avgTime, 1/avgTime); //tmIni.Report(); //tmRef.Report(); //CmEvaluation::EvalueMask(imgDir + "*.png", salDir, ".png", "_GC.png"); char* pDes[] = { "GCMF1", "GCMF"}; //, "CudaG4", "Onecut", "GC", "CudaH", vecS des = charPointers2StrVec (pDes); CStr rootDir = CmFile::GetFatherFolder(wkDir), dbName = CmFile::GetNameNE(wkDir.substr(0, wkDir.size() - 1)); CmEvaluation::EvalueMask(imgDir + "*.png", salDir, des, wkDir.substr(0, wkDir.size() - 1) + "Res.m", 0.3, false, "", dbName); }
/////////////////////////////////////////////////////////////////// // Panel::CannyDetection() // Description: This function is called by DetectEdges() and it // is the Canny edge detection function which does not contain // debugging statements. We run the image through several different // image processing functions to prepare the image before edge // detection. After detection the edges we run Hough lines which // approximates lines of minimum length as specified in // Settings.xml. We find all intersections of the Hough lines // then make a minimum area rectangle around the intersections to // approximate the edges of the panel which we are trying to // measure. From there we use the unit conversion calculated // in DetectFeatures() to find a length and width of the current // panel. We report the length and width with a message box. /////////////////////////////////////////////////////////////////// Mat Panel::CannyDetection(Mat image, bool showImg) { Mat greyImage; cvtColor(image, greyImage, CV_BGR2GRAY); Mat eroded, dilated, thresh, blurredThresh, edges, edgesGray; vector<Vec2f> lines; threshold(greyImage, thresh, m_lowCannyThreshold, 255, THRESH_BINARY); erode(thresh, eroded, Mat()); dilate(eroded, dilated, Mat()); GaussianBlur(thresh, blurredThresh, Size(7, 7), m_sigmaX, m_sigmaY); Canny(blurredThresh, edges, m_cannyLow, m_cannyLow*m_ratio, 3); HoughLines(edges, lines, 1, CV_PI / 180, m_houghLength, 0, 0); cvtColor(edges, edgesGray, CV_GRAY2BGR); for (size_t i = 0; i < lines.size(); i++) { float rho = lines[i][0], theta = lines[i][1]; Point pt1, pt2; double a = cos(theta), b = sin(theta); double x0 = a*rho, y0 = b*rho; pt1.x = cvRound(x0 + 1000 * (-b)); pt1.y = cvRound(y0 + 1000 * (a)); pt2.x = cvRound(x0 - 1000 * (-b)); pt2.y = cvRound(y0 - 1000 * (a)); line(edgesGray, pt1, pt2, Scalar(0, 0, 255), 3, CV_AA); } //////////////////////////////////////////////////////// // Compute the intersection from the lines detected //////////////////////////////////////////////////////// vector<Point2f> intersections; for (size_t i = 0; i < lines.size(); i++) { for (size_t j = 0; j < lines.size(); j++) { Vec2f line1 = lines[i]; Vec2f line2 = lines[j]; if (acceptLinePair(line1, line2, (float)CV_PI / 32)) { Point2f intersection = computeIntersect(line1, line2); if (intersection.x >= 0 && intersection.y >= 0) intersections.push_back(intersection); } } } if (intersections.size() > 0) { vector<Point2f>::iterator i; for (i = intersections.begin(); i != intersections.end(); ++i) { cout << "Intersection is " << i->x << ", " << i->y << endl; circle(image, *i, 2, Scalar(0, 255, 0), 3); } // Find the minimum bounding rectangle RotatedRect rect; Point2f rectPoints[4]; Scalar color = Scalar(255, 0, 0); if (intersections.size() == 4) { // TODO } rect = minAreaRect(intersections); rect.points(rectPoints); int j = 0; for (j; j < 4; j++) line(image, rectPoints[j], rectPoints[(j + 1) % 4], color, 5, 8); float topLength = (float)norm(rectPoints[1] - rectPoints[0]); float botLength = (float)norm(rectPoints[3] - rectPoints[2]); float panelWidthPixels = topLength < botLength ? topLength : botLength; float leftHeight = (float)norm(rectPoints[3] - rectPoints[0]); float rightHeight = (float)norm(rectPoints[2] - rectPoints[1]); float panelHeightPixels = leftHeight < rightHeight ? leftHeight : rightHeight; string dimensionDisplayPixels = "Pixels:\nWidth: " + to_string(panelWidthPixels) + " pixels\nHeight: " + to_string(panelHeightPixels) + " pixels"; // ShowMessage(dimensionDisplayPixels); if (m_conversionRate) { float panelWidthReal = panelWidthPixels / m_conversionRate; float panelHeightReal = panelHeightPixels / m_conversionRate; string dimensionDisplayActual = "Actual:\nWidth: " + to_string(panelWidthReal) + " cm\nHeight: " + to_string(panelHeightReal) + " cm"; ShowMessage(dimensionDisplayActual); } } if (showImg){ namedWindow("Intersections", CV_WINDOW_KEEPRATIO); imshow("Intersections", image); } ///////////////////////////////////////////////////////////// // End of Computing the intersection from the lines detected ///////////////////////////////////////////////////////////// return edges; }
//-------------------------------------------------------------- void ofApp::update(){ kinect.update(); deltaTime = ofGetElapsedTimef() - lastTime; lastTime = ofGetElapsedTimef(); if (kinect.isFrameNew()) { // Load grayscale depth image from the kinect source grayImage.setFromPixels(kinect.getDepthPixels(), kinect.width, kinect.height, OF_IMAGE_GRAYSCALE); // Threshold image threshold(grayImage, grayThreshNear, nearThreshold, true); threshold(grayImage, grayThreshFar, farThreshold); // Convert to CV to perform AND operation Mat grayThreshNearMat = toCv(grayThreshNear); Mat grayThreshFarMat = toCv(grayThreshFar); Mat grayImageMat = toCv(grayImage); // cvAnd to get the pixels which are a union of the two thresholds bitwise_and(grayThreshNearMat, grayThreshFarMat, grayImageMat); // Save pre-processed image for drawing it grayPreprocImage = grayImage; // Process image dilate(grayImage); dilate(grayImage); //erode(grayImage); // Mark image as changed grayImage.update(); // Find contours //contourFinder.setThreshold(ofMap(mouseX, 0, ofGetWidth(), 0, 255)); contourFinder.findContours(grayImage); ofPushStyle(); ofEnableBlendMode(OF_BLENDMODE_DISABLED); cameraFbo.begin(); ofSetColor(ofColor::white); if (doFlipCamera) kinect.drawDepth(cameraFbo.getWidth(), 0, -cameraFbo.getWidth(), cameraFbo.getHeight()); // Flip Horizontal else kinect.drawDepth(0, 0, cameraFbo.getWidth(), cameraFbo.getHeight()); cameraFbo.end(); ofDisableBlendMode(); ofPopStyle(); opticalFlow.setSource(cameraFbo.getTexture()); opticalFlow.update(deltaTime); velocityMask.setDensity(cameraFbo.getTexture()); velocityMask.setVelocity(opticalFlow.getOpticalFlow()); velocityMask.update(); } fluidSimulation.addVelocity(opticalFlow.getOpticalFlowDecay()); fluidSimulation.addDensity(velocityMask.getColorMask()); fluidSimulation.addTemperature(velocityMask.getLuminanceMask()); mouseForces.update(deltaTime); for (int i=0; i<mouseForces.getNumForces(); i++) { if (mouseForces.didChange(i)) { switch (mouseForces.getType(i)) { case FT_DENSITY: fluidSimulation.addDensity(mouseForces.getTextureReference(i), mouseForces.getStrength(i)); break; case FT_VELOCITY: fluidSimulation.addVelocity(mouseForces.getTextureReference(i), mouseForces.getStrength(i)); particleFlow.addFlowVelocity(mouseForces.getTextureReference(i), mouseForces.getStrength(i)); break; case FT_TEMPERATURE: fluidSimulation.addTemperature(mouseForces.getTextureReference(i), mouseForces.getStrength(i)); break; case FT_PRESSURE: fluidSimulation.addPressure(mouseForces.getTextureReference(i), mouseForces.getStrength(i)); break; case FT_OBSTACLE: fluidSimulation.addTempObstacle(mouseForces.getTextureReference(i)); default: break; } } } fluidSimulation.update(); if (particleFlow.isActive()) { particleFlow.setSpeed(fluidSimulation.getSpeed()); particleFlow.setCellSize(fluidSimulation.getCellSize()); particleFlow.addFlowVelocity(opticalFlow.getOpticalFlow()); particleFlow.addFluidVelocity(fluidSimulation.getVelocity()); // particleFlow.addDensity(fluidSimulation.getDensity()); particleFlow.setObstacle(fluidSimulation.getObstacle()); } particleFlow.update(); }