ORB原理与Opencv源码解析

转自：http://blog.youkuaiyun.com/haoliliang88/article/details/51841131

为了满足实时性的要求，前面文章中介绍过快速提取特征点算法Fast,以及特征描述子Brief。本篇文章介绍的ORB算法结合了Fast和Brief的速度优势，并做了改进，且ORB是免费。

   Ethan Rublee等人2011年在《ORB：An Efficient Alternative to SIFT or SURF》文章中提出了ORB算法。结合Fast与Brief算法，并给Fast特征点增加了方向性，使得特征点具有旋转不变性，并提出了构造金字塔方法，解决尺度不变性，但文章中没有具体详述。实验证明，ORB远优于之前的SIFT与SURF算法。

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

论文核心内容概述：

1.构造金字塔，在每层金字塔上采用Fast算法提取特征点，采用Harris角点响应函数，按角点响应值排序，选取前N个特征点。

2. oFast:计算每个特征点的主方向，灰度质心法，计算特征点半径为r的圆形邻域范围内的灰度质心位置。从中心位置到质心位置的向量，定义为该特 征点的主方向。

  定义矩的计算公式，x,y∈[-r,r]：

                                 

             质心位置：

                               

               主方向：

                                  

3.rBrief:为了解决旋转不变性，把特征点的Patch旋转到主方向上(steered Brief)。通过实验得到，描述子在各个维度上的均值比较离散(偏离0.5)，同时维度间相关性很强，说明特征点描述子区分性不好，影响匹配的效果。论文中提出采取学习的方法，采用300K个训练样本点。每一个特征点，选取Patch大小为wp=31，Patch内每对点都采用wt=5大小的子窗口灰度均值做比较，子窗口的个数即为N=(wp-wt)*(wp-wt),从N个窗口中随机选两个做比较即构成描述子的一个bit,论文中采用M=205590种可能的情况：   

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

        1.对所有样本点，做M种测试，构成M维的描述子，每个维度上非1即0；

        2.按均值对M个维度排序（以0.5为中心），组成向量T；

        3.贪婪搜索：把向量T中第一个元素移动到R中，然后继续取T的第二个元素，与R中的所有元素做相关性比较，如果相关性大于指定的阈值Threshold,           抛弃T的这个元素，否则加入到R中；

        4.重复第3个步骤，直到R中有256个元素，若检测完毕,少于256个元素，则降低阈值，重复上述步骤；

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

    rBrief:通过上面的步骤取到的256对点，构成的描述子各维度间相关性很低，区分性好；

                                        

                                              训练前                                            训练后

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

ORB算法步骤,参考OpenCV源码:

1.首先构造尺度金字塔；

   金字塔共n层，与SIFT不同，每层仅有一副图像；

   第s层的尺度为，Fator初始尺度(默认为1.2)，原图在第0层；

   第s层图像大小:

                              ；

2.在不同尺度上采用Fast检测特征点；在每一层上按公式计算需要提取的特征点数n,在本层上按Fast角点响应值排序，提取前2n个特征点，然后根据Harris   角点响应值排序， 取前n个特征点，作为本层的特征点；

3.计算每个特征点的主方向（质心法）；

4.旋转每个特征点的Patch到主方向，采用上述步骤3的选取的最优的256对特征点做τ测试，构成256维描述子，占32个字节；

                   ,,n=256

4.采用汉明距离做特征点匹配；

----------OpenCV源码解析-------------------------------------------------------

ORB类定义：位置..\features2d.hpp

nfeatures:需要的特征点总数；

scaleFactor:尺度因子；

nlevels:金字塔层数；

edgeThreshold:边界阈值；

firstLevel:起始层；

 WTA_K：描述子形成方法,WTA_K=2表示，采用两两比较；

 scoreType:角点响应函数，可以选择Harris或者Fast的方法；

 patchSize:特征点邻域大小；

[cpp]  view plain  copy

 

 

