double LeastMedianOfSquares(const Kernel &kernel, typename Kernel::Model * model = NULL, double* outlierThreshold = NULL, double outlierRatio=0.5, double minProba=0.99) { const size_t min_samples = Kernel::MINIMUM_SAMPLES; const size_t total_samples = kernel.NumSamples(); std::vector<double> residuals(total_samples); // Array for storing residuals std::vector<size_t> vec_sample(min_samples); double dBestMedian = std::numeric_limits<double>::max(); // Required number of iterations is evaluated from outliers ratio const size_t N = (min_samples<total_samples)? getNumSamples(minProba, outlierRatio, min_samples): 0; for (size_t i=0; i < N; i++) { // Get Samples indexes UniformSample(min_samples, total_samples, &vec_sample); // Estimate parameters: the solutions are stored in a vector std::vector<typename Kernel::Model> models; kernel.Fit(vec_sample, &models); // Now test the solutions on the whole data for (size_t k = 0; k < models.size(); ++k) { //Compute Residuals : for (size_t l = 0; l < total_samples; ++l) { double error = kernel.Error(l, models[k]); residuals[l] = error; } // Compute median std::vector<double>::iterator itMedian = residuals.begin() + std::size_t( total_samples*(1.-outlierRatio) ); std::nth_element(residuals.begin(), itMedian, residuals.end()); double median = *itMedian; // Store best solution if(median < dBestMedian) { dBestMedian = median; if (model) (*model) = models[k]; } } } // This array of precomputed values corresponds to the inverse // cumulative function for a normal distribution. For more information // consult the litterature (Robust Regression for Outlier Detection, // rouseeuw-leroy). The values are computed for each 5% static const double ICDF[21] = { 1.4e16, 15.94723940, 7.957896558, 5.287692054, 3.947153876, 3.138344200, 2.595242369, 2.203797543, 1.906939402, 1.672911853, 1.482602218, 1.323775627, 1.188182950, 1.069988721, 0.9648473415, 0.8693011162, 0.7803041458, 0.6946704675, 0.6079568319,0.5102134568, 0.3236002672 }; // Evaluate the outlier threshold if(outlierThreshold) { double sigma = ICDF[int((1.-outlierRatio)*20.)] * (1. + 5. / double(total_samples - min_samples)); *outlierThreshold = (double)(sigma * sigma * dBestMedian * 4.); if (N==0) *outlierThreshold = std::numeric_limits<double>::max(); } return dBestMedian; }
/// Generic implementation of 'ORSA': /// A Probabilistic Criterion to Detect Rigid Point Matches /// Between Two Images and Estimate the Fundamental Matrix. /// Bibtex : /// @article{DBLP:journals/ijcv/MoisanS04, /// author = {Lionel Moisan and B{\'e}renger Stival}, /// title = {A Probabilistic Criterion to Detect Rigid Point Matches /// Between Two Images and Estimate the Fundamental Matrix}, /// journal = {International Journal of Computer Vision}, /// volume = {57}, /// number = {3}, /// year = {2004}, /// pages = {201-218}, /// ee = {http://dx.doi.org/10.1023/B:VISI.0000013094.38752.54}, /// bibsource = {DBLP, http://dblp.uni-trier.de} ///} /// /// ORSA is based on an a contrario criterion of /// inlier/outlier discrimination, is parameter free and relies on an optimized /// random sampling procedure. It returns the log of NFA and optionally /// the best estimated model. /// /// \param vec_inliers Output vector of inlier indices. /// \param nIter The number of iterations. /// \param precision (input/output) threshold for inlier discrimination. /// \param model The best computed model. /// \param bVerbose Display optimization statistics. double OrsaModel::orsa(std::vector<int> & vec_inliers, size_t nIter, double *precision, Model *model, bool bVerbose) const { vec_inliers.clear(); const int sizeSample = SizeSample(); const int nData = x1_.ncol(); if(nData <= sizeSample) return std::numeric_limits<double>::infinity(); const double maxThreshold = (precision && *precision>0)? *precision * *precision *N2_(0,0)*N2_(0,0): // Square max error std::numeric_limits<double>::infinity(); std::vector<ErrorIndex> vec_residuals(nData); // [residual,index] std::vector<int> vec_sample(sizeSample); // Sample indices // Possible sampling indices (could change in the optimization phase) std::vector<int> vec_index(nData); for (int i = 0; i < nData; ++i) vec_index[i] = i; // Precompute log combi double loge0 = log10((double)NbModels() * (nData-sizeSample)); std::vector<float> vec_logc_n, vec_logc_k; makelogcombi_n(nData, vec_logc_n); makelogcombi_k(sizeSample,nData, vec_logc_k); // Reserve 10% of iterations for focused sampling size_t nIterReserve=nIter/10; nIter -= nIterReserve; // Output parameters double minNFA = std::numeric_limits<double>::infinity(); double errorMax = 0; int side=0; // Main estimation loop. for (size_t iter=0; iter < nIter; iter++) { UniformSample(sizeSample, vec_index, &vec_sample); // Get random sample std::vector<Model> vec_models; // Up to max_models solutions Fit(vec_sample, &vec_models); // Evaluate models bool better=false; for (size_t k = 0; k < vec_models.size(); ++k) { // Residuals computation and ordering for (int i = 0; i < nData; ++i) { int s; double error = Error(vec_models[k], i, &s); vec_residuals[i] = ErrorIndex(error, i, s); } std::sort(vec_residuals.begin(), vec_residuals.end()); // Most meaningful discrimination inliers/outliers ErrorIndex best = bestNFA(vec_residuals, loge0, maxThreshold, vec_logc_n, vec_logc_k); if(best.error < minNFA) // A better model was found { better = true; minNFA = best.error; side = best.side; vec_inliers.resize(best.index); for (int i=0; i<best.index; ++i) vec_inliers[i] = vec_residuals[i].index; errorMax = vec_residuals[best.index-1].error; // Error threshold if(best.error<0 && model) *model = vec_models[k]; if(bVerbose) { std::cout << " nfa=" << minNFA << " inliers=" << vec_inliers.size() << " precision=" << denormalizeError(errorMax, side) << " im" << side+1 << " (iter=" << iter; if(best.error<0) { std::cout << ",sample=" << vec_sample.front(); std::vector<int>::const_iterator it=vec_sample.begin(); for(++it; it != vec_sample.end(); ++it) std::cout << ',' << *it; } std::cout << ")" <<std::endl; } } } // ORSA optimization: draw samples among best set of inliers so far if((better && minNFA<0) || (iter+1==nIter && nIterReserve)) { if(vec_inliers.empty()) { // No model found at all so far nIter++; // Continue to look for any model, even not meaningful nIterReserve--; } else { vec_index = vec_inliers; if(nIterReserve) { nIter = iter+1+nIterReserve; nIterReserve=0; } } } } if(minNFA >= 0) vec_inliers.clear(); if(bConvergence) refineUntilConvergence(vec_logc_n, vec_logc_k, loge0, maxThreshold, minNFA, model, bVerbose, vec_inliers, errorMax, side); if(precision) *precision = denormalizeError(errorMax, side); if(model && !vec_inliers.empty()) Unnormalize(model); return minNFA; }
std::pair<double, double> ACRANSAC(const Kernel &kernel, std::vector<size_t> & vec_inliers, size_t nIter = 1024, typename Kernel::Model * model = NULL, double precision = std::numeric_limits<double>::infinity(), bool bVerbose = false) { vec_inliers.clear(); const size_t sizeSample = Kernel::MINIMUM_SAMPLES; const size_t nData = kernel.NumSamples(); if(nData <= (size_t)sizeSample) return std::make_pair(0.0,0.0); const double maxThreshold = (precision==std::numeric_limits<double>::infinity()) ? std::numeric_limits<double>::infinity() : precision * kernel.normalizer2()(0,0) * kernel.normalizer2()(0,0); std::vector<ErrorIndex> vec_residuals(nData); // [residual,index] std::vector<double> vec_residuals_(nData); std::vector<size_t> vec_sample(sizeSample); // Sample indices // Possible sampling indices (could change in the optimization phase) std::vector<size_t> vec_index(nData); for (size_t i = 0; i < nData; ++i) vec_index[i] = i; // Precompute log combi double loge0 = log10((double)Kernel::MAX_MODELS * (nData-sizeSample)); std::vector<float> vec_logc_n, vec_logc_k; makelogcombi_n(nData, vec_logc_n); makelogcombi_k(sizeSample, nData, vec_logc_k); // Output parameters double minNFA = std::numeric_limits<double>::infinity(); double errorMax = std::numeric_limits<double>::infinity(); // Reserve 10% of iterations for focused sampling size_t nIterReserve = nIter/10; nIter -= nIterReserve; // Main estimation loop. for (size_t iter=0; iter < nIter; ++iter) { UniformSample(sizeSample, vec_index, &vec_sample); // Get random sample std::vector<typename Kernel::Model> vec_models; // Up to max_models solutions kernel.Fit(vec_sample, &vec_models); // Evaluate models bool better = false; for (size_t k = 0; k < vec_models.size(); ++k) { // Residuals computation and ordering kernel.Errors(vec_models[k], vec_residuals_); for (size_t i = 0; i < nData; ++i) { const double error = vec_residuals_[i]; vec_residuals[i] = ErrorIndex(error, i); } std::sort(vec_residuals.begin(), vec_residuals.end()); // Most meaningful discrimination inliers/outliers const ErrorIndex best = bestNFA( sizeSample, kernel.logalpha0(), vec_residuals, loge0, maxThreshold, vec_logc_n, vec_logc_k, kernel.multError()); if (best.first < minNFA /*&& vec_residuals[best.second-1].first < errorMax*/) { // A better model was found better = true; minNFA = best.first; vec_inliers.resize(best.second); for (size_t i=0; i<best.second; ++i) vec_inliers[i] = vec_residuals[i].second; errorMax = vec_residuals[best.second-1].first; // Error threshold if(model) *model = vec_models[k]; if(bVerbose) { std::cout << " nfa=" << minNFA << " inliers=" << best.second << " precisionNormalized=" << errorMax << " precision=" << kernel.unormalizeError(errorMax) << " (iter=" << iter; std::cout << ",sample="; std::copy(vec_sample.begin(), vec_sample.end(), std::ostream_iterator<size_t>(std::cout, ",")); std::cout << ")" <<std::endl; } } } // ACRANSAC optimization: draw samples among best set of inliers so far if((better && minNFA<0) || (iter+1==nIter && nIterReserve)) { if(vec_inliers.empty()) { // No model found at all so far nIter++; // Continue to look for any model, even not meaningful nIterReserve--; } else { // ACRANSAC optimization: draw samples among best set of inliers so far vec_index = vec_inliers; if(nIterReserve) { nIter = iter+1+nIterReserve; nIterReserve=0; } } } } if(minNFA >= 0) vec_inliers.clear(); if (!vec_inliers.empty()) { if (model) kernel.Unnormalize(model); errorMax = kernel.unormalizeError(errorMax); } return std::make_pair(errorMax, minNFA); }