学习OpenCV——Surf（特征点篇）&flann(二)

代码：                                                                                                             

来源：OpenCV/sample/c中的find_obj.cpp代码

 文章出处：http://blog.csdn.net/sangni007/article/details/7482960

需仔细注意：

1.定位部分：通过透视变换，画出了目标在图像中的位置，但是这么做会浪费很多时间，可以改进：

2.flann寻找最近的临近Keypoints：

首先，利用图像，构建多维查找树，然后，利用Knn算法找到最近的Keypoints (KNN算法：http://blog.csdn.net/sangni007/article/details/7482890）

[cpp]  view plain copy print ?

1. //Constructs a nearest neighbor search index for a given dataset  
2. //利用m_image构造 a set of randomized kd-trees 一系列随机多维检索树;  
3. cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4));  // using 4 randomized kdtrees  
4. //利用Knn近邻算法检索m_object；结果存入 m_indices, m_dists；  
5. flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked  

flann算法有很多功能，

文档：http://opencv.itseez.com/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html?highlight=flann#fast-approximate-nearest-neighbor-search

 

[cpp]  view plain copy print ?

1. /* 
2.  * A Demo to OpenCV Implementation of SURF 
3.  * Further Information Refer to "SURF: Speed-Up Robust Feature" 
4.  * Author: Liu Liu 
5.  * liuliu.1987+opencv@gmail.com 
6.  */  
7. #include "opencv2/objdetect/objdetect.hpp"  
8. #include "opencv2/features2d/features2d.hpp"  
9. #include "opencv2/highgui/highgui.hpp"  
10. #include "opencv2/calib3d/calib3d.hpp"  
11. #include "opencv2/imgproc/imgproc_c.h"#include <iostream>  
12. #include <vector>  
13. #include <stdio.h>using namespace std;  
14. void help()  
15. {  
16.     printf(  
17.         "This program demonstrated the use of the SURF Detector and Descriptor using\n"  
18.         "either FLANN (fast approx nearst neighbor classification) or brute force matching\n"  
19.         "on planar objects.\n"  
20.         "Usage:\n"  
21.         "./find_obj <object_filename> <scene_filename>, default is box.png  and box_in_scene.png\n\n");  
22.     return;  
23. }// define whether to use approximate nearest-neighbor search  
24. #define USE_FLANN  
25. IplImage* image = 0;double compareSURFDescriptors( const float* d1, const float* d2, double best, int length )  
26. {  
27.     double total_cost = 0;  
28.     assert( length % 4 == 0 );  
29.     for( int i = 0; i < length; i += 4 )  
30.     {  
31.         double t0 = d1[i  ] - d2[i  ];  
32.         double t1 = d1[i+1] - d2[i+1];  
33.         double t2 = d1[i+2] - d2[i+2];  
34.         double t3 = d1[i+3] - d2[i+3];  
35.         total_cost += t0*t0 + t1*t1 + t2*t2 + t3*t3;  
36.         if( total_cost > best )  
37.             break;  
38.     }  
39.     return total_cost;  
40. }  
41. int naiveNearestNeighbor( const float* vec, int laplacian,  
42.                       const CvSeq* model_keypoints,  
43.                       const CvSeq* model_descriptors )  
44. {  
45.     int length = (int)(model_descriptors->elem_size/sizeof(float));  
46.     int i, neighbor = -1;  
47.     double d, dist1 = 1e6, dist2 = 1e6;  
48.     CvSeqReader reader, kreader;  
49.     cvStartReadSeq( model_keypoints, &kreader, 0 );  
50.     cvStartReadSeq( model_descriptors, &reader, 0 );    for( i = 0; i < model_descriptors->total; i++ )  
51.     {  
52.         const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;  
53.         const float* mvec = (const float*)reader.ptr;  
54.      CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );  
55.         CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );  
56.         if( laplacian != kp->laplacian )  
57.             continue;  
58.         d = compareSURFDescriptors( vec, mvec, dist2, length );  
59.         if( d < dist1 )  
60.         {  
61.             dist2 = dist1;  
62.             dist1 = d;  
63.             neighbor = i;  
64.         }  
65.         else if ( d < dist2 )  
66.             dist2 = d;  
67.     }  
68.     if ( dist1 < 0.6*dist2 )  
69.         return neighbor;  
70.     return -1;  
71. }//用于找到两幅图像之间匹配的点对，并把匹配的点对存储在 ptpairs 向量中，其中物体(object)图像的特征点  
72. //及其相应的描述器（局部特征）分别存储在 objectKeypoints 和 objectDescriptors，场景(image)图像的特  
73. //征点及其相应的描述器（局部特征）分别存储在 imageKeypoints和 imageDescriptors  
74. void findPairs( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,  
75.            const CvSeq* imageKeypoints, const CvSeq* imageDescriptors, vector<int>& ptpairs )  
76. {  
77.     int i;  
78.     CvSeqReader reader, kreader;  
79.     cvStartReadSeq( objectKeypoints, &kreader );  
80.     cvStartReadSeq( objectDescriptors, &reader );  
81.     ptpairs.clear();    for( i = 0; i < objectDescriptors->total; i++ )  
82.     {  
83.         const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;  
84.         const float* descriptor = (const float*)reader.ptr;  
85.         CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );  
86.         CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );  
87.         int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, imageKeypoints, imageDescriptors );  
88.         if( nearest_neighbor >= 0 )  
89.         {  
90.             ptpairs.push_back(i);  
91.             ptpairs.push_back(nearest_neighbor);  
92.         }  
93.     }  
94. }//Fast Library for Approximate Nearest Neighbors（FLANN）  
95. void flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,  
96.            const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )  
97. {  
98.  int length = (int)(objectDescriptors->elem_size/sizeof(float));    cv::Mat m_object(objectDescriptors->total, length, CV_32F);  
99.  cv::Mat m_image(imageDescriptors->total, length, CV_32F);  
100.  // copy descriptors  
101.     CvSeqReader obj_reader;  
102.  float* obj_ptr = m_object.ptr<float>(0);  
103.     cvStartReadSeq( objectDescriptors, &obj_reader );  
104.  //objectDescriptors to m_object   
105.     for(int i = 0; i < objectDescriptors->total; i++ )  
106.     {  
107.         const float* descriptor = (const float*)obj_reader.ptr;  
108.         CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );  
109.         memcpy(obj_ptr, descriptor, length*sizeof(float));  
110.         obj_ptr += length;  
111.     }  
112.  //imageDescriptors to m_image  
113.     CvSeqReader img_reader;  
114.  float* img_ptr = m_image.ptr<float>(0);  
115.     cvStartReadSeq( imageDescriptors, &img_reader );  
116.     for(int i = 0; i < imageDescriptors->total; i++ )  
117.     {  
118.         const float* descriptor = (const float*)img_reader.ptr;  
119.         CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );  
120.         memcpy(img_ptr, descriptor, length*sizeof(float));  
121.         img_ptr += length;  
122.     }    // find nearest neighbors using FLANN  
123.     cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);  
124.     cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);  
125.  //Constructs a nearest neighbor search index for a given dataset  
126.  //利用m_image构造 a set of randomized kd-trees 一系列随机多维检索树;  
127.     cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4));  // using 4 randomized kdtrees  
128.  //利用Knn近邻算法检索m_object；结果存入 m_indices, m_dists；  
129.     flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked    int* indices_ptr = m_indices.ptr<int>(0);  
130.     float* dists_ptr = m_dists.ptr<float>(0);  
131.     for (int i=0;i<m_indices.rows;++i)   
132.  {  
133.      if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1])  
134.   {  
135.       ptpairs.push_back(i);  
136.       ptpairs.push_back(indices_ptr[2*i]);  
137.      }  
138.     }  
139. }//用于寻找物体(object)在场景(image)中的位置,位置信息保存在参数dst_corners中，参数src_corners由物  
140. //体(object的width几height等决定，其他部分参数如上findPairs  
141. /* a rough implementation for object location */  
142. int locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,  
143.  const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,  
144.  const CvPoint src_corners[4], CvPoint dst_corners[4] )  
145. {  
146.     double h[9];  
147.     CvMat _h = cvMat(3, 3, CV_64F, h);  
148.     vector<int> ptpairs;  
149.     vector<CvPoint2D32f> pt1, pt2;  
150.     CvMat _pt1, _pt2;  
151.     int i, n;#ifdef USE_FLANN  
152.     flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );  
153. #else  
154.     findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );  
155. #endif    n = (int)(ptpairs.size()/2);  
156.     if( n < 4 )  
157.         return 0;    pt1.resize(n);  
158.     pt2.resize(n);  
159.     for( i = 0; i < n; i++ )  
160.     {  
161.         pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;  
162.         pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;  
163.     }    _pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );  
164.     _pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );  
165.     if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))//计算两个平面之间的透视变换  
166.         return 0;    for( i = 0; i < 4; i++ )  
167.     {  
168.         double x = src_corners[i].x, y = src_corners[i].y;  
169.         double Z = 1./(h[6]*x + h[7]*y + h[8]);  
170.         double X = (h[0]*x + h[1]*y + h[2])*Z;  
171.         double Y = (h[3]*x + h[4]*y + h[5])*Z;  
172.         dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));  
173.     }    return 1;  
174. }  
175.   
176. int main(int argc, char** argv)  
177. {  
178.  //物体(object)和场景(scene)的图像向来源  
179.     const char* object_filename = argc == 3 ? argv[1] : "D:/src.jpg";  
180.     const char* scene_filename = argc == 3 ? argv[2] : "D:/Demo.jpg";    help();    IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );  
181.     IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );  
182.     if( !object || !image )  
183.     {  
184.         fprintf( stderr, "Can not load %s and/or %s\n",  
185.             object_filename, scene_filename );  
186.         exit(-1);  
187.     }  
188.  //内存存储器  
189.     CvMemStorage* storage = cvCreateMemStorage(0);    cvNamedWindow("Object", 1);  
190.     cvNamedWindow("Object Correspond", 1);    static CvScalar colors[] =   
191.     {  
192.         {{0,0,255}},  
193.         {{0,128,255}},  
194.         {{0,255,255}},  
195.         {{0,255,0}},  
196.         {{255,128,0}},  
197.         {{255,255,0}},  
198.         {{255,0,0}},  
199.         {{255,0,255}},  
200.         {{255,255,255}}  
201.     };  
202.     
203.     IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);  
204.     cvCvtColor( object, object_color, CV_GRAY2BGR );    CvSeq* objectKeypoints = 0, *objectDescriptors = 0;  
205.     CvSeq* imageKeypoints = 0, *imageDescriptors = 0;  
206.     int i;  
207.  /* 
208.  CvSURFParams params = cvSURFParams(500, 1);//SURF参数设置：阈值500，生成128维描述符 
209.  cvSURFParams 函数原型如下： 
210.  CvSURFParams cvSURFParams(double threshold, int extended) 
211.  { 
212.   CvSURFParams params; 
213.   params.hessianThreshold = threshold; // 特征点选取的 hessian 阈值 
214.   params.extended = extended; // 是否扩展，1 - 生成128维描述符，0 - 64维描述符 
215.   params.nOctaves = 4;  
216.   params.nOctaveLayers = 2; 
217.   return params; 
218.  } 
219.  */  
220.  CvSURFParams params = cvSURFParams(500, 1);    double tt = (double)cvGetTickCount();//计时  
221.  /* 
222.  提取图像中的特征点，函数原型： 
223.  CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask, 
224.  CvSeq** keypoints, CvSeq** descriptors, 
225.  CvMemStorage* storage, CvSURFParams params, int useProvidedKeyPts CV_DEFAULT(0) ); 
226.  第3、4个参数返回结果：特征点和特征点描述符，数据类型是指针的指针， 
227.  */  
228.     cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params );  
229.     printf("Object Descriptors: %d\n", objectDescriptors->total);    cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params );  
230.     printf("Image Descriptors: %d\n", imageDescriptors->total);  
231.     tt = (double)cvGetTickCount() - tt;    printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));  
232.     CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};  
233.     //定义感兴趣的区域  
234.  CvPoint dst_corners[4];  
235.     IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );  
236.  //设置感兴趣区域  
237.  //形成一大一小两幅图显示在同一窗口  
238.     cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );  
239.     cvCopy( object, correspond );  
240.     cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );  
241.     cvCopy( image, correspond );  
242.     cvResetImageROI( correspond );#ifdef USE_FLANN  
243.     printf("Using approximate nearest neighbor search\n");  
244. #endif  
245.  //寻找物体(object)在场景(image)中的位置，并将信息保存（矩形框）  
246.     if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,  
247.         imageDescriptors, src_corners, dst_corners ))  
248.     {  
249.         for( i = 0; i < 4; i++ )  
250.         {  
251.             CvPoint r1 = dst_corners[i%4];  
252.             CvPoint r2 = dst_corners[(i+1)%4];  
253.    cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),  
254.     cvPoint(r2.x, r2.y+object->height ), colors[8] );  
255.         }  
256.     }  
257.  //定义并保存物体(object)在场景(image)图形之间的匹配点对，并将其存储在向量 ptpairs 中，之后可以对  
258.  //ptpairs 进行操作  
259.     vector<int> ptpairs;  
260. #ifdef USE_FLANN  
261.     flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );  
262. #else  
263.     findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );  
264. #endif  
265.  //显示匹配结果（直线连接）  
266.     for( i = 0; i < (int)ptpairs.size(); i += 2 )  
267.     {  
268.         CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );  
269.         CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );  
270.         cvLine( correspond, cvPointFrom32f(r1->pt),  
271.             cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );  
272.     }    cvShowImage( "Object Correspond", correspond );  
273.  //显示物体(object)的所有特征点  
274.     for( i = 0; i < objectKeypoints->total; i++ )  
275.     {  
276.         CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );  
277.         CvPoint center;  
278.         int radius;  
279.         center.x = cvRound(r->pt.x);  
280.         center.y = cvRound(r->pt.y);  
281.         radius = cvRound(r->size*1.2/9.*2);  
282.         cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );  
283.     }  
284.     cvShowImage( "Object", object_color );    cvWaitKey(0); //释放窗口所占用的内存  
285.     cvDestroyWindow("Object");  
286.     cvDestroyWindow("Object Correspond");    return 0;  
287. }  
288.