1. /*! 
2.  ORB implementation. 
3. */  
4. class CV_EXPORTS_W ORB : public Feature2D  
5. {  
6. public:  
7.     // the size of the signature in bytes  
8.     enum { kBytes = 32, HARRIS_SCORE=0, FAST_SCORE=1 };  
9.   
10.     CV_WRAP explicit ORB(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31,//构造函数  
11.         int firstLevel = 0, int WTA_K=2, int scoreType=ORB::HARRIS_SCORE, int patchSize=31 );  
12.   
13.     // returns the descriptor size in bytes  
14.     int descriptorSize() const;   //描述子占用的字节数，默认32字节  
15.     // returns the descriptor type  
16.     int descriptorType() const;//描述子类型，8位整形数  
17.   
18.     // Compute the ORB features and descriptors on an image  
19.     void operator()(InputArray image, InputArray mask, vector<KeyPoint>& keypoints) const;  
20.   
21.     // Compute the ORB features and descriptors on an image  
22.     void operator()( InputArray image, InputArray mask, vector<KeyPoint>& keypoints,    //提取特征点与形成描述子  
23.                      OutputArray descriptors, bool useProvidedKeypoints=false ) const;  
24.   
25.     AlgorithmInfo* info() const;  
26.   
27. protected:  
28.   
29.     void computeImpl( const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors ) const;//计算描述子  
30.     void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;//检测特征点  
31.   
32.     CV_PROP_RW int nfeatures;//特征点总数  
33.     CV_PROP_RW double scaleFactor;//尺度因子  
34.     CV_PROP_RW int nlevels;//金字塔内层数  
35.     CV_PROP_RW int edgeThreshold;//边界阈值  
36.     CV_PROP_RW int firstLevel;//开始层数  
37.     CV_PROP_RW int WTA_K;//描述子形成方法，默认WTA_K=2，两两比较  
38.     CV_PROP_RW int scoreType;//角点响应函数  
39.     CV_PROP_RW int patchSize;//邻域Patch大小  
40. };  

特征提取及形成描述子：通过这个函数对图像提取Fast特征点或者计算特征描述子

_image:输入图像；

_mask:掩码图像;

_keypoints:输入角点；

_descriptors:如果为空，只寻找特征点，不计算特征描述子；

_useProvidedKeypoints:如果为true,函数只计算特征描述子；

[cpp]  view plain  copy

 

 

