RANSAC algorithm Detailed

Original address: http://grunt1223.iteye.com/blog/961063

Another reference: http://www.cnblogs.com/xrwang/archive/2011/03/09/ransac-1.html
Given the coordinates of two points P1 and P2, it is determined that the line formed by these two points requires the P3 of any point in the input to determine whether it is on the line. The middle school analytic geometry knowledge tells us, judge a point in the straight line, only then it and the straight line any two points slope all can. In actual operation, the expression of straight line is calculated according to the known two points (point oblique type, intercept type and so on), then it is convenient to judge whether the P3 is on the line by the vector calculation.

The data in the production practice tends to deviate a certain amount. For example, we know the linear relationship between the two variables x and Y, y=ax+b, we want to determine the specific values of the parameters A and B. By experimenting, you can get a set of test values for x and Y. Although the theory of two unknown equations only need two sets of values can be confirmed, but due to the system error reasons, arbitrary two points calculated by the value of a and B are different. We hope that the final calculation of the theoretical model and test value of the least error. In the higher mathematics course of university, the idea of least squares is expounded in detail. A value that calculates the minimum mean variance of the partial derivative of parameter A, B, and Zero. In fact, in many cases, the least squares are synonymous with linear regression.

Unfortunately, the least squares method is only suitable for cases with small errors. Imagine this situation, if you need to extract a model from a noisy data set (for example, when only 20% of the data conforms to the model), the least squares will be inadequate. For example, a straight line (pattern) can be easily seen by the naked eye, but the algorithm is wrong.



The input to the RANSAC algorithm is a set of observational data (often with large noise or invalid points), a parameterized model for interpreting observational data, and some credible parameters. Ransac the goal by repeatedly selecting a set of random subsets in the data. The selected subset is assumed to be an insider, and is validated using the following method:

• There is a model adapted to the hypothetical insider point, where all unknown parameters can be calculated from the hypothetical insider.
• Use the model obtained in 1 to test all other data, and if a point applies to the estimated model, it is considered an insider point.
• If there are enough points to be classified as hypothetical insider points, then the estimated model is reasonable enough.
• Then, the model is re-estimated using all the hypothetical insider points (for example, using the least squares method), because it is only estimated by the initial assumption-points.
• Finally, the model is evaluated by estimating the error rate of the insider and the model.
• The process is repeated for a fixed number of times, and each resulting model is either discarded because it is too small, or is chosen because it is better than the existing model.

The whole process can be referred to:



About the source code of the algorithm, Ziv Yaniv once wrote a good C + + version, I added the comment in the key:
C code

