├── README.md
└── main.cpp


/README.md:
--------------------------------------------------------------------------------
1 | rtObjectRecognition
2 | ===================
3 | 
4 | Real Time Object Recognition using SURF algorithm in OpenCV EEL6562 Course Project.
5 | 
6 | Note: OpenCV libraries must be installed to use code. See link below on how to install OpenCV
7 | 
8 | http://nenadbulatovic.blogspot.com/2013/07/configuring-opencv-245-eclipse-cdt-juno.html
9 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * EEL6562 Project
  3 |  * Real Time Object Recognition using SURF
  4 |  *
  5 |  *  Created on: Nov 15, 2013
  6 |  *      Author: Frank
  7 |  */
  8 | 
  9 | //Include statements
 10 | #include <iostream>
 11 | #include <fstream>
 12 | #include <string>
 13 | #include <opencv2/core/core.hpp>
 14 | #include <opencv2/highgui/highgui.hpp>
 15 | #include <opencv2/opencv.hpp>
 16 | #include "opencv2/features2d/features2d.hpp"
 17 | #include "opencv2/imgproc/imgproc.hpp"
 18 | #include "opencv2/calib3d/calib3d.hpp"
 19 | #include "opencv2/nonfree/nonfree.hpp"
 20 | 
 21 | //Name spaces used
 22 | using namespace cv;
 23 | using namespace std;
 24 | 
 25 | int main()
 26 | {
 27 | 	//Turn on performance analysis functions for generating metrics if generateMetricsForReport = true
 28 | 	bool generateMetricsForReport=false;
 29 | 	double t; //timing variable
 30 | 	string resourceFilePath = "C:/School/Image Processing/";
 31 | 	string trainingImageFilePath = resourceFilePath + "book.jpg";
 32 | 
 33 | 	//load training image
 34 | 	Mat object = imread (trainingImageFilePath, CV_LOAD_IMAGE_GRAYSCALE);
 35 | 	if (!object.data){
 36 | 		cout<<"Can't open image";
 37 | 		return -1;
 38 | 	}
 39 | 	namedWindow("Good Matches", CV_WINDOW_AUTOSIZE);
 40 | 
 41 | 	//SURF Detector, and descriptor parameters
 42 | 	int minHess=3000;
 43 | 	vector<KeyPoint> kpObject, kpImage;
 44 | 	Mat desObject, desImage;
 45 | 
 46 | 	//Performance measures calculations for report
 47 | 	if (generateMetricsForReport)
 48 | 	{
 49 | 		//Calculate integral image
 50 | 		cout<<object.rows<<" "<<object.cols<<endl;
 51 | 		Mat iObject;
 52 | 		integral(object, iObject);
 53 | 		imshow("Good Matches", iObject);
 54 | 		imwrite(resourceFilePath + "IntegralImage.jpg", iObject);
 55 | 		cvWaitKey(0);
 56 | 
 57 | 		//calculate number of interest points, computation time as f(minHess)
 58 | 		int minHessVector[]={100, 500, 1000, 1500, 2000, 2500, 3000,
 59 | 									3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000, 7500,
 60 | 									8000, 8500, 9000, 9500, 10000};
 61 | 		int minH;
 62 | 		std::ofstream file;
 63 | 		file.open(resourceFilePath + "TimingC.csv", std::ofstream::out);
 64 | 		for (int i=0; i<20; i++)
 65 | 		{
 66 | 			minH=minHessVector[i];
 67 | 			t = (double)getTickCount();
 68 | 			SurfFeatureDetector detector(minH);
 69 | 			detector.detect(object, kpObject);
 70 | 			t = ((double)getTickCount() - t)/getTickFrequency();
 71 | 			file<<minHess<<","<<kpObject.size()<<","<<t<<",";
 72 | 			cout<<t<<" "<<kpObject.size()<<" "<<desObject.size()<<endl;
 73 | 
 74 | 			t = (double)getTickCount();
 75 | 			SurfDescriptorExtractor extractor;
 76 | 			extractor.compute(object, kpObject, desObject);
 77 | 			t = ((double)getTickCount() - t)/getTickFrequency();
 78 | 			file<<t<<endl;
 79 | 		}
 80 | 		file.close();
 81 | 
 82 | 	//Display keypoints on training image
 83 | 	Mat interestPointObject=object;
 84 | 	for (unsigned int i=0; i<kpObject.size();i++)
 85 | 	{
 86 | 		if(kpObject[i].octave)
 87 | 		{
 88 | 			circle(interestPointObject,kpObject[i].pt,kpObject[i].size,0);
 89 | 			string octaveS;
 90 | 			switch(kpObject[i].octave)
 91 | 			{
 92 | 			case 0:
 93 | 				octaveS="0";
 94 | 				break;
 95 | 			case 1:
 96 | 				octaveS='1';
 97 | 				break;
 98 | 			case 2:
 99 | 				octaveS='2';
100 | 				break;
101 | 			default:
102 | 				break;
103 | 
104 | 			}
105 | 			putText(interestPointObject, octaveS, kpObject[i].pt,
106 | 				    FONT_HERSHEY_COMPLEX_SMALL, 1, cvScalar(0,0,250), 1, CV_AA);
107 | 		}
108 | 
109 | 	}
110 | 	imshow("Good Matches",interestPointObject);
111 | 	imwrite(resourceFilePath + "bookIP2.jpg", interestPointObject);
112 | 	cvWaitKey(0);
113 | 	}
114 | 
115 | 	//SURF Detector, and descriptor parameters, match object initialization
116 | 	minHess=2000;
117 | 	SurfFeatureDetector detector(minHess);
118 | 	detector.detect(object, kpObject);
119 | 	SurfDescriptorExtractor extractor;
120 | 	extractor.compute(object, kpObject, desObject);
121 | 	FlannBasedMatcher matcher;
122 | 
123 | 	//Initialize video and display window
124 | 	VideoCapture cap(1);  //camera 1 is webcam
125 | 	if (!cap.isOpened()) return -1;
126 | 
127 | 	//Object corner points for plotting box
128 | 	vector<Point2f> obj_corners(4);
129 | 	obj_corners[0] = cvPoint(0,0);
130 | 	obj_corners[1] = cvPoint( object.cols, 0 );
131 |     obj_corners[2] = cvPoint( object.cols, object.rows );
132 |     obj_corners[3] = cvPoint( 0, object.rows );
133 | 
134 |     //video loop
135 |     char escapeKey='k';
136 |     double frameCount = 0;
137 |     float thresholdMatchingNN=0.7;
138 |     unsigned int thresholdGoodMatches=4;
139 |     unsigned int thresholdGoodMatchesV[]={4,5,6,7,8,9,10};
140 | 
141 |     for (int j=0; j<7;j++){
142 |     	thresholdGoodMatches=thresholdGoodMatchesV[j];
143 |     	//thresholdGoodMatches=8;
144 |     	cout<<thresholdGoodMatches<<endl;
145 | 
146 |     if(true)
147 |     {
148 |     	t = (double)getTickCount();
149 |     }
150 | 
151 |     while (escapeKey != 'q')
152 |     {
153 |     	frameCount++;
154 |     	Mat frame;
155 |     	Mat image;
156 |     	cap>>frame;
157 |     	cvtColor(frame, image, CV_RGB2GRAY);
158 | 
159 |     	Mat des_image, img_matches, H;
160 |     	vector<KeyPoint> kp_image;
161 |     	vector<vector<DMatch > > matches;
162 |     	vector<DMatch > good_matches;
163 |     	vector<Point2f> obj;
164 |     	vector<Point2f> scene;
165 |     	vector<Point2f> scene_corners(4);
166 | 
167 |     	detector.detect( image, kp_image );
168 |     	extractor.compute( image, kp_image, des_image );
169 |     	matcher.knnMatch(desObject, des_image, matches, 2);
170 | 
171 |     	                            for(int i = 0; i < min(des_image.rows-1,(int) matches.size()); i++) //THIS LOOP IS SENSITIVE TO SEGFAULTS
172 |     	                            {
173 |     	                            	if((matches[i][0].distance < thresholdMatchingNN*(matches[i][1].distance)) && ((int) matches[i].size()<=2 && (int) matches[i].size()>0))
174 |     	                                {
175 |     	                                    good_matches.push_back(matches[i][0]);
176 |     	                                }
177 |     	                            }
178 | 
179 |     	                            //Draw only "good" matches
180 |     	                            drawMatches( object, kpObject, image, kp_image, good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
181 | 
182 |     	                            if (good_matches.size() >= thresholdGoodMatches)
183 |     	                            {
184 |     	                            	//Display that the object is found
185 |     	                            	putText(img_matches, "Object Found", cvPoint(10,50),FONT_HERSHEY_COMPLEX_SMALL, 2, cvScalar(0,0,250), 1, CV_AA);
186 |     	                                for(unsigned int i = 0; i < good_matches.size(); i++ )
187 |     	                                {
188 |     	                                    //Get the keypoints from the good matches
189 |     	                                    obj.push_back( kpObject[ good_matches[i].queryIdx ].pt );
190 |     	                                    scene.push_back( kp_image[ good_matches[i].trainIdx ].pt );
191 |     	                                }
192 | 
193 |     	                                H = findHomography( obj, scene, CV_RANSAC );
194 |     	                                perspectiveTransform( obj_corners, scene_corners, H);
195 | 
196 |     	                                //Draw lines between the corners (the mapped object in the scene image )
197 |     	                                line( img_matches, scene_corners[0] + Point2f( object.cols, 0), scene_corners[1] + Point2f( object.cols, 0), Scalar(0, 255, 0), 4 );
198 |     	                                line( img_matches, scene_corners[1] + Point2f( object.cols, 0), scene_corners[2] + Point2f( object.cols, 0), Scalar( 0, 255, 0), 4 );
199 |     	                                line( img_matches, scene_corners[2] + Point2f( object.cols, 0), scene_corners[3] + Point2f( object.cols, 0), Scalar( 0, 255, 0), 4 );
200 |     	                                line( img_matches, scene_corners[3] + Point2f( object.cols, 0), scene_corners[0] + Point2f( object.cols, 0), Scalar( 0, 255, 0), 4 );
201 |     	                            }
202 |     	                            else
203 |     	                            {
204 |     	                            	putText(img_matches, "", cvPoint(10,50), FONT_HERSHEY_COMPLEX_SMALL, 3, cvScalar(0,0,250), 1, CV_AA);
205 |     	                            }
206 | 
207 |     	                            //Show detected matches
208 |     	                            imshow( "Good Matches", img_matches );
209 |     	                            escapeKey=cvWaitKey(10);
210 |     	                            //imwrite(resourceFilePath + "bookIP3.jpg", img_matches);
211 | 
212 |     	                            if(frameCount>10)
213 |     	                            	escapeKey='q';
214 |     }
215 | 
216 |     //average frames per second
217 |     if(true)
218 |     {
219 |     	t = ((double)getTickCount() - t)/getTickFrequency();
220 |     	cout<<t<<" "<<frameCount/t<<endl;
221 |     	cvWaitKey(0);
222 |     }
223 | 
224 |     frameCount=0;
225 |     escapeKey='a';
226 |     }
227 | 
228 |     //Release camera and exit
229 |     cap.release();
230 | 	return 0;
231 | }
232 | 


--------------------------------------------------------------------------------