1. /** Compute the ORB features and descriptors on an image 
2.  * @param img the image to compute the features and descriptors on 
3.  * @param mask the mask to apply 
4.  * @param keypoints the resulting keypoints 
5.  * @param descriptors the resulting descriptors 
6.  * @param do_keypoints if true, the keypoints are computed, otherwise used as an input 
7.  * @param do_descriptors if true, also computes the descriptors 
8.  */  
9. void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _keypoints,  
10.                       OutputArray _descriptors, bool useProvidedKeypoints) const  
11. {  
12.     CV_Assert(patchSize >= 2);  
13.   
14.     bool do_keypoints = !useProvidedKeypoints;  
15.     bool do_descriptors = _descriptors.needed();  
16.   
17.     if( (!do_keypoints && !do_descriptors) || _image.empty() )  
18.         return;  
19.   
20.     //ROI handling  
21.     const int HARRIS_BLOCK_SIZE = 9;//Harris角点响应需要的边界大小  
22.     int halfPatchSize = patchSize / 2;.//邻域半径  
23.     int border = std::max(edgeThreshold, std::max(halfPatchSize, HARRIS_BLOCK_SIZE/2))+1;//采用最大的边界  
24.   
25.     Mat image = _image.getMat(), mask = _mask.getMat();  
26.     if( image.type() != CV_8UC1 )  
27.         cvtColor(_image, image, CV_BGR2GRAY);//转灰度图  
28.   
29.     int levelsNum = this->nlevels;//金字塔层数  
30.   
31.     if( !do_keypoints )   //不做特征点检测  
32.     {  
33.         // if we have pre-computed keypoints, they may use more levels than it is set in parameters  
34.         // !!!TODO!!! implement more correct method, independent from the used keypoint detector.  
35.         // Namely, the detector should provide correct size of each keypoint. Based on the keypoint size  
36.         // and the algorithm used (i.e. BRIEF, running on 31x31 patches) we should compute the approximate  
37.         // scale-factor that we need to apply. Then we should cluster all the computed scale-factors and  
38.         // for each cluster compute the corresponding image.  
39.         //  
40.         // In short, ultimately the descriptor should  
41.         // ignore octave parameter and deal only with the keypoint size.  
42.         levelsNum = 0;  
43.         for( size_t i = 0; i < _keypoints.size(); i++ )  
44.             levelsNum = std::max(levelsNum, std::max(_keypoints[i].octave, 0));//提取特征点的最大层数  
45.         levelsNum++;  
46.     }  
47.   
48.     // Pre-compute the scale pyramids  
49.     vector<Mat> imagePyramid(levelsNum), maskPyramid(levelsNum);//创建尺度金字塔图像  
50.     for (int level = 0; level < levelsNum; ++level)  
51.     {  
52.         float scale = 1/getScale(level, firstLevel, scaleFactor);  //每层对应的尺度  
53.         /* 
54.         static inline float getScale(int level, int firstLevel, double scaleFactor) 
55.             { 
56.                    return (float)std::pow(scaleFactor, (double)(level - firstLevel)); 
57.             }    
58.         */  
59.         Size sz(cvRound(image.cols*scale), cvRound(image.rows*scale));//每层对应的图像大小  
60.         Size wholeSize(sz.width + border*2, sz.height + border*2);  
61.         Mat temp(wholeSize, image.type()), masktemp;  
62.         imagePyramid[level] = temp(Rect(border, border, sz.width, sz.height));  
63.         if( !mask.empty() )  
64.         {  
65.             masktemp = Mat(wholeSize, mask.type());  
66.             maskPyramid[level] = masktemp(Rect(border, border, sz.width, sz.height));  
67.         }  
68.   
69.         // Compute the resized image  
70.         if( level != firstLevel )    //得到金字塔每层的图像  
71.         {  
72.             if( level < firstLevel )  
73.             {  
74.                 resize(image, imagePyramid[level], sz, 0, 0, INTER_LINEAR);  
75.                 if (!mask.empty())  
76.                     resize(mask, maskPyramid[level], sz, 0, 0, INTER_LINEAR);  
77.             }  
78.             else  
79.             {  
80.                 resize(imagePyramid[level-1], imagePyramid[level], sz, 0, 0, INTER_LINEAR);  
81.                 if (!mask.empty())  
82.                 {  
83.                     resize(maskPyramid[level-1], maskPyramid[level], sz, 0, 0, INTER_LINEAR);  
84.                     threshold(maskPyramid[level], maskPyramid[level], 254, 0, THRESH_TOZERO);  
85.                 }  
86.             }  
87.   
88.             copyMakeBorder(imagePyramid[level], temp, border, border, border, border,//扩大图像的边界  
89.                            BORDER_REFLECT_101+BORDER_ISOLATED);  
90.             if (!mask.empty())  
91.                 copyMakeBorder(maskPyramid[level], masktemp, border, border, border, border,  
92.                                BORDER_CONSTANT+BORDER_ISOLATED);  
93.         }  
94.         else  
95.         {  
96.             copyMakeBorder(image, temp, border, border, border, border,//扩大图像的四个边界  
97.                            BORDER_REFLECT_101);  
98.             if( !mask.empty() )  
99.                 copyMakeBorder(mask, masktemp, border, border, border, border,  
100.                                BORDER_CONSTANT+BORDER_ISOLATED);  
101.         }  
102.     }  
103.   
104.     // Pre-compute the keypoints (we keep the best over all scales, so this has to be done beforehand  
105.     vector < vector<KeyPoint> > allKeypoints;  
106.     if( do_keypoints )//提取角点  
107.     {  
108.         // Get keypoints, those will be far enough from the border that no check will be required for the descriptor  
109.         computeKeyPoints(imagePyramid, maskPyramid, allKeypoints,  //对每一层图像提取角点，见下面(1)的分析  
110.                          nfeatures, firstLevel, scaleFactor,  
111.                          edgeThreshold, patchSize, scoreType);  
112.   
113.         // make sure we have the right number of keypoints keypoints  
114.         /*vector<KeyPoint> temp; 
115.  
116.         for (int level = 0; level < n_levels; ++level) 
117.         { 
118.             vector<KeyPoint>& keypoints = all_keypoints[level]; 
119.             temp.insert(temp.end(), keypoints.begin(), keypoints.end()); 
120.             keypoints.clear(); 
121.         } 
122.  
123.         KeyPoint::retainBest(temp, n_features_); 
124.  
125.         for (vector<KeyPoint>::iterator keypoint = temp.begin(), 
126.              keypoint_end = temp.end(); keypoint != keypoint_end; ++keypoint) 
127.             all_keypoints[keypoint->octave].push_back(*keypoint);*/  
128.     }  
129.     else  //不提取角点  
130.     {  
131.         // Remove keypoints very close to the border  
132.         KeyPointsFilter::runByImageBorder(_keypoints, image.size(), edgeThreshold);  
133.   
134.         // Cluster the input keypoints depending on the level they were computed at  
135.         allKeypoints.resize(levelsNum);  
136.         for (vector<KeyPoint>::iterator keypoint = _keypoints.begin(),  
137.              keypointEnd = _keypoints.end(); keypoint != keypointEnd; ++keypoint)  
138.             allKeypoints[keypoint->octave].push_back(*keypoint);    //把角点信息存入allKeypoints内  
139.   
140.         // Make sure we rescale the coordinates  
141.         for (int level = 0; level < levelsNum; ++level)   //把角点位置信息缩放到指定层位置上  
142.         {  
143.             if (level == firstLevel)  
144.                 continue;  
145.   
146.             vector<KeyPoint> & keypoints = allKeypoints[level];  
147.             float scale = 1/getScale(level, firstLevel, scaleFactor);  
148.             for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),  
149.                  keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)  
150.                 keypoint->pt *= scale;   //缩放  
151.         }  
152.     }  
153.   
154.     Mat descriptors;          
155.     vector<Point> pattern;  
156.   
157.     if( do_descriptors ) //计算特征描述子  
158.     {  
159.         int nkeypoints = 0;  
160.         for (int level = 0; level < levelsNum; ++level)  
161.             nkeypoints += (int)allKeypoints[level].size();//得到所有层的角点总数  
162.         if( nkeypoints == 0 )  
163.             _descriptors.release();  
164.         else  
165.         {  
166.             _descriptors.create(nkeypoints, descriptorSize(), CV_8U);//创建一个矩阵存放描述子,每一行表示一个角点信息  
167.             descriptors = _descriptors.getMat();  
168.         }  
169.   
170.         const int npoints = 512;//取512个点,共256对,产生256维描述子,32个字节  
171.         Point patternbuf[npoints];  
172.         const Point* pattern0 = (const Point*)bit_pattern_31_;//训练好的256对数据点位置  
173.   
174.         if( patchSize != 31 )  
175.         {  
176.             pattern0 = patternbuf;  
177.             makeRandomPattern(patchSize, patternbuf, npoints);  
178.         }  
179.   
180.         CV_Assert( WTA_K == 2 || WTA_K == 3 || WTA_K == 4 );  
181.   
182.         if( WTA_K == 2 )  //WTA_K=2使用两个点之间作比较  
183.             std::copy(pattern0, pattern0 + npoints, std::back_inserter(pattern));  
184.         else  
185.         {  
186.             int ntuples = descriptorSize()*4;  
187.             initializeOrbPattern(pattern0, pattern, ntuples, WTA_K, npoints);  
188.         }  
189.     }  
190.   
191.     _keypoints.clear();  
192.     int offset = 0;  
193.     for (int level = 0; level < levelsNum; ++level)//依次计算每一层的角点描述子  
194.     {  
195.         // Get the features and compute their orientation  
196.         vector<KeyPoint>& keypoints = allKeypoints[level];  
197.         int nkeypoints = (int)keypoints.size();//本层内角点个数  
198.   
199.         // Compute the descriptors  
200.         if (do_descriptors)  
201.         {  
202.             Mat desc;  
203.             if (!descriptors.empty())  
204.             {  
205.                 desc = descriptors.rowRange(offset, offset + nkeypoints);  
206.             }  
207.   
208.             offset += nkeypoints;  //偏移量  
209.             // preprocess the resized image  
210.             Mat& workingMat = imagePyramid[level];  
211.             //boxFilter(working_mat, working_mat, working_mat.depth(), Size(5,5), Point(-1,-1), true, BORDER_REFLECT_101);  
212.             GaussianBlur(workingMat, workingMat, Size(7, 7), 2, 2, BORDER_REFLECT_101);//高斯平滑图像  
213.             computeDescriptors(workingMat, keypoints, desc, pattern, descriptorSize(), WTA_K);//计算本层内角点的描述子,（3）  
214.         }  
215.   
216.         // Copy to the output data  
217.         if (level != firstLevel)  //角点位置信息返回到原图上  
218.         {  
219.             float scale = getScale(level, firstLevel, scaleFactor);  
220.             for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),  
221.                  keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)  
222.                 keypoint->pt *= scale;   
223.         }  
224.         // And add the keypoints to the output  
225.         _keypoints.insert(_keypoints.end(), keypoints.begin(), keypoints.end());//存入描述子信息，返回  
226.     }  
227. }  

