int main() { #if VIDEO FollowVisibleFace video; #else JPSequence video; #endif #if HSV HSVFrameTransformation trans; #else GrayFrameTransformation trans; #endif switch (PART) { case 1: { ParticleFilter filter(video, trans); filter.track(); } break; case 2: { MeanShift meanShift(video, trans); meanShift.track(); } break; default: { PFMS pfms(video, trans); pfms.track(); } } return 0; }
QGraphicsScene * ClusteredArranger::arrange(SegmentList const & segments) const { QGraphicsScene * arrangement = new QGraphicsScene(); QTime time; time.start(); // determine background Segment * background = determineBackground(segments); SegmentList segmentsWOBack = removeBackground(segments, background); arrangement->setBackgroundBrush(QBrush(QColor(background->color().toQRgb()))); segmentsWOBack.calculateFeatureVariances(); // initialize layout //initializeLayout(segmentsWOBack, segmentsWOBack.featX(), segmentsWOBack.featY()); initializeLayout(segmentsWOBack, xAxisBox->currentIndex(), yAxisBox->currentIndex()); // find clusters time.restart(); QList<SegmentList> clusters = meanShift(segmentsWOBack); qDebug("Segments clustered in %f seconds", time.restart()/1000.0); qDebug(" %d clusters found", clusters.size()); // refine clusters //int counter = 0; foreach (SegmentList cluster, clusters) { if (clusterBox->currentIndex() == 0) { refineLayoutCircles(cluster); } else if (clusterBox->currentIndex() == 1) { refineLayoutPiles(cluster); } // debug output /*QGraphicsScene scene; scene.setBackgroundBrush(QBrush(QColor(255, 255, 255))); foreach(Segment * const segment, cluster) { scene.addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash scene.width(); } ++counter; saveScene(&scene, QString("Test%1.png").arg(counter, 2));*/ } // refine layout if (clusterBox->currentIndex() == 0) { refineLayoutByPlace(clusters); } else if (clusterBox->currentIndex() == 1) { refineLayoutBySize(clusters); } // convert the segments to QGraphicsItems and add to QGraphicsScene foreach(Segment const * const segment, segmentsWOBack) { arrangement->addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash arrangement->width(); }
/* see meanShift.m for usage info */ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { double radius, rate, *data, *labels, *means; int p, n, maxIter; bool blur; /* Check inputs */ if(nrhs < 4) mexErrMsgTxt("At least four input arguments required."); if(nlhs > 2) mexErrMsgTxt("Too many output arguments."); if(nrhs==5) blur = mxGetScalar(prhs[4])!=0; /* Get inputs */ data = mxGetPr(prhs[0]); radius = mxGetScalar(prhs[1]); rate = mxGetScalar(prhs[2]); maxIter = (int) mxGetScalar(prhs[3]); p=mxGetM(prhs[0]); n=mxGetN(prhs[0]); /* Create outputs */ plhs[0] = mxCreateNumericMatrix(n, 1, mxDOUBLE_CLASS, mxREAL); plhs[1] = mxCreateNumericMatrix(p, n, mxDOUBLE_CLASS, mxREAL); labels=mxGetPr(plhs[0]); means=mxGetPr(plhs[1]); /* Do the actual computations in a subroutine */ meanShift( data, p, n, radius, rate, maxIter, blur, labels, means ); }
int main(int argc, char** argv) { Point2f cp; cv::initModule_nonfree(); // Read the VIDEO VideoCapture cap("video1.avi"); if( !cap.isOpened() ) { cout << "Could not initialize capturing...\n"; return 0;} //Initialize Video Writer //writeOut.open("MStrack_3.avi", CV_FOURCC('M', 'J', 'P', 'G'), 15, Size(640,480), 1 ); cv::SURF mySURF; mySURF.extended = 0; Ptr<FeatureDetector> detector = FeatureDetector::create( "SURF"); // SURF,SIFT ,MSER Ptr<DescriptorExtractor> descriptorExtractor = DescriptorExtractor::create( "SURF" ); Ptr<DescriptorMatcher> descriptorMatcher = DescriptorMatcher::create( "FlannBased" ); // FlannBased , BruteForce int matcherFilterType = getMatcherFilterType( "CrossCheckFilter" ); // Get the first frame and select the ROI to be tracked in the subsequent frames Mat frame, img1, img2; cap >> frame; if( frame.empty() ) return -1; else img1 = frame.clone() ; Mat temp = img1.clone() ; if(img1.empty()) { cout << "Exiting as the input image is empty" << endl; exit(-1); } const char* name = "Initiate_ROI"; box = cvRect(-1,-1,0,0); cvNamedWindow( name ); // Set up the callback cvSetMouseCallback( name, my_mouse_callback); // Wait until ROI is selected by the user while( 1 ) { img1.copyTo(temp); if( drawing_box ) draw_box( temp, box ); cv::imshow(name,temp) ; cvWaitKey( 15 ); if(rect_drawn) break; } // storing the initial selected Box, as "box" variable changes in consecutive matching boxOrg = box; Mat img1ROI, labels1, clusters1, descriptors1, descriptors2; vector<int> reprojections; // number of reprojections per keypoint, size same as keypoint (increasing) vector<KeyPoint> keypoints1, keypoints2; //human aspect ratio (not used) double aspectRatio = (double)box.width / box.height; // Compute SURF features within the *selected* ROI img1ROI = img1(boxOrg); mySURF.detect(img1ROI, keypoints1 ); mySURF.compute(img1ROI, keypoints1, descriptors1 ); // Create a Template Pool that contains both descriptors as well as Keypoints (local & Global) Mat tpDescriptors; vector<KeyPoint> tpKeypoints; vector<float> tpWeights; int tpMaxSize = 1000; //Initially copy of the descriptor of Ist image ROI into it. descriptors1.copyTo(tpDescriptors); tpWeights.resize(tpDescriptors.rows,2.0); // Initial values of all weights is 2.0 for(uint i = 0; i < keypoints1.size(); ++i) tpKeypoints.push_back(keypoints1.at(i)); //========================================== // Main Iteration Loop starts here : Tracking //============================================ int MP, count; struct timeval t1, t2; //Rect msBox; // Box obtained from mean-shift tracker // Loop over all images for(int k=1;;k++) //int i=2;i<1002;i+=1) { gettimeofday(&t1, NULL); //create clusters in the SURF descriptor space // clusters are created in the template pool cv::kmeans(tpDescriptors, NOC, labels1, TermCriteria( CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 50, 1.0 ), 1, /*KMEANS_PP_CENTERS*/KMEANS_RANDOM_CENTERS, clusters1); // img1 - source image // img2 - Destination image // Mean-shift algorithm returns the window on Destination image given the source ROI in boxOrg. //Capture a New frame cap >> frame; if( frame.empty() ) return -1; else img2 = frame.clone() ; temp = img2.clone(); if(img2.empty() ) { cout<< "Could not open image: " << img2 << endl ; //continue ; exit(-1); } int flag=1; // what is this flag ?? MP=0; count=0; // ?? //Call the mean-shift tracker vector<int> queryIdxs, trainIdxs; meanShift(img1, img2, descriptorMatcher, matcherFilterType, keypoints1, descriptors1, keypoints2, descriptors2, clusters1, reprojections, cp, flag, count, MP, temp, queryIdxs, trainIdxs); DivideAndComputeScaling(img1, img2); // box.height = (int)(scaleValue * box.height); // box.width = (int)(aspectRatio * box.height); // box.x = cp.x - box.width/2.0; // box.y = cp.y - box.height/2.0; //cout << "Scale Value = " << scaleValue << endl; // Add the target ROI descriptors into the template pool. for(int i=0;i< descriptors2.rows;i++) { tpDescriptors.push_back(descriptors2.row(i)); tpKeypoints.push_back(keypoints2.at(i)); } // If the size of template pool exceeds max size, remove that many number of points from top Mat tempMat; if(tpDescriptors.rows > tpMaxSize) { //cout << "Time to Truncate Template Pool" << endl; uint dLength = tpDescriptors.rows - tpMaxSize; tempMat = tpDescriptors.rowRange(Range(dLength, tpDescriptors.rows)); tpKeypoints.erase(tpKeypoints.begin(), tpKeypoints.begin()+dLength); //tpDescriptors.release(); tpDescriptors = tempMat; tpDescriptors = tempMat; } tempMat.release(); //cout << "Template Pool size =" << tpDescriptors.rows << endl; // Current target image becomes the source image for the next iteration img1=img2.clone(); boxOrg = box; // source descriptors and keypoints are taken from the template pool keypoints1 = tpKeypoints; descriptors1 = tpDescriptors; gettimeofday(&t2, NULL); double diff = (float)((t2.tv_sec * 1000000 + t2.tv_usec) - (t1.tv_sec * 1000000 + t1.tv_usec)); diff = diff/1000; cout << k << "\tTime taken in mili sec \t" << diff<< endl; //f1 << k << "\t" << MP << "\t" << count << "\t" << diff << "\n"; cv::circle(temp, cp, 2, Scalar(0,255,255), 2); //======================================= imshow("main", temp); //imshow("img2", img2); char c = (char)waitKey(10); if( c == '\x1b' ) // esc { cout << "Exiting ..." << endl; break; } waitKey(5); } return 0; }
cv::RotatedRect cv::CamShift( InputArray _probImage, Rect& window, TermCriteria criteria ) { CV_INSTRUMENT_REGION() const int TOLERANCE = 10; Size size; Mat mat; UMat umat; bool isUMat = _probImage.isUMat(); if (isUMat) umat = _probImage.getUMat(), size = umat.size(); else mat = _probImage.getMat(), size = mat.size(); meanShift( _probImage, window, criteria ); window.x -= TOLERANCE; if( window.x < 0 ) window.x = 0; window.y -= TOLERANCE; if( window.y < 0 ) window.y = 0; window.width += 2 * TOLERANCE; if( window.x + window.width > size.width ) window.width = size.width - window.x; window.height += 2 * TOLERANCE; if( window.y + window.height > size.height ) window.height = size.height - window.y; // Calculating moments in new center mass Moments m = isUMat ? moments(umat(window)) : moments(mat(window)); double m00 = m.m00, m10 = m.m10, m01 = m.m01; double mu11 = m.mu11, mu20 = m.mu20, mu02 = m.mu02; if( fabs(m00) < DBL_EPSILON ) return RotatedRect(); double inv_m00 = 1. / m00; int xc = cvRound( m10 * inv_m00 + window.x ); int yc = cvRound( m01 * inv_m00 + window.y ); double a = mu20 * inv_m00, b = mu11 * inv_m00, c = mu02 * inv_m00; // Calculating width & height double square = std::sqrt( 4 * b * b + (a - c) * (a - c) ); // Calculating orientation double theta = atan2( 2 * b, a - c + square ); // Calculating width & length of figure double cs = cos( theta ); double sn = sin( theta ); double rotate_a = cs * cs * mu20 + 2 * cs * sn * mu11 + sn * sn * mu02; double rotate_c = sn * sn * mu20 - 2 * cs * sn * mu11 + cs * cs * mu02; double length = std::sqrt( rotate_a * inv_m00 ) * 4; double width = std::sqrt( rotate_c * inv_m00 ) * 4; // In case, when tetta is 0 or 1.57... the Length & Width may be exchanged if( length < width ) { std::swap( length, width ); std::swap( cs, sn ); theta = CV_PI*0.5 - theta; } // Saving results int _xc = cvRound( xc ); int _yc = cvRound( yc ); int t0 = cvRound( fabs( length * cs )); int t1 = cvRound( fabs( width * sn )); t0 = MAX( t0, t1 ) + 2; window.width = MIN( t0, (size.width - _xc) * 2 ); t0 = cvRound( fabs( length * sn )); t1 = cvRound( fabs( width * cs )); t0 = MAX( t0, t1 ) + 2; window.height = MIN( t0, (size.height - _yc) * 2 ); window.x = MAX( 0, _xc - window.width / 2 ); window.y = MAX( 0, _yc - window.height / 2 ); window.width = MIN( size.width - window.x, window.width ); window.height = MIN( size.height - window.y, window.height ); RotatedRect box; box.size.height = (float)length; box.size.width = (float)width; box.angle = (float)((CV_PI*0.5+theta)*180./CV_PI); while(box.angle < 0) box.angle += 360; while(box.angle >= 360) box.angle -= 360; if(box.angle >= 180) box.angle -= 180; box.center = Point2f( window.x + window.width*0.5f, window.y + window.height*0.5f); return box; }
AppTemplate::AppTemplate(const Mat* frame_set, const Rect iniWin,int ID) :ID(ID)//bgr,hsv,lab { //get roi out of frame set Rect body_win=scaleWin(iniWin,1/TRACKING_TO_BODYSIZE_RATIO); Rect roi_win(body_win.x-body_win.width,body_win.y-body_win.width,3*body_win.width,2*body_win.width+body_win.height); body_win= body_win&Rect(0,0,frame_set[0].cols,frame_set[0].rows); roi_win=roi_win&Rect(0,0,frame_set[0].cols,frame_set[0].rows); Mat roi_set[]={Mat(frame_set[0],roi_win),Mat(frame_set[1],roi_win),Mat(frame_set[2],roi_win)}; Rect iniWin_roi=iniWin-Point(roi_win.x,roi_win.y); //scores for each channel list<ChannelScore> channel_score; Mat mask_roi(roi_set[0].rows,roi_set[0].cols,CV_8UC1,Scalar(0)); rectangle(mask_roi,iniWin_roi,Scalar(255),-1); Mat inv_mask_roi(roi_set[0].rows,roi_set[0].cols,CV_8UC1,Scalar(255)); rectangle(inv_mask_roi,body_win-Point(roi_win.x,roi_win.y),Scalar(0),-1); //calculate score for each channel Mat temp_hist; Mat temp_bp; int hist_size[]={BIN_NUMBER}; for (int i=0;i<9;i++) { float range1[]={0,255}; if (i==3) { range1[1]=179; } const float* hist_range[]={range1}; calcHist(roi_set,3,&i,inv_mask_roi,temp_hist,1,hist_size,hist_range); normalize(temp_hist,temp_hist,255,0.0,NORM_L1);//scale to 255 for display calcBackProject(roi_set,3,&i,temp_hist,temp_bp,hist_range); int c[]={0}; int hs[]={BIN_NUMBER}; float hr[]={0,255}; const float* hrr[]={hr}; Mat hist_fore; Mat hist_back; calcHist(&temp_bp,1,c,mask_roi,hist_fore,1,hs,hrr); calcHist(&temp_bp,1,c,inv_mask_roi,hist_back,1,hs,hrr); normalize(hist_fore,hist_fore,1.0,0.0,NORM_L1); normalize(hist_back,hist_back,1.0,0.0,NORM_L1); //deal with gray image to get rid of #IND double score=getVR(hist_back,hist_fore); score=score==score ? score:0; channel_score.push_back(ChannelScore(i,score)); } //choose the 2 highest scored channels channel_score.sort(compareChannel); channels[0]=channel_score.back().idx; channel_score.pop_back(); channels[1]=channel_score.back().idx; //using 2 best channel to calculate histogram for (int i=0;i<2;++i) { _hRang[i][0]=0; if (channels[i]==3) _hRang[i][1]=179; else _hRang[i][1]=255; hRange[i]=_hRang[i]; } calcHist(roi_set,3,channels,inv_mask_roi,temp_hist,2,hSize,hRange); normalize(temp_hist,temp_hist,255,0,NORM_L1); Mat final_mask;//mask for sampling calcBackProject(roi_set,3,channels,temp_hist,final_mask,hRange); threshold(final_mask,final_mask,5,255,CV_THRESH_BINARY_INV); final_mask=min(final_mask,mask_roi); //choose the best two feature space for foreground**************** Mat hist_fore,hist_back; channel_score.clear(); double sum_score=0; for (int i=0;i<9;i++) { float range1[]={0,255}; if (i==3) { range1[1]=179; } const float* hist_range[]={range1}; Mat temp_hist_neg; calcHist(roi_set,3,&i,final_mask,temp_hist,1,hist_size,hist_range); normalize(temp_hist,temp_hist,255,0,NORM_L1); calcHist(roi_set,3,&i,inv_mask_roi,temp_hist_neg,1,hist_size,hist_range); normalize(temp_hist_neg,temp_hist_neg,255,0,NORM_L1); log(temp_hist,temp_hist); log(temp_hist_neg,temp_hist_neg); temp_hist=temp_hist-temp_hist_neg; threshold(temp_hist,temp_hist,0,255,CV_THRESH_TOZERO); normalize(temp_hist,temp_hist,255,0.0,NORM_L1);//scale to 255 for display calcBackProject(roi_set,3,&i,temp_hist,temp_bp,hist_range); int c[]={0}; int hs[]={BIN_NUMBER}; float hr[]={0,255}; const float* hrr[]={hr}; calcHist(&temp_bp,1,c,final_mask,hist_fore,1,hs,hrr); calcHist(&temp_bp,1,c,inv_mask_roi,hist_back,1,hs,hrr); normalize(hist_fore,hist_fore,1.0,0.0,NORM_L1); normalize(hist_back,hist_back,1.0,0.0,NORM_L1); double score=getVR(hist_back,hist_fore); score=score==score ? score:0; channel_score.push_back(ChannelScore(i,score)); sum_score+=exp(score); } channel_score.sort(compareChannel); channels[0]=channel_score.back().idx; channel_score.pop_back(); channels[1]=channel_score.back().idx; for (int i=0;i<2;++i) { _hRang[i][0]=0; if (channels[i]==3) _hRang[i][1]=179; else _hRang[i][1]=255; hRange[i]=_hRang[i]; } calcHist(roi_set,3,channels,final_mask,hist,2,hSize,hRange);/////////////////// normalize(hist,hist,255,0,NORM_L1); //recover the shift_vector Mat backPro; calcBackProject(roi_set,3,channels,hist,backPro,hRange); iniWin_roi=iniWin-Point(roi_win.x,roi_win.y); Point2f origin_point_roi((float)(iniWin_roi.x+0.5*iniWin_roi.width),(float)(iniWin_roi.y+0.5*iniWin_roi.height)); meanShift(backPro,iniWin_roi,TermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 )); Point2f shift_point_roi((float)(iniWin_roi.x+0.5*iniWin_roi.width),(float)(iniWin_roi.y+0.5*iniWin_roi.height)); shift_vector=(shift_point_roi-origin_point_roi)*(1/(float)iniWin.width); }
void MeanShiftDemo( VideoCapture& video, Rect& starting_position, int starting_frame_number, int end_frame) { bool half_size = true; video.set(CV_CAP_PROP_POS_FRAMES,starting_frame_number); Mat current_frame, hls_image; std::vector<cv::Mat> hls_planes(3); video >> current_frame; Rect current_position(starting_position); if (half_size) { resize(current_frame, current_frame, Size( current_frame.cols/2, current_frame.rows/2 )); current_position.height /= 2; current_position.width /= 2; current_position.x /= 2; current_position.y /= 2; } cvtColor(current_frame, hls_image, CV_BGR2HLS); split(hls_image,hls_planes); int chosen_channel = 0; // Hue channel Mat image1ROI = hls_planes[chosen_channel](current_position); float channel_range[2] = { 0.0, 255.0 }; int channel_numbers[1] = { 0 }; int number_bins[1] = { 32 }; MatND histogram[1]; const float* channel_ranges = channel_range; calcHist(&(image1ROI), 1, channel_numbers, Mat(), histogram[0], 1 , number_bins, &channel_ranges); normalize(histogram[0],histogram[0],1.0); rectangle(current_frame,current_position,Scalar(0,255,0),2); Mat starting_frame = current_frame.clone(); int frame_number = starting_frame_number; while (!current_frame.empty() && (frame_number < end_frame)) { // Calculate back projection Mat back_projection_probabilities; calcBackProject(&(hls_planes[chosen_channel]),1,channel_numbers,*histogram,back_projection_probabilities,&channel_ranges,255.0); // Remove low saturation points from consideration Mat saturation_mask; inRange( hls_image, Scalar(0,10,50,0),Scalar(180,256,256,0), saturation_mask ); bitwise_and( back_projection_probabilities, back_projection_probabilities,back_projection_probabilities, saturation_mask ); // Mean shift TermCriteria criteria(cv::TermCriteria::MAX_ITER,5,0.01); meanShift(back_projection_probabilities,current_position,criteria); // Output to screen rectangle(current_frame,current_position,Scalar(0,255,0),2); Mat chosen_channel_image, back_projection_image; cvtColor(hls_planes[chosen_channel], chosen_channel_image, CV_GRAY2BGR); cvtColor(back_projection_probabilities, back_projection_image, CV_GRAY2BGR); Mat row1_output = JoinImagesHorizontally( starting_frame, "Starting position", chosen_channel_image, "Chosen channel (Hue)", 4 ); Mat row2_output = JoinImagesHorizontally( back_projection_image, "Back projection", current_frame, "Current position", 4 ); Mat mean_shift_output = JoinImagesVertically(row1_output,"",row2_output,"", 4); imshow("Mean Shift Tracking", mean_shift_output ); // Advance to next frame video >> current_frame; if (half_size) resize(current_frame, current_frame, Size( current_frame.cols/2, current_frame.rows/2 )); cvtColor(current_frame, hls_image, CV_BGR2HLS); split(hls_image,hls_planes); frame_number++; cvWaitKey(1000); } char c = cvWaitKey(); cvDestroyAllWindows(); }
int main(int argc, char** argv) { ofstream f1; f1.open("result.txt"); size_t i,j; Point2f cp; cv::initModule_nonfree(); vector<Point2f> MP1,MP2; vector<int> trainIdxs, queryIdxs; //Read Video File VideoCapture cap("video1.avi"); if( !cap.isOpened() ) { cout << "Could not initialize capturing...\n"; return 0;} VideoWriter writer("ms_tracking.avi",CV_FOURCC('D','I','V','3'), 10,cvSize(640,480),1); cv::SURF mySURF; mySURF.extended = 0; Ptr<DescriptorMatcher> descriptorMatcher = DescriptorMatcher::create( "FlannBased" ); int mactherFilterType = getMatcherFilterType( "CrossCheckFilter" ); Mat frame,img1,img2; cap >> frame; if( frame.empty() ) return -1; img1 = frame.clone() ; Mat temp,temp1; if(img1.empty()) cout << "Exiting as the input image is empty" << endl; const char* name = "Initiate_ROI"; box = cvRect(-1,-1,0,0); cvNamedWindow( name,1); cvSetMouseCallback( name, my_mouse_callback2); // Main loop while( 1 ) { img1.copyTo(temp); if( drawing_poly) { for ( i=0; i < polyPoints.size(); i++) circle(temp, polyPoints[i], 2, Scalar(0,255,0), -1,8); } cv::imshow(name,temp) ; char c = (char)waitKey(10); if( c == '\x1b' ) // esc break; if(poly_drawn) break; } //Read the polygon points from a text file FILE *f11; polyPoints.clear(); IpolyPoints.clear(); f11 = fopen("points.txt","r"); Point a; for(int j=0;j<37;j++) { fscanf(f11,"%d",&(a.x)); fscanf(f11,"%d",&(a.y)); polyPoints.push_back(a); IpolyPoints.push_back(a); } fclose(f11); // Drawing Polygon Point pointArr[polyPoints.size()]; for (i=0; i< polyPoints.size(); i++) pointArr[i] = polyPoints[i]; const Point* pointsArray[1] = {pointArr}; int nCurvePts[1] = { polyPoints.size() }; polylines(temp, pointsArray, nCurvePts, 1, 1, Scalar(0,255,0), 1); cout << polyPoints.size() << endl; box= boundingRect(polyPoints); //boxOrg = Rect(box.x-15, box.y-15, box.width+30, box.height+30); boxOuter = Rect(box.x-30, box.y-30, box.width+60, box.height+60); //box =boxOrg; // storing the initial selected Box, as "box" variable changes in consecutive matching boxP=box; Mat img1ROI, labels1, clusters1, descriptors,roidescriptors, descriptors1,bdescriptors, bmdescriptors; vector<int> reprojections; // number of reprojections per KP, size same as KP(incresing) vector<Point2f> points,points1,points2, Mpoints1,Mpoints2,bpoints,npoints1,npoints2; //bmpoints,tpoints; vector<KeyPoint> roikeypoints, bkeypoints,keypoints,keypoints1, keypoints2; draw_box(temp, box ); //Show InnerBox - This is used by the Mean-Shift Tracker draw_box(temp,boxOuter); //Show OuterBox - This is used for removing background points bpoints.clear(); //calculating keypoints and descriptors of the selected polygon in image roi //==============================================================================================// for(i=0;i<polyPoints.size();i++) { // cout << polyPoints[i] << endl; // polyPoints[i].x = polyPoints[i].x -boxOuter.x; polyPoints[i].y = polyPoints[i].y- boxOuter.y; } img1ROI = img1(boxOuter); points1.clear(); mySURF.detect(img1ROI, roikeypoints); KeyPoint::convert(roikeypoints, points); mySURF.compute(img1ROI, roikeypoints, roidescriptors); bdescriptors.release();bkeypoints.clear(); bcategorizePoints( points, bpoints,polyPoints, roikeypoints, roidescriptors, bkeypoints, bdescriptors); shiftPoints(bpoints,boxOuter); for(i=0;i<bpoints.size();i++) circle(temp, bpoints[i], 2, Scalar(0,255,0),2); vector<KeyPoint> tpkeypoints; Mat tpdescriptors; categorizePoints( points, points1,polyPoints, roikeypoints, roidescriptors, tpkeypoints, tpdescriptors); shiftPoints(points1, boxOuter); for(i=0;i<points1.size();i++) circle(temp, points1[i], 2, Scalar(0,0,255),2); //====================================================================================================// points1.clear(); Mat img2ROI; // tpkeypoints = keypoints1; tpdescriptors = descriptors1; cv::imshow(name,temp) ; imwrite("a.jpg",temp); cout << "BD_SIZE \t" << bdescriptors.rows << "\t" << "FD_SIZE \t" << tpdescriptors.rows << endl; // Mat newimg = img1ROI.clone(); // KeyPoint::convert(tpkeypoints, points1); // for(size_t i=0;i<points1.size();i++) // circle(newimg, points1[i], 2, Scalar(255,0,255),2); // imshow( "newimg", newimg ); // points1.clear(); waitKey(0); cvDestroyWindow( name ); int FG_mp, FG, BG_mp, BG, FG_BG, msI ; //Foreground matching points struct timeval t1, t2; for(int l=0;;l++) { gettimeofday(&t1, NULL); cv::kmeans(tpdescriptors, NOC, labels1, TermCriteria( CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 50, 1.0 ), 1, KMEANS_RANDOM_CENTERS, clusters1); cap >> frame; img2 = frame.clone() ; temp1 =frame.clone() ; if(img2.empty() ) { cout<< "Could not open image: " << endl ; break;} int flag=1; Mpoints1.clear(); Mat descriptors2; msI=0; meanShift(img1, img2, descriptorMatcher, mactherFilterType, tpkeypoints, tpdescriptors,keypoints2,descriptors2, clusters1, cp, flag, MP1,img2ROI,bkeypoints, bdescriptors, temp1,FG_mp, FG, BG_mp, BG, FG_BG,msI); //==========scaling================= float scale=1; // cout <<"MP1size \t" << MP1.size() <<endl; if(APPLY_SCALING) { vector<DMatch> filteredMatches; if(descriptors1.rows > 4 && descriptors2.rows > 4) { crossCheckMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches, 1 ); trainIdxs.clear(); queryIdxs.clear(); for( i = 0; i < filteredMatches.size(); i++ ) { queryIdxs.push_back(filteredMatches[i].queryIdx); trainIdxs.push_back(filteredMatches[i].trainIdx); } points1.clear(); points2.clear(); KeyPoint::convert(keypoints1, points1, queryIdxs); KeyPoint::convert(keypoints2, points2, trainIdxs); // cout << "point2size" << points2.size() << endl; //homography npoints1.clear();npoints2.clear(); Mpoints1.clear();Mpoints2.clear(); Mat H12, points1t; double ransacReprojThreshold = 10; if( ransacReprojThreshold >= 0 && points1.size() > 4) H12 = findHomography( Mat(points1), Mat(points2), CV_RANSAC, ransacReprojThreshold ); vector<char> matchesMask( filteredMatches.size(), 0 );// NONmatchesMask( filteredMatches.size(), 0 ); if( !H12.empty() ) { perspectiveTransform(Mat(points1), points1t, H12); double maxInlierDist = 10;//ransacReprojThreshold < 0 ? 3 : ransacReprojThreshold; for(i = 0; i < points1.size(); i++ ) { if( norm(points2[i] - points1t.at<Point2f>((int)i,0)) <= 5)// maxInlierDist ) // inlier { matchesMask[i] = 1; npoints2.push_back(points2[i]); npoints1.push_back(points1[i]); } } for(i=0; i<npoints2.size();i++) { for(j=0;j<MP1.size();j++) { double dist = norm(npoints2[i]-MP1[j]); // cout <<"dist \t" <<dist << endl; // waitKey(0); if(dist < 0.1) { Mpoints2.push_back(npoints2[i]); Mpoints1.push_back(npoints1[i]); break; } } } } Mat drawImg; drawMatches( img1ROI, keypoints1, img2ROI, keypoints2, filteredMatches, drawImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255), matchesMask #if DRAW_RICH_KEYPOINTS_MODE , DrawMatchesFlags::DRAW_RICH_KEYPOINTS #endif ); imshow( "correspondance", drawImg ); cout << "npoints1.size \t" << Mpoints1.size() << "\t" << Mpoints2.size() << endl; if(Mpoints1.size() > 8) weightScalingAspect(Mpoints1,Mpoints2,&scale); } } img1=img2; img1ROI = img2ROI; boxOrg =box; keypoints1 = keypoints2; descriptors1 =descriptors2; box.x += box.width/2; box.y += box.height/2; box.height = round(boxOrg.height *scale); box.width = round(( float(boxOrg.width)/float(boxOrg.height) ) * box.height); box.x -= box.width/2; box.y -= box.height/2; boundaryCheckRect(box); cout <<"SCALE \t" << scale << endl; gettimeofday(&t2, NULL); double diff = (float)((t2.tv_sec * 1000000 + t2.tv_usec) - (t1.tv_sec * 1000000 + t1.tv_usec)); diff = diff/1000; cout <<"Time taken in mili sec \t" << diff<< endl; // cout << tpdescriptors.rows << endl; //cout <<"BD \t" << bdescriptors.rows << endl; f1 << l << "\t" << FG_mp << "\t" << BG_mp << "\t" << FG << "\t"<< msI << "\n"; cout << "l \t" << l << "\t" <<" msI \t"<< msI << endl; imshow("img2",temp1); writer << temp1; waitKey(0); // boxOrg = eBox; char c = (char)waitKey(10); if( c == '\x1b' ) // esc { cout << "Exiting ..." << endl; break; } } trajectory.close(); return 0; }