/// 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;
}
/// Refine the model on all the inliers with the "a contrario" model
/// The model is refined while the NFA threshold is not stable.
void OrsaModel::refineUntilConvergence(const std::vector<float> & vec_logc_n,
const std::vector<float> & vec_logc_k,
double loge0,
double maxThreshold,
double minNFA,
Model *model,
bool bVerbose,
std::vector<int> & vec_inliers,
double & errorMax,
int & side) const
{
std::cout << "\n\n OrsaModel::refineUntilConvergence(...)\n" << std::endl;
const int nData = x1_.ncol();
std::vector<ErrorIndex> vec_residuals(nData); // [residual,index]
bool bContinue = true;
int iter = 0;
do{
std::vector<Model> vec_models; // Up to max_models solutions
Fit(vec_inliers, &vec_models);
// Evaluate models
for (size_t k = 0; k < vec_models.size(); ++k)
{
// Residuals computation and ordering
for (int i = 0; i < nData; ++i)
{
double error = Error(vec_models[k], i);
vec_residuals[i] = ErrorIndex(error, i);
}
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 < 0 && best.error < minNFA) // A better model was found
{
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(model) *model = vec_models[k];
if(bVerbose)
{
std::cout << " nfa=" << minNFA
<< " inliers=" << vec_inliers.size()
<< " precision=" << denormalizeError(errorMax, side)
<< " (iter=" << iter << ")\n";
}
}
else
bContinue = false;
}
if (vec_models.empty())
{
bContinue = false;
}
++iter;
}
while( bContinue );
}
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);
}