（1）提取角点：computeKeyPoints

imagePyramid:即构造好的金字塔

[cpp]  view plain  copy

 

 

1. /** Compute the ORB keypoints on an image 
2.  * @param image_pyramid the image pyramid to compute the features and descriptors on 
3.  * @param mask_pyramid the masks to apply at every level 
4.  * @param keypoints the resulting keypoints, clustered per level 
5.  */  
6. static void computeKeyPoints(const vector<Mat>& imagePyramid,  
7.                              const vector<Mat>& maskPyramid,  
8.                              vector<vector<KeyPoint> >& allKeypoints,  
9.                              int nfeatures, int firstLevel, double scaleFactor,  
10.                              int edgeThreshold, int patchSize, int scoreType )  
11. {  
12.     int nlevels = (int)imagePyramid.size();  //金字塔层数  
13.     vector<int> nfeaturesPerLevel(nlevels);  
14.   
15.     // fill the extractors and descriptors for the corresponding scales  
16.     float factor = (float)(1.0 / scaleFactor);  
17.     float ndesiredFeaturesPerScale = nfeatures*(1 - factor)/(1 - (float)pow((double)factor, (double)nlevels));//  
18.   
19.     int sumFeatures = 0;  
20.     for( int level = 0; level < nlevels-1; level++ )   //对每层图像上分配相应角点数  
21.     {  
22.         nfeaturesPerLevel[level] = cvRound(ndesiredFeaturesPerScale);  
23.         sumFeatures += nfeaturesPerLevel[level];  
24.         ndesiredFeaturesPerScale *= factor;  
25.     }  
26.     nfeaturesPerLevel[nlevels-1] = std::max(nfeatures - sumFeatures, 0);//剩下角点数，由最上层图像提取  
27.   
28.     // Make sure we forget about what is too close to the boundary  
29.     //edge_threshold_ = std::max(edge_threshold_, patch_size_/2 + kKernelWidth / 2 + 2);  
30.   
31.     // pre-compute the end of a row in a circular patch  
32.     int halfPatchSize = patchSize / 2;           //计算每个特征点圆邻域的位置信息  
33.     vector<int> umax(halfPatchSize + 2);  
34.     int v, v0, vmax = cvFloor(halfPatchSize * sqrt(2.f) / 2 + 1);  
35.     int vmin = cvCeil(halfPatchSize * sqrt(2.f) / 2);  
36.     for (v = 0; v <= vmax; ++v)           //  
37.         umax[v] = cvRound(sqrt((double)halfPatchSize * halfPatchSize - v * v));  
38.     // Make sure we are symmetric  
39.     for (v = halfPatchSize, v0 = 0; v >= vmin; --v)  
40.     {  
41.         while (umax[v0] == umax[v0 + 1])  
42.             ++v0;  
43.         umax[v] = v0;  
44.            ++v0;  
45.     }  
46.   
47.     allKeypoints.resize(nlevels);  
48.   
49.     for (int level = 0; level < nlevels; ++level)  
50.     {  
51.         int featuresNum = nfeaturesPerLevel[level];  
52.         allKeypoints[level].reserve(featuresNum*2);  
53.   
54.         vector<KeyPoint> & keypoints = allKeypoints[level];  
55.   
56.         // Detect FAST features, 20 is a good threshold  
57.         FastFeatureDetector fd(20, true);        
58.         fd.detect(imagePyramid[level], keypoints, maskPyramid[level]);//Fast角点检测  
59.   
60.         // Remove keypoints very close to the border  
61.         KeyPointsFilter::runByImageBorder(keypoints, imagePyramid[level].size(), edgeThreshold);//去除邻近边界的点  
62.   
63.         if( scoreType == ORB::HARRIS_SCORE )  
64.         {  
65.             // Keep more points than necessary as FAST does not give amazing corners  
66.             KeyPointsFilter::retainBest(keypoints, 2 * featuresNum);//按Fast强度排序,保留前2*featuresNum个特征点  
67.   
68.             // Compute the Harris cornerness (better scoring than FAST)  
69.             HarrisResponses(imagePyramid[level], keypoints, 7, HARRIS_K); //计算每个角点的Harris强度响应  
70.         }  
71.   
72.         //cull to the final desired level, using the new Harris scores or the original FAST scores.  
73.         KeyPointsFilter::retainBest(keypoints, featuresNum);//按Harris强度排序，保留前featuresNum个  
74.   
75.         float sf = getScale(level, firstLevel, scaleFactor);  
76.   
77.         // Set the level of the coordinates  
78.         for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),  
79.              keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)  
80.         {  
81.             keypoint->octave = level;  //层信息  
82.             keypoint->size = patchSize*sf; //  
83.         }  
84.   
85.         computeOrientation(imagePyramid[level], keypoints, halfPatchSize, umax);  //计算角点的方向，（2）分析  
86.     }  
87. }  

