//构造函数，初始化特征点类型、特征向量类型、匹配方式
Feature::Feature(const string& detectType, const string& extractType, const string& matchType)
{
assert(!detectType.empty());
assert(!extractType.empty());
assert(!matchType.empty());
m_detectType = detectType;
m_extractType = extractType;
m_matchType = matchType;
initModule_nonfree();
}
int compute_feature(frame &f, string detector, string descriptor)
{
initModule_nonfree();
Ptr<FeatureDetector> _detector = FeatureDetector::create(detector.c_str());
Ptr<DescriptorExtractor> _descriptor = DescriptorExtractor::create(descriptor.c_str());
_detector->detect(f.rgb, f.kps);
_descriptor->compute(f.rgb, f.kps, f.desp);
return f.kps.size();
}
//默认构造函数
Feature::Feature()
{
/*（即局部图像特征检测算子+特征向量描述算子+高维特征向量匹配方法）
1. FAST+SIFT+FLANN
2. HARRIS+SIFT+FLANN
3. SURF+SIFT+FLANN
4. MSER+SIFT+FLANN
5. STAR+SIFT+FLANN
6.SIFT+SIFT+FLANN
7. ORB+ORB+FLANN
*/
m_detectType = "SURF";
m_extractType = "SIFT";
m_matchType = "BruteForce";
initModule_nonfree();
}
bool cv::initAll()
{
return true
#ifdef HAVE_OPENCV_VIDEO
&& initModule_video()
#endif
#ifdef HAVE_OPENCV_FEATURES2D
&& initModule_features2d()
#endif
#ifdef HAVE_OPENCV_NONFREE
&& initModule_nonfree()
#endif
#ifdef HAVE_OPENCV_ML
&& initModule_ml()
#endif
;
}
void ObjectRecognition::loadFeatures(Mat& inImage, vector< KeyPoint >& keypoints, vector< std::vector< float > >& features, Mat& descriptors)
{
features.clear();
keypoints.clear();
if(input_type==0) //input_type = 0 camera
cvtColor(inImage, inImage, CV_RGB2GRAY);
#if FEATURE_EXTRATION
//---------------using SIFT to get features descriptors-------------------------
//cout<< "...Extracting SIFT features..." << endl;
initModule_nonfree();
SIFT sift(1, 3, 0.04, 10, 1.0);
sift(inImage, noArray(), keypoints, descriptors);
// vector<vector<float> > vdesc;
// vdesc.reserve(descriptors.rows);
for (int i=0; i<descriptors.rows; i++)
{
features.push_back(descriptors.row(i));
}
// cout<< "descriptors: " << vdesc.size() << " " << vdesc[0].size() << endl;
#else
//-----------using SURF to get features descriptors------------------------
vector<float> descriptors;
cv::Mat mask;
cv::SURF surf(400, 4, 2, EXTENDED_SURF);
surf(inimage, mask, keypoints, descriptors);
features.push_back(vector<vector<float> >());
changeStructure(descriptors, features.back(), surf.descriptorSize());
#endif
//----------------------------display keypoints--------------------------
// drawKeypoints(image, keypoints, image, Scalar(255,0,0));
// imshow("clusters", image);
// waitKey();
}
ImgDescriptorExtractor::ImgDescriptorExtractor()
{
cv_bow_img_desc_extractor = NULL;
initModule_nonfree();
}
int main()
{
if(run_tests_only)
{
MyLine3D::runTest();
return 0;
}
//CvMat *camera_inner_calibration_matrix;
bool show_surf_example=false;
bool show_calibration_from_camera_and_undistortion=false;
if(show_calibration_from_camera_and_undistortion)
{
CvMat *object_points_all=0;
CvMat *image_points_all=0;
CvMat *points_count_all=0;
CvMat *camera_matr=0;
CvMat *distor_coefs=0;
CvMat *rotation_vecs=0;
CvMat *transpose_vecs=0;
vector<CvPoint2D32f> qu_calibr_points;
IplImage* frameCam1;
cvNamedWindow("WindowCam1",CV_WINDOW_KEEPRATIO);
CvCapture *captureCam1=cvCreateCameraCapture(0);
IplImage *quarterFrame;
CvPoint2D32f *cornersFounded= new CvPoint2D32f[100];
int cornersCount=0;
int result_Found=0;
// getting snapshots for inner camera calibration from video camera
bool capture_flag=false;
while(true)
{
frameCam1=cvQueryFrame(captureCam1);
quarterFrame=cvCreateImage(cvSize((frameCam1->width),(frameCam1->height)),IPL_DEPTH_8U,3);
cvCopy(frameCam1,quarterFrame);
if(capture_flag)
{
result_Found=cvFindChessboardCorners(quarterFrame,cvSize(chess_b_szW,chess_b_szH),cornersFounded,&cornersCount);//,CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS |CV_CALIB_CB_FAST_CHECK);
cvDrawChessboardCorners(quarterFrame,cvSize(chess_b_szW,chess_b_szH),cornersFounded,cornersCount,result_Found);
if(result_Found>0)
AddPointsToInnerCalibrate(qu_calibr_points,cornersFounded,cornersCount);
capture_flag=false;
cvShowImage("WindowCam1",quarterFrame);
if(result_Found>0)
cvWaitKey(0);
}
char c=cvWaitKey(33);
if(c==27)
break;
if(c==32 || c=='y' || c=='Y')
capture_flag=true;
cvShowImage("WindowCam1",quarterFrame);
cvReleaseImage(&quarterFrame);
}
cvReleaseImage(&quarterFrame);
cvReleaseCapture(&captureCam1);
cvDestroyWindow("WindowCam1");
PrintAllPointsForInnerCalibrate(qu_calibr_points,chess_b_szW*chess_b_szH);
InitCvMatPointsParametersForInnerCallibration_part1(qu_calibr_points,chess_b_szW*chess_b_szH,object_points_all,image_points_all,points_count_all,chess_b_szW,chess_b_szH);
InitOtherCameraParametersForInnerCallibration_part2(qu_calibr_points.size()/(chess_b_szW*chess_b_szH),camera_matr,distor_coefs,rotation_vecs,transpose_vecs);
double calibration_error_result=cvCalibrateCamera2(object_points_all,
image_points_all,
points_count_all,
cvSize(imgW,imgH),
camera_matr,
distor_coefs,
rotation_vecs,
transpose_vecs,
CV_CALIB_FIX_PRINCIPAL_POINT|CV_CALIB_FIX_ASPECT_RATIO|CV_CALIB_ZERO_TANGENT_DIST
);
WriteMatrixCoef(camera_matr);
WriteMatrixCoef(distor_coefs);
//camera_inner_calibration_matrix=cvCreateMat(3,3,CV_32FC1);
//cvCopy(camera_matr,camera_inner_calibration_matrix);
cvSave("camera_calibration_inner.txt",camera_matr,"camera_inner_calibration_matrix");
cvSave("camera_calibration_dist.txt",distor_coefs,"distor_coefs","coeficients of distortions");
cout<<"Total Error:"<<calibration_error_result<<endl;
cout<<"Average Calibration Error :"<<(calibration_error_result)/qu_calibr_points.size()<<endl;
//undistortion example
IplImage *frame_cur;
IplImage *undistor_image;
cvNamedWindow("cameraUndistor",CV_WINDOW_KEEPRATIO);
CvCapture *captureCam2=cvCreateCameraCapture(0);
bool undist_flag=false;
while(true)
{
frame_cur= cvQueryFrame(captureCam2);
undistor_image=cvCreateImage(cvSize((frame_cur->width),(frame_cur->height)),IPL_DEPTH_8U,3);
if(undist_flag)
{
cvUndistort2(frame_cur,undistor_image,camera_matr,distor_coefs);
}
else
{
cvCopy(frame_cur,undistor_image);
}
cvShowImage("cameraUndistor",undistor_image);
char c=cvWaitKey(33);
if(c==27)
break;
if(c=='u'||c=='U')
undist_flag=!undist_flag;
cvReleaseImage(&undistor_image);
}
cvReleaseImage(&undistor_image);
cvReleaseCapture(&captureCam2);
cvDestroyWindow("cameraUndistor");
}//ending undistortion_example
if(show_surf_example)
{
//using SURF
initModule_nonfree();// added at 16.04.2013
CvCapture* capture_cam_3=cvCreateCameraCapture(0);
cvNamedWindow("SURF from Cam",CV_WINDOW_KEEPRATIO);
cvCreateTrackbar("Hessian Level","SURF from Cam",0,1000,onTrackbarSlide1);
IplImage* buf_frame_3=0;
IplImage* gray_copy=0;
IplImage* buf_frame_3_copy=0;
CvSeq *kp1,*descr1;
CvMemStorage *storage=cvCreateMemStorage(0);
CvSURFPoint *surf_pt;
bool surf_flag=false;
while(true)
{
buf_frame_3=cvQueryFrame(capture_cam_3);
if(surf_flag)
{
surf_flag=false;
gray_copy=cvCreateImage(cvSize((buf_frame_3->width),(buf_frame_3->height)),IPL_DEPTH_8U,1);
buf_frame_3_copy=cvCreateImage(cvSize((buf_frame_3->width),(buf_frame_3->height)),IPL_DEPTH_8U,3);
cvCvtColor(buf_frame_3,gray_copy,CV_RGB2GRAY);
//cvSetImageROI(gray_copy,cvRect(280,200,40,40));
cvExtractSURF(gray_copy,NULL,&kp1,&descr1,storage,cvSURFParams(0.0,0));
cvReleaseImage(&gray_copy);
re_draw=true;
while(true)
{
if(re_draw)
{
cvCopy(buf_frame_3,buf_frame_3_copy);
double pi=acos(-1.0);
for(int i=0;i<kp1->total;i++)
{
surf_pt=(CvSURFPoint*)cvGetSeqElem(kp1,i);
if(surf_pt->hessian<min_hessian)
continue;
int pt_x,pt_y;
pt_x=(int)(surf_pt->pt.x);
pt_y=(int)(surf_pt->pt.y);
int sz=surf_pt->size;
int rad_angle=(surf_pt->dir*pi)/180;
cvCircle(buf_frame_3_copy,cvPoint(pt_x,pt_y),1/*sz*/,CV_RGB(0,255,0));
cvLine(buf_frame_3_copy,cvPoint(pt_x,pt_y),cvPoint(pt_x+sz*cosl(rad_angle),pt_y-sz*sinl(rad_angle)),CV_RGB(0,0,255));
}
cvShowImage("SURF from Cam",buf_frame_3_copy);
}
char c=cvWaitKey(33);
if(c==27)
{
break;
}
}
cvReleaseImage(&buf_frame_3_copy);
}
cvShowImage("SURF from Cam",buf_frame_3);
char ch=cvWaitKey(33);
if(ch==27)
break;
if(ch==32)
surf_flag=true;
}
if(gray_copy!=0)
cvReleaseImage(&gray_copy);
cvReleaseCapture(&capture_cam_3);
cvDestroyWindow("SURF from Cam");
}//ending SURF_example
CvFont my_font=cvFont(1,1);
cvInitFont(&my_font,CV_FONT_HERSHEY_SIMPLEX,1.0,1.0);
cvNamedWindow("twoSnapshots",CV_WINDOW_KEEPRATIO);
cvCreateTrackbar("Select LLine","twoSnapshots",0,1000,onTrackbarSlideSelectLine);
CvCapture *capture_4 = 0;
IplImage* left_img=0;
IplImage* right_img=0;
IplImage* cur_frame_buf=0;
IplImage* gray_img_left=0;
IplImage* gray_img_right=0;
IplImage* merged_images=0;
IplImage* merged_images_copy=0;
CvMat *fundamentalMatrix = 0;
vector<KeyPoint> key_points_left;
Mat descriptors_left;
vector<KeyPoint> key_points_right;
Mat descriptors_right;
//CvMemStorage *mem_stor=cvCreateMemStorage(0);*/
float min_hessian_value=1001.0f;
double startValueOfFocus = 350;
char* left_image_file_path = "camera_picture_left.png";
char* right_image_file_path = "camera_picture_right.png";
Array left_points, right_points;
left_points.init(1,1);
right_points.init(1,1);
Array forReconstructionLeftPoints, forReconstructionRightPoints;
forReconstructionLeftPoints.init(1,1);
forReconstructionRightPoints.init(1,1);
while(true)
{
char ch=cvWaitKey(33);
if(ch==27)
break;
// open left and right images
if(ch == 'o' || ch == 'O')
{
openTwoImages(left_image_file_path, right_image_file_path, left_img, right_img );
MergeTwoImages(left_img,right_img,merged_images);
}
// save both left and right images from camera
if(ch == 's' || ch == 'S')
{
if( left_img != 0 )
cvSaveImage(left_image_file_path, left_img);
if( right_img != 0)
cvSaveImage(right_image_file_path, right_img);
}
if(ch=='l'||ch=='L')
{
if(capture_4 == 0)
{
capture_4=cvCreateCameraCapture(0);
}
cur_frame_buf=cvQueryFrame(capture_4);
if(left_img==0)
left_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3);
cvCopy(cur_frame_buf,left_img);
if(right_img == 0)
{
right_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3);
cvCopy(cur_frame_buf,right_img);
}
MergeTwoImages(left_img,right_img,merged_images);
}
if(ch=='r'||ch=='R')
{
if(capture_4 == 0)
{
capture_4=cvCreateCameraCapture(0);
}
cur_frame_buf=cvQueryFrame(capture_4);
if(right_img==0)
right_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3);
cvCopy(cur_frame_buf,right_img);
if(left_img == 0)
{
left_img=cvCreateImage(cvSize(cur_frame_buf->width,cur_frame_buf->height),IPL_DEPTH_8U,3);
cvCopy(cur_frame_buf,left_img);
}
MergeTwoImages(left_img,right_img,merged_images);
}
if(ch=='b'||ch=='B')
{
if(capture_4 == 0)
{
capture_4=cvCreateCameraCapture(0);
}
cur_frame_buf=cvQueryFrame(capture_4);
cvCopy(cur_frame_buf,left_img);
cvCopy(cur_frame_buf,right_img);
}
if(ch=='q'||ch=='Q' && left_img!=0)
{
//proceed left
extractFeaturesFromImage(left_img, min_hessian_value, gray_img_left, key_points_left, descriptors_left);
}
if(ch=='w'||ch=='W' && right_img!=0)
{
//proceed right
extractFeaturesFromImage(right_img, min_hessian_value, gray_img_right, key_points_right, descriptors_right);
}
if(ch=='m'||ch=='M' && left_img!=0 && right_img!=0)
{
//merge two images in to bigger one
MergeTwoImages(left_img,right_img,merged_images);
}
if(ch=='c'||ch=='C' && merged_images!=0)
{
//comparison of two images
if(fundamentalMatrix != 0)
{
cvReleaseMat(& fundamentalMatrix);
fundamentalMatrix = 0;
}
left_to_right_corresponding_points.clear();
right_to_left_corresponding_points.clear();
GetCorrespondingPointsForSURF(key_points_left,descriptors_left,key_points_right,descriptors_right,left_to_right_corresponding_points,right_to_left_corresponding_points);
}
if(ch == 'E' || ch == 'e')
{
//drawing lines for corresponding points
KeyPoint *leftPoint,*rightPoint,*leftPoint2,*rightPoint2;
int width_part=merged_images->width>>1;
/*for(int iL=0;iL<left_to_right_corresponding_points.size();iL++)
{
leftPoint=(CvSURFPoint*)cvGetSeqElem(key_points_left,left_to_right_corresponding_points[iL].first);
rightPoint=(CvSURFPoint*)cvGetSeqElem(key_points_right,left_to_right_corresponding_points[iL].second);
cvLine(merged_images,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y),CV_RGB(255,0,0));
}*/
int sizeOfAccepptedLeftToRightCorrespondings = left_to_right_corresponding_points.size();
bool* acceptedLeftToRightCorrespondings = 0;
getAcceptedCorrespondingsForFindingModelParameters(left_to_right_corresponding_points,
key_points_left,
key_points_right,
fundamentalMatrix,
acceptedLeftToRightCorrespondings,
sizeOfAccepptedLeftToRightCorrespondings);
while(true)
{
merged_images_copy=cvCreateImage(cvSize(merged_images->width,merged_images->height),merged_images->depth,3);
cvCopy(merged_images,merged_images_copy);
int iL=selectedLeftLine;
int iR=iL;
if(iL>=left_to_right_corresponding_points.size())
iL=left_to_right_corresponding_points.size()-1;
if(iR>=right_to_left_corresponding_points.size())
iR=right_to_left_corresponding_points.size()-1;
char str[100]={0};
if(iL >= 0 )
{
bool isLeftToRightLineIsAccepted = acceptedLeftToRightCorrespondings[iL];
// difference value
sprintf(str,"%f",left_to_right_corresponding_points[iL].comparer_value);
cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-40),&my_font,CV_RGB(0,255,0));
// count of Matches
sprintf(str,"%d",left_to_right_corresponding_points[iL].counterOfMatches);
cvPutText(merged_images_copy,str,cvPoint(200,merged_images_copy->height-40),&my_font,CV_RGB(255,255,0));
// median of compared values
sprintf(str,"%lf",left_to_right_corresponding_points[iL].medianOfComparedMatches);
cvPutText(merged_images_copy,str,cvPoint(250,merged_images_copy->height-40),&my_font,CV_RGB(255,0,0));
// Variance of compared values
sprintf(str,"V=%lf",left_to_right_corresponding_points[iL].Variance());
cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-80),&my_font,CV_RGB(0,255,0));
// Standard deviation of compared values
sprintf(str,"SD=%lf",sqrt( left_to_right_corresponding_points[iL].Variance() ));
cvPutText(merged_images_copy,str,cvPoint(250,merged_images_copy->height-80),&my_font,CV_RGB(0,255,0));
double SD = sqrt( left_to_right_corresponding_points[iL].Variance() ) ;
double median = left_to_right_corresponding_points[iL].medianOfComparedMatches;
double compValue = left_to_right_corresponding_points[iL].comparer_value;
double mark_1_5 = median - 1.5 * SD - compValue;
// Mark 1.5
sprintf(str,"m1.5=%lf", mark_1_5);
cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-120),&my_font,CV_RGB(0,255,0));
sprintf(str,"angle=%lf", left_to_right_corresponding_points[iL].degreesBetweenDeltaVector);
cvPutText(merged_images_copy,str,cvPoint(0,merged_images_copy->height-150),&my_font,CV_RGB(0,255,0));
leftPoint= &(key_points_left[ left_to_right_corresponding_points[iL].comp_pair.first ]);
rightPoint=&(key_points_right[ left_to_right_corresponding_points[iL].comp_pair.second ]);
cvLine(merged_images_copy,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y),CV_RGB(0,255,0));
drawEpipolarLinesOnLeftAndRightImages(merged_images_copy, cvPoint(leftPoint->pt.x,leftPoint->pt.y),
cvPoint(rightPoint->pt.x,rightPoint->pt.y), fundamentalMatrix);
CvScalar color = CV_RGB(255, 0, 0);
if(isLeftToRightLineIsAccepted)
{
color = CV_RGB(0,255,0);
}
cvCircle(merged_images_copy, cvPoint(leftPoint->pt.x,leftPoint->pt.y), 5, color);
cvCircle(merged_images_copy, cvPoint(rightPoint->pt.x+width_part,rightPoint->pt.y), 5, color);
}
//cvLine(merged_images_copy,cvPoint(leftPoint->pt.x,leftPoint->pt.y),cvPoint(rightPoint->pt.x,rightPoint->pt.y),CV_RGB(255,0,255));
if(iR >= 0 )
{
sprintf(str,"%f",right_to_left_corresponding_points[iR].comparer_value);
cvPutText(merged_images_copy,str,cvPoint(width_part,merged_images_copy->height-40),&my_font,CV_RGB(255,0,0));
rightPoint2= &(key_points_right [right_to_left_corresponding_points[iR].comp_pair.first]);
leftPoint2= &(key_points_left [right_to_left_corresponding_points[iR].comp_pair.second]);
cvLine(merged_images_copy,cvPoint(leftPoint2->pt.x,leftPoint2->pt.y),cvPoint(rightPoint2->pt.x+width_part,rightPoint2->pt.y),CV_RGB(255,0,0));
}
//cvLine(merged_images_copy,cvPoint(leftPoint2->pt.x+width_part,leftPoint2->pt.y),cvPoint(rightPoint2->pt.x+width_part,rightPoint2->pt.y),CV_RGB(255,0,255));
cvShowImage("twoSnapshots",merged_images_copy);
cvReleaseImage(&merged_images_copy);
char ch2=cvWaitKey(33);
if(ch2==27)
break;
if(ch2=='z' && selectedLeftLine>0)
{
selectedLeftLine--;
}
if(ch2=='x' && selectedLeftLine<1000)
{
selectedLeftLine++;
}
if( ch2 == 'a' || ch2 == 'A')
{
acceptedLeftToRightCorrespondings[selectedLeftLine] = true;
}
if( ch2 == 'd' || ch2 == 'D')
{
acceptedLeftToRightCorrespondings[selectedLeftLine] = false;
}
}//end of while(true)
SaveAcceptedCorresspondings(
left_to_right_corresponding_points,
right_to_left_corresponding_points,
key_points_left,
key_points_right,
acceptedLeftToRightCorrespondings,
sizeOfAccepptedLeftToRightCorrespondings
);
ConvertAcceptedCorresspondingsToMyArray(left_to_right_corresponding_points,
right_to_left_corresponding_points,
key_points_left,
key_points_right,
acceptedLeftToRightCorrespondings,
sizeOfAccepptedLeftToRightCorrespondings,
left_points,
right_points
);
delete[] acceptedLeftToRightCorrespondings;
}
if( ch == 'T' || ch == 't')
{
clock_t startTime = clock();
openTwoImages(left_image_file_path, right_image_file_path, left_img, right_img );
// proceed left
extractFeaturesFromImage(left_img, min_hessian_value, gray_img_left, key_points_left, descriptors_left);
//proceed right
extractFeaturesFromImage(right_img, min_hessian_value, gray_img_right, key_points_right, descriptors_right);
//comparison of two images
if(fundamentalMatrix != 0)
{
cvReleaseMat(& fundamentalMatrix);
fundamentalMatrix = 0;
}
left_to_right_corresponding_points.clear();
right_to_left_corresponding_points.clear();
GetCorrespondingPointsForSURF(key_points_left,descriptors_left,key_points_right,descriptors_right,left_to_right_corresponding_points,right_to_left_corresponding_points);
// searching fundamental matrix and corresponding points
findFundamentalMatrixAndCorrespondingPointsForReconstruction(
left_to_right_corresponding_points,
right_to_left_corresponding_points,
fundamentalMatrix,
key_points_left,
key_points_right,
descriptors_left,
descriptors_right,
left_img,
right_img,
gray_img_left,
gray_img_right,
forReconstructionLeftPoints,
forReconstructionRightPoints,
min_hessian_value, 450);
// selecting points for finding model parameters
int sizeOfAccepptedLeftToRightCorrespondings = left_to_right_corresponding_points.size();
bool* acceptedLeftToRightCorrespondings = 0;
getAcceptedCorrespondingsForFindingModelParameters(left_to_right_corresponding_points,
key_points_left,
key_points_right,
fundamentalMatrix,
acceptedLeftToRightCorrespondings,
sizeOfAccepptedLeftToRightCorrespondings);
ConvertAcceptedCorresspondingsToMyArray(left_to_right_corresponding_points,
right_to_left_corresponding_points,
key_points_left,
key_points_right,
acceptedLeftToRightCorrespondings,
sizeOfAccepptedLeftToRightCorrespondings,
left_points,
right_points
);
delete[] acceptedLeftToRightCorrespondings;
// start process of determination parameters of model and reconstruction of scene
cv::Mat mat_left_img(left_img, true);
cv::Mat mat_right_img(right_img, true);
mainLevenbergMarkvardt_LMFIT(startValueOfFocus, "currentPLYExportFile", left_points, right_points,
mat_left_img, mat_right_img,
forReconstructionLeftPoints, forReconstructionRightPoints);
mat_left_img.release();
mat_right_img.release();
cout << "Code execution time: "<< double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< " seconds." << endl;
}
if( ch == 'I' || ch == 'i')
{
//-- Step 3: Matching descriptor vectors using FLANN matcher
FlannBasedMatcher matcher;
std::vector< DMatch > matches;
matcher.match( descriptors_left, descriptors_right, matches );
//double max_dist = 0; double min_dist = 100;
////-- Quick calculation of max and min distances between keypoints
//for( int i = 0; i < descriptors_left.rows; i++ )
//{ double dist = matches[i].distance;
// if( dist < min_dist ) min_dist = dist;
// if( dist > max_dist ) max_dist = dist;
//}
//printf("-- Max dist : %f \n", max_dist );
//printf("-- Min dist : %f \n", min_dist );
//-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist,
//-- or a small arbitary value ( 0.02 ) in the event that min_dist is very
//-- small)
//-- PS.- radiusMatch can also be used here.
//std::vector< DMatch > good_matches;
left_to_right_corresponding_points.clear();
right_to_left_corresponding_points.clear();
for( int i = 0; i < descriptors_left.rows; i++ )
{
//if( matches[i].distance <= max(2*min_dist, 0.02) )
{
//good_matches.push_back( matches[i]);
left_to_right_corresponding_points.push_back( ComparedIndexes(matches[i].distance, pair<int, int> (i, matches[i].trainIdx)) );
}
}
cout<< "Count of good matches :" << left_to_right_corresponding_points.size() << endl;
stable_sort(left_to_right_corresponding_points.begin(),left_to_right_corresponding_points.end(),my_comparator_for_stable_sort);
}
//if( ch == 'K' || ch == 'k')
//{
// CvSURFPoint *leftPoint;
// //proceed left
// gray_img_left=cvCreateImage(cvSize((left_img->width),(left_img->height)),IPL_DEPTH_8U,1);
// cvCvtColor(left_img,gray_img_left,CV_RGB2GRAY);
// cvExtractSURF(gray_img_left,NULL,&key_points_left,&descriptors_left,mem_stor,cvSURFParams(min_hessian_value,0));
// cv::Mat mat_gray_leftImage(gray_img_left, true);
// cvReleaseImage(&gray_img_left);
// // proceed right
// gray_img_right=cvCreateImage(cvSize((right_img->width),(right_img->height)),IPL_DEPTH_8U,1);
// cvCvtColor(right_img,gray_img_right,CV_RGB2GRAY);
// cv::Mat mat_gray_rightImage(gray_img_right, true);
// cvReleaseImage(&gray_img_right);
// vector<Point2f> LK_left_points;
// vector<Point2f> LK_right_points;
// LK_right_points.resize(key_points_left->total);
// for( int i = 0; i < key_points_left->total; i++)
// {
// leftPoint=(CvSURFPoint*)cvGetSeqElem(key_points_left, i);
// LK_left_points.push_back(Point2f( leftPoint->pt.x, leftPoint->pt.y));
// }
//
// vector<uchar> status;
// vector<float> err;
// cv::calcOpticalFlowPyrLK(
// mat_gray_leftImage,
// mat_gray_rightImage,
// LK_left_points,
// LK_right_points,
// status,
// err);
// int width_part=merged_images->width>>1;
//
// float minErr = err[0];
// for(int k = 0; k < err.size(); k++)
// {
// if(status[k] && err[k] < minErr)
// {
// minErr = err[k];
// }
// }
// cout<< "Lucass Kanade min error: " << minErr<< endl;
// int i = 0;
// merged_images_copy=cvCreateImage(cvSize(merged_images->width,merged_images->height),merged_images->depth,3);
// cvCopy(merged_images,merged_images_copy);
// for(; i < LK_left_points.size(); ++i)
// {
// if(err[i] < 5 * minErr && status[i])
// {
// cvLine(merged_images_copy,cvPoint(LK_left_points[i].x,LK_left_points[i].y),cvPoint(LK_right_points[i].x+width_part,LK_right_points[i].y),
// CV_RGB(100 + (( i *3) % 155), 100+ ((i*7)%155), 100+ ((i*13)%155)));
// }
// }
// cvShowImage("twoSnapshots",merged_images_copy);
//
// while(true)
// {
// char ch2=cvWaitKey(33);
// if(ch2==27)
// break;
//
// }
//
// cvReleaseImage(&merged_images_copy);
// status.clear();
// err.clear();
// LK_left_points.clear();
// LK_right_points.clear();
// mat_gray_leftImage.release();
// mat_gray_rightImage.release();
//}
if( ch == 'F' || ch == 'f')
{
findFundamentalMatrixAndCorrespondingPointsForReconstruction(
left_to_right_corresponding_points,
right_to_left_corresponding_points,
fundamentalMatrix,
key_points_left,
key_points_right,
descriptors_left,
descriptors_right,
left_img,
right_img,
gray_img_left,
gray_img_right,
forReconstructionLeftPoints,
forReconstructionRightPoints,
min_hessian_value);
}
if( ch == 'P' || ch == 'p')
{
cv::Mat mat_left_img(left_img, true);
cv::Mat mat_right_img(right_img, true);
mainLevenbergMarkvardt_LMFIT(startValueOfFocus, "currentPLYExportFile", left_points, right_points,
mat_left_img, mat_right_img,
forReconstructionLeftPoints, forReconstructionRightPoints);
mat_left_img.release();
mat_right_img.release();
}
if(merged_images!=0)
{
cvShowImage("twoSnapshots",merged_images);
}
}
int ObjectRecognition::find(Mat _image)
{
//-----------------------------------------------------------
// image = imread( "../../../New_modules1/image_014.jpeg");
// image = imread( "../../../TestDATA/snap-unknown-20120901-203157-1.jpeg" );
// imshow( "mywindow", image );
// waitKey(0);
// imshow("Capure_Image", image);
// waitKey();
//-----------------Extract the features----------------------------
//cout<< ss.str() << endl;
double t = (double)cvGetTickCount();
loadFeatures(_image, keypoints, features, descriptors);
//-----------------Query the Database----------------------------
//cout <<endl<<"-----------------Start to QUERY-------------------" <<endl;
queryDatabase(features, db, ret, ret_num);
//testAP(ret);
//cout << ret <<endl;
//t = (double)cvGetTickCount()-t;
// cout << "voc tree time = " << t/((double)cvGetTickFrequency()*1000)<< endl;
//if (ret[0].Score<0.6 && ret[0].Score>0.24)
{
cout << " Start to Homography " <<endl;
initModule_nonfree();
double HomographyT = (double)cvGetTickCount();
checkHomography( _image, keypoints, descriptors, ret);
HomographyT = (double)cvGetTickCount()-HomographyT;
cout << "Homography time (ms) = " << HomographyT/((double)cvGetTickFrequency()*1000)<< endl;
sort(ret.begin(), ret.end());
// if ((ranking/(OBJ_IMG+1))==(ret[0].Id/(OBJ_IMG+1)))
// AP+=1;
//cout<<ret<<endl<<endl;
}
int dis_id=0;
bool ret_correct_flag = false;
int ret_end = ret.size()-1;
if (ret[ret_end].Score>ret[0].Score)
{
if(ret[ret_end].Id/10==ret[ret_end-1].Id/10)
{
dis_id = ret_end;
ret_correct_flag = true;
}
}
else
{
if (ret[1].Id/10==ret[0].Id/10)
{
dis_id = 0;
ret_correct_flag = true;
}
}
if ((ret[dis_id].Score>=0.6) && ret_correct_flag)
{
cout<< "-----Object "<< ret[dis_id].Id << " is detected!!!---------------"<<endl;
return ret[dis_id].Id;
// stringstream ss;
// ss<<"../../../New_modules1/image_";
// if(ret[dis_id].Id<10) ss<< "00"<<ret[dis_id].Id<< ".jpeg";
// if(ret[dis_id].Id>=10&&ret[dis_id].Id<100) ss<< "0"<<ret[dis_id].Id<<".jpeg";
// if(ret[dis_id].Id>=100 ) ss<< ret[dis_id].Id<<".jpeg";
// cout<< ss.str()<< endl;
// Mat r=imread(ss.str());
// // namedWindow(ss.str());
// // imshow(ss.str(), r);
// // moveWindow(ss.str(), 650, 0);
// imshow("result", r);
// waitKey(0);
}
else
{
cout<< "No object!!!!!"<<endl;
return 255;
}
//cout<<"AP is : " << AP <<endl<<endl<<endl;
//testAP(ret);
//------------------------------------------------------------------
// waitKey(0);
// if ( (waitKey(1) & 255) == 27 ) break;
return 255;
}
