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

#include <Ransac.h>

Inheritance diagram for alvar::IndexRansac< MODEL >:

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_params	is the minimum number of parameters needed to create a model.
max_params	is 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:

params	An array of indises of sampled parameters.
param_c	The number of parameter indises in the params array.
model	Pointer 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:

param	Index of the parameter to check.
model	Pointer 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_c	Number of parameters available in estimation.
support_limit	The search is stopped if a model receives more support that this limit.
max_rounds	How many different samples are tried before stopping the search.
model	The 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_c	Number of parameters available for estimation.
support_limit	The search is stopped if a model receives more support that this limit.
max_rounds	How many iterations of the refinement are run.
model	The estimated model that is refined.
inlier_mask	Byte 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:

Ransac.h

Public Member Functions

Protected Member Functions

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

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