（2）为每个角点计算主方向，质心法；

[cpp]  view plain  copy

 

 

1. static void computeOrientation(const Mat& image, vector<KeyPoint>& keypoints,  
2.                                int halfPatchSize, const vector<int>& umax)  
3. {  
4.     // Process each keypoint  
5.     for (vector<KeyPoint>::iterator keypoint = keypoints.begin(),  //为每个角点计算主方向  
6.          keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)  
7.     {  
8.         keypoint->angle = IC_Angle(image, halfPatchSize, keypoint->pt, umax);//计算质心方向  
9.     }  
10. }  

[cpp]  view plain  copy

 

 

1. static float IC_Angle(const Mat& image, const int half_k, Point2f pt,  
2.                       const vector<int> & u_max)  
3. {  
4.     int m_01 = 0, m_10 = 0;  
5.   
6.     const uchar* center = &image.at<uchar> (cvRound(pt.y), cvRound(pt.x));  
7.   
8.     // Treat the center line differently, v=0  
9.     for (int u = -half_k; u <= half_k; ++u)  
10.         m_10 += u * center[u];  
11.   
12.     // Go line by line in the circular patch  
13.     int step = (int)image.step1();  
14.     for (int v = 1; v <= half_k; ++v)    //每次处理对称的两行v  
15.     {  
16.         // Proceed over the two lines  
17.         int v_sum = 0;  
18.         int d = u_max[v];  
19.         for (int u = -d; u <= d; ++u)  
20.         {  
21.             int val_plus = center[u + v*step], val_minus = center[u - v*step];  
22.             v_sum += (val_plus - val_minus); //计算m_01时,位置上差一个符号  
23.             m_10 += u * (val_plus + val_minus);  
24.         }  
25.         m_01 += v * v_sum;//计算上下两行的m_01  
26.     }  
27.   
28.     return fastAtan2((float)m_01, (float)m_10);//计算角度  
29. }  

