Public Member Functions | Protected Member Functions
alvar::IndexRansac< MODEL > Class Template Reference

Implementation of a general RANdom SAmple Consensus algorithm with implicit parameters. More...

#include <Ransac.h>

Inheritance diagram for alvar::IndexRansac< MODEL >:
Inheritance graph
[legend]

List of all members.

Public Member Functions

int estimate (int param_c, int support_limit, int max_rounds, MODEL *model)
 Estimates a model from input data parameters.
 IndexRansac (int min_params, int max_params)
 Initialize the algorithm.
int refine (int param_c, int support_limit, int max_rounds, MODEL *model, char *inlier_mask=NULL)
 Iteratively makes the estimated model better.
virtual ~IndexRansac ()

Protected Member Functions

void _doEstimate (int *params, int param_c, void *model)
bool _doSupports (int param, void *model)
virtual void doEstimate (int *params, int param_c, MODEL *model)=0
 Creates a model estimate from a set of parameters.
virtual bool doSupports (int param, MODEL *model)=0
 Computes how well a parameters supports a model.

Detailed Description

template<typename MODEL>
class alvar::IndexRansac< MODEL >

Implementation of a general RANdom SAmple Consensus algorithm with implicit parameters.

These parameters are accessed by indises. The benefit of this is that we avoid copying input data from an array into another. See Ransac class for more details.

Extending class must provide two methods:

   void doEstimate(int* params, int param_c, MODEL* model);
   bool doSupports(int param, MODEL* model);

Example fitting points to a line (compare this with the example in the Ransac class):

 typedef struct Point { double x, double y; };
 typedef struct Line { Point p1, p2; };

 class MyLineFittingRansac : public IndexRansac<Line, Point> {
   Point *points;

   // Line fitting needs at least 2 parameters and here we want
   // to support at most 16 parameters.
   MyLineFittingRansac(Points *input) : Ransac(2, 16), points(input) {}

   void doEstimate(int *indises, int points_c, Line *line) {
     if (points_c == 2) { return Line(points[indises[0]], *points[indises[1]]); }
     else { // compute best line fitting up to 16 points. }
   }

   bool doSupports(int index, Line *line) {
     Point *point = &points[index];
     double distance = // compute point distance to line.
     return distance < POINT_DISTANCE_LIMIT;
   }
 };

 Point input[N_POINTS] = { .. };
 Line line;
 MyLineFittingRansac ransac(input);

 // assuming 60% of inliers, run RANSAC until the best model is found with 99% propability.
 int max_rounds = ransac.estimateRequiredRounds(0.99, 0.6);
 int number_of_inliers = ransac.estimate(input, N_POINTS, N_POINTS, max_rounds, &line);

 // lets make the estimate even better.
 if (number_of_inliers > 0 && number_of_inliers < N_POINTS)
   number_of_inliers = ransac.refine(input, N_POINTS, N_POINTS, 10, &line);

 // you should keep track of the real percentage of inliers to determine
 // the  required number of RANSAC rounds.
 double inlier_percentage = (double)number_of_inliers / (double)N_POINTS;

Definition at line 343 of file Ransac.h.


Constructor & Destructor Documentation

template<typename MODEL >
alvar::IndexRansac< MODEL >::IndexRansac ( int  min_params,
int  max_params 
) [inline]

Initialize the algorithm.

Uses at least min_params and at most max_params number of input data elements for model estimation.

Must be: max_params >= min_params

Parameters:
min_paramsis the minimum number of parameters needed to create a model.
max_paramsis the maximum number of parameters to using in refining the model.

Definition at line 397 of file Ransac.h.

template<typename MODEL >
virtual alvar::IndexRansac< MODEL >::~IndexRansac ( ) [inline, virtual]

Definition at line 400 of file Ransac.h.


Member Function Documentation

template<typename MODEL >
void alvar::IndexRansac< MODEL >::_doEstimate ( int *  params,
int  param_c,
void *  model 
) [inline, protected, virtual]

Wrapper for templated parameters.

Reimplemented from alvar::RansacImpl.

Definition at line 373 of file Ransac.h.

template<typename MODEL >
bool alvar::IndexRansac< MODEL >::_doSupports ( int  param,
void *  model 
) [inline, protected, virtual]

Wrapper for templated parameters.

Reimplemented from alvar::RansacImpl.

Definition at line 380 of file Ransac.h.

template<typename MODEL >
virtual void alvar::IndexRansac< MODEL >::doEstimate ( int *  params,
int  param_c,
MODEL *  model 
) [protected, pure virtual]

Creates a model estimate from a set of parameters.

The user must implement this method to compute model parameters from the input data.

Parameters:
paramsAn array of indises of sampled parameters.
param_cThe number of parameter indises in the params array.
modelPointer to the model where to store the estimate.
template<typename MODEL >
virtual bool alvar::IndexRansac< MODEL >::doSupports ( int  param,
MODEL *  model 
) [protected, pure virtual]

Computes how well a parameters supports a model.

This method is used by the RANSAC algorithm to count how many parameters support the estimated model (inliers). Althought this is case specific, usually parameter supports the model when the distance from model prediction is not too far away from the parameter.

Parameters:
paramIndex of the parameter to check.
modelPointer to the model to check the parameter against.
Returns:
True when the parameter supports the model.
template<typename MODEL >
int alvar::IndexRansac< MODEL >::estimate ( int  param_c,
int  support_limit,
int  max_rounds,
MODEL *  model 
) [inline]

Estimates a model from input data parameters.

Randomly samples min_params number of input data elements from params array and chooses the model that has the largest set of supporting parameters (inliers) in the params array.

Note that this method always uses min_params number of parameters, that is, doEstimate method can be implemented to support only the minimum number of parameters unless refine method is used.

Parameters:
param_cNumber of parameters available in estimation.
support_limitThe search is stopped if a model receives more support that this limit.
max_roundsHow many different samples are tried before stopping the search.
modelThe estimated model is stored here.
Returns:
the number of parameters supporting the model, or 0 if a suitable model could not be build at all.

Definition at line 421 of file Ransac.h.

template<typename MODEL >
int alvar::IndexRansac< MODEL >::refine ( int  param_c,
int  support_limit,
int  max_rounds,
MODEL *  model,
char *  inlier_mask = NULL 
) [inline]

Iteratively makes the estimated model better.

Starting with the estimated model, computes the model from all inlier parameters and interates until no new parameters support the model.

Note that this method uses up to max_params number of parameters, that is, doEstimate method must be implemented in such a way that it can estimate a model from a variable number of parameters.

Parameters:
param_cNumber of parameters available for estimation.
support_limitThe search is stopped if a model receives more support that this limit.
max_roundsHow many iterations of the refinement are run.
modelThe estimated model that is refined.
inlier_maskByte array where 1 is stored for inliers and 0 for outliers.
Returns:
the number of parameters supporting the model.

Definition at line 445 of file Ransac.h.


The documentation for this class was generated from the following file:


ar_track_alvar
Author(s): Scott Niekum
autogenerated on Thu Jun 6 2019 21:12:55