2. #include <math.h>
4. #include "LineParamEstimator.h"
8. Lineparamestimator::lineparamestimator (Double delta): m_deltasquared (Delta*delta) {}
14. void Lineparamestimator::estimate (std::vector<point2d *> &data,
16. Std::vector<double> &parameters)
18. {
20. Parameters.clear ();
22. if (Data.size () <2)
24. Return
26. Double NX = data[1]->y-data[0]->y;
28. Double NY = data[0]->x-data[1]->x;//the slope of the original line is k, the slope of the normal is -1/k
30. Double norm = sqrt (nx*nx + ny*ny);
34. Parameters.push_back (Nx/norm);
36. Parameters.push_back (Ny/norm);
38. Parameters.push_back (DATA[0]->X);
40. Parameters.push_back (Data[0]->y);
42. }
48. void Lineparamestimator::leastsquaresestimate (std::vector<point2d *> &data,
50. Std::vector<double> &parameters)
52. {
54. Double Meanx, Meany, NX, NY, Norm;
56. Double covMat11, covMat12, covMat21, covMat22; The entries of the symmetric covarinace matrix
58. int I, datasize = Data.size ();
62. Parameters.clear ();
64. if (Data.size () <2)
66. Return
70. Meanx = Meany = 0.0;
72. covMat11 = covMat12 = covMat21 = covMat22 = 0;
74. for (i=0; i<datasize; i++) {
76. Meanx +=data[i]->x;
78. Meany +=data[i]->y;
82. CovMat11 +=data[i]->x * data[i]->x;
84. covMat12 +=data[i]->x * data[i]->y;
86. covMat22 +=data[i]->y * data[i]->y;
88. }
92. Meanx/=datasize;
94. Meany/=datasize;
98. CovMat11-= Datasize*meanx*meanx;
100. covMat12-= Datasize*meanx*meany;
102. covMat22-= Datasize*meany*meany;
104. covMat21 = covMat12;
108. if (covmat11<1e-12) {
110. NX = 1.0;
112. NY = 0.0;
114. }
116. else {//LAMDA1 is the largest eigen-value of the covariance matrix
118. and is used to compute the eigne-vector corresponding to the smallest
120. Eigenvalue, which isn ' t computed explicitly.
122. Double lamda1 = (covMat11 + covMat22 + sqrt ((covmat11-covmat22) * (covmat11-covmat22) + 4*covmat12*covmat12)/2.0;
124. NX =-covmat12;
126. NY = lamda1-covmat22;
128. Norm = sqrt (nx*nx + ny*ny);
130. Nx/=norm;
132. Ny/=norm;
134. }
136. Parameters.push_back (NX);
138. Parameters.push_back (NY);
140. Parameters.push_back (Meanx);
142. Parameters.push_back (Meany);
144. }
150. BOOL Lineparamestimator::agree (std::vector<double> &parameters, point2d &data)
152. {
154. Double signeddistance = parameters[0]* (data.x-parameters[2]) + parameters[1]* (data.y-parameters[3]);
156. Return ((Signeddistance*signeddistance) < m_deltasquared);
158. }

Ransac looks for the matching code as follows:
C code

4. Template<class T, Class s>
6. Double Ransac<t,s>::compute (std::vector<s> &parameters,
8. Parameteresitmator<t,s> *paramestimator,
10. Std::vector<t> &data,
12. int numforestimate)
14. {
16. Std::vector<t *> Leastsquaresestimatedata;
18. int numdataobjects = Data.size ();
20. int numvotesforbest =-1;
22. int *arr = new int[numforestimate];//numforestimate represents the minimum number of points required to fit the model, which is 2 for the straight line of this example
24. Short *curvotes = new Short[numdataobjects]; One if Data[i] agrees with the current model, otherwise zero
26. Short *bestvotes = new Short[numdataobjects]; One if Data[i] agrees with the best model, otherwise zero
32. There is less data objects than the minimum required for an exact fit
34. if (Numdataobjects < numforestimate)
36. return 0;
38. Calculate all possible lines and find the solution with the least error. For the 100-point linear fitting, the complexity is undoubtedly large, with approximately 100*99*0.5=4950 operations. The method of randomly selecting a subset is generally used.
40. Computeallchoices (Paramestimator,data,numforestimate,
42. Bestvotes, Curvotes, numvotesforbest, 0, Data.size (), numforestimate, 0, arr);
46. Compute the least squares estimate using the largest sub set
48. for (int j=0; j<numdataobjects; J + +) {
50. if (Bestvotes[j])
52. Leastsquaresestimatedata.push_back (& (Data[j));
54. }
56. To fit the model again with the least squares method to the insider point
58. Paramestimator->leastsquaresestimate (leastsquaresestimatedata,parameters);
62. delete [] arr;
64. delete [] bestvotes;
66. delete [] curvotes;
70. Return (double) leastsquaresestimatedata.size ()/(double) numdataobjects;
72. }

Ransac can always find the optimal solution in the case of model determination and the maximum number of iterations allowed. In my experiment, the effect of RANSAC is far superior to the direct least squares method for datasets containing 80% errors.

What scenarios can RANSAC be used for? The most famous is the picture splicing technology. Better than the lens limit, it often takes more than one photo to shoot that huge landscape. When multiple images are synthesized, some key feature points are extracted in advance in the image to be synthesized. The study of computer vision shows that objects can be obtained by the transformation of a perspective moment (3x3 or 2x2) matrix in different visual angles. RANSAC is used to fit the parameters of the model (the values of each column of the matrix), thus identifying the same object in different photographs. Refer to:







In addition, RANSAC can also be used for error correction and object recognition in image search. , there are several straight lines are the sift of the matching algorithm, Ransac effectively identify them, and the correct model (book) with the wireframe marked out:

RANSAC algorithm Detailed