(3)计算特征点描述子

[cpp]  view plain  copy

 

 

1. static void computeDescriptors(const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors,  
2.                                const vector<Point>& pattern, int dsize, int WTA_K)  
3. {  
4.     //convert to grayscale if more than one color  
5.     CV_Assert(image.type() == CV_8UC1);  
6.     //create the descriptor mat, keypoints.size() rows, BYTES cols  
7.     descriptors = Mat::zeros((int)keypoints.size(), dsize, CV_8UC1);  
8.   
9.     for (size_t i = 0; i < keypoints.size(); i++)  
10.         computeOrbDescriptor(keypoints[i], image, &pattern[0], descriptors.ptr((int)i), dsize, WTA_K);  
11. }  

[cpp]  view plain  copy

 

 

1. static void computeOrbDescriptor(const KeyPoint& kpt,  
2.                                  const Mat& img, const Point* pattern,  
3.                                  uchar* desc, int dsize, int WTA_K)  
4. {  
5.     float angle = kpt.angle;   
6.     //angle = cvFloor(angle/12)*12.f;  
7.     angle *= (float)(CV_PI/180.f);  
8.     float a = (float)cos(angle), b = (float)sin(angle);  
9.   
10.     const uchar* center = &img.at<uchar>(cvRound(kpt.pt.y), cvRound(kpt.pt.x));  
11.     int step = (int)img.step;  
12.   
13. #if 1  
14.     #define GET_VALUE(idx) \       //取旋转后一个像素点的值  
15.         center[cvRound(pattern[idx].x*b + pattern[idx].y*a)*step + \  
16.                cvRound(pattern[idx].x*a - pattern[idx].y*b)]  
17. #else  
18.     float x, y;  
19.     int ix, iy;  
20.     #define GET_VALUE(idx) \ //取旋转后一个像素点，插值法  
21.         (x = pattern[idx].x*a - pattern[idx].y*b, \  
22.         y = pattern[idx].x*b + pattern[idx].y*a, \  
23.         ix = cvFloor(x), iy = cvFloor(y), \  
24.         x -= ix, y -= iy, \  
25.         cvRound(center[iy*step + ix]*(1-x)*(1-y) + center[(iy+1)*step + ix]*(1-x)*y + \  
26.                 center[iy*step + ix+1]*x*(1-y) + center[(iy+1)*step + ix+1]*x*y))  
27. #endif  
28.   
29.     if( WTA_K == 2 )  
30.     {  
31.         for (int i = 0; i < dsize; ++i, pattern += 16)//每个特征描述子长度为32个字节  
32.         {  
33.             int t0, t1, val;  
34.             t0 = GET_VALUE(0); t1 = GET_VALUE(1);  
35.             val = t0 < t1;  
36.             t0 = GET_VALUE(2); t1 = GET_VALUE(3);  
37.             val |= (t0 < t1) << 1;  
38.             t0 = GET_VALUE(4); t1 = GET_VALUE(5);  
39.             val |= (t0 < t1) << 2;  
40.             t0 = GET_VALUE(6); t1 = GET_VALUE(7);  
41.             val |= (t0 < t1) << 3;  
42.             t0 = GET_VALUE(8); t1 = GET_VALUE(9);  
43.             val |= (t0 < t1) << 4;  
44.             t0 = GET_VALUE(10); t1 = GET_VALUE(11);  
45.             val |= (t0 < t1) << 5;  
46.             t0 = GET_VALUE(12); t1 = GET_VALUE(13);  
47.             val |= (t0 < t1) << 6;  
48.             t0 = GET_VALUE(14); t1 = GET_VALUE(15);  
49.             val |= (t0 < t1) << 7;  
50.   
51.             desc[i] = (uchar)val;  
52.         }  
53.     }  
54.     else if( WTA_K == 3 )  
55.     {  
56.         for (int i = 0; i < dsize; ++i, pattern += 12)  
57.         {  
58.             int t0, t1, t2, val;  
59.             t0 = GET_VALUE(0); t1 = GET_VALUE(1); t2 = GET_VALUE(2);  
60.             val = t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0);  
61.   
62.             t0 = GET_VALUE(3); t1 = GET_VALUE(4); t2 = GET_VALUE(5);  
63.             val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 2;  
64.   
65.             t0 = GET_VALUE(6); t1 = GET_VALUE(7); t2 = GET_VALUE(8);  
66.             val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 4;  
67.   
68.             t0 = GET_VALUE(9); t1 = GET_VALUE(10); t2 = GET_VALUE(11);  
69.             val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 6;  
70.   
71.             desc[i] = (uchar)val;  
72.         }  
73.     }  
74.     else if( WTA_K == 4 )  
75.     {  
76.         for (int i = 0; i < dsize; ++i, pattern += 16)  
77.         {  
78.             int t0, t1, t2, t3, u, v, k, val;  
79.             t0 = GET_VALUE(0); t1 = GET_VALUE(1);  
80.             t2 = GET_VALUE(2); t3 = GET_VALUE(3);  
81.             u = 0, v = 2;  
82.             if( t1 > t0 ) t0 = t1, u = 1;  
83.             if( t3 > t2 ) t2 = t3, v = 3;  
84.             k = t0 > t2 ? u : v;  
85.             val = k;  
86.   
87.             t0 = GET_VALUE(4); t1 = GET_VALUE(5);  
88.             t2 = GET_VALUE(6); t3 = GET_VALUE(7);  
89.             u = 0, v = 2;  
90.             if( t1 > t0 ) t0 = t1, u = 1;  
91.             if( t3 > t2 ) t2 = t3, v = 3;  
92.             k = t0 > t2 ? u : v;  
93.             val |= k << 2;  
94.   
95.             t0 = GET_VALUE(8); t1 = GET_VALUE(9);  
96.             t2 = GET_VALUE(10); t3 = GET_VALUE(11);  
97.             u = 0, v = 2;  
98.             if( t1 > t0 ) t0 = t1, u = 1;  
99.             if( t3 > t2 ) t2 = t3, v = 3;  
100.             k = t0 > t2 ? u : v;  
101.             val |= k << 4;  
102.   
103.             t0 = GET_VALUE(12); t1 = GET_VALUE(13);  
104.             t2 = GET_VALUE(14); t3 = GET_VALUE(15);  
105.             u = 0, v = 2;  
106.             if( t1 > t0 ) t0 = t1, u = 1;  
107.             if( t3 > t2 ) t2 = t3, v = 3;  
108.             k = t0 > t2 ? u : v;  
109.             val |= k << 6;  
110.   
111.             desc[i] = (uchar)val;  
112.         }  
113.     }  
114.     else  
115.         CV_Error( CV_StsBadSize, "Wrong WTA_K. It can be only 2, 3 or 4." );  
116.   
117.     #undef GET_VALUE  
118. }  

参考：

Ethan Rublee et. ORB：An Efficient Alternative to SIFT or SURF

http://www.cnblogs.com/ronny/p/4083537.html