Public Member Functions | Protected Member Functions | List of all members
alvar::IndexRansac< MODEL > Class Template Referenceabstract

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

#include <Ransac.h>

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

Public Member Functions

int estimate (int param_c, int support_limit, int max_rounds, MODEL *model)
 Estimates a model from input data parameters. More...
 
 IndexRansac (int min_params, int max_params)
 Initialize the algorithm. More...
 
int refine (int param_c, int support_limit, int max_rounds, MODEL *model, char *inlier_mask=NULL)
 Iteratively makes the estimated model better. More...
 
virtual ~IndexRansac ()
 
- Public Member Functions inherited from alvar::RansacImpl
int estimateRequiredRounds (float success_propability, float inlier_percentage)
 How many rounds are needed for the Ransac to work. More...
 

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. More...
 
virtual bool doSupports (int param, MODEL *model)=0
 Computes how well a parameters supports a model. More...
 
- Protected Member Functions inherited from alvar::RansacImpl
virtual void _doEstimate (void **params, int param_c, void *model)
 
virtual bool _doSupports (void *param, void *model)
 
int _estimate (void *params, int param_c, int support_limit, int max_rounds, void *model)
 
int _estimate (int param_c, int support_limit, int max_rounds, void *model)
 
int _refine (void *params, int param_c, int support_limit, int max_rounds, void *model, char *inlier_mask=NULL)
 
int _refine (int param_c, int support_limit, int max_rounds, void *model, char *inlier_mask=NULL)
 
 RansacImpl (int min_params, int max_params, int sizeof_param, int sizeof_model)
 
 RansacImpl (int min_params, int max_params, int sizeof_model)
 
virtual ~RansacImpl ()
 

Additional Inherited Members

- Protected Attributes inherited from alvar::RansacImpl
void * hypothesis
 
int * indices
 
int max_params
 
int min_params
 
void ** samples
 
int sizeof_model
 
int sizeof_param
 

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 ( )
inlinevirtual

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 
)
inlineprotectedvirtual

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 
)
inlineprotectedvirtual

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 
)
protectedpure 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 
)
protectedpure 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 Mon Jun 10 2019 12:47:04