Struct arrsac::Arrsac

pub struct Arrsac<R> { /* fields omitted */ }

The ARRSAC algorithm for sample consensus.

Implementations

impl<R> Arrsac<R> where
    R: RngCore, 

pub fn new(inlier_threshold: f32, rng: R) -> Self

rng should have the same properties you would want for a Monte Carlo simulation. It should generate random numbers quickly without having any discernable patterns.

The inlier_threshold is the one parameter that is always specific to your dataset. This must be set to the threshold in which a data point's residual is considered an inlier. Some of the other parameters may need to be configured based on the amount of data, such as block_size, likelyhood_ratio_threshold, and block_size. However, inlier_threshold has to be set based on the residual function used with the model.

pub fn max_candidate_hypotheses(self, max_candidate_hypotheses: usize) -> Self

Number of hypotheses that will be generated for each block of data evaluated

Default: 50

pub fn block_size(self, block_size: usize) -> Self

Number of data points evaluated before more hypotheses are generated

Default: 100

pub fn max_delta_estimations(self, max_delta_estimations: usize) -> Self

Number of times that the entire dataset is compared against a bad model to see the probability of inliers in a bad model

Default: 4

pub fn likelyhood_ratio_threshold(self, likelyhood_ratio_threshold: f32) -> Self

Once a model reaches this level of unlikelyhood, it is rejected. Set this higher to make it less restrictive, usually at the cost of more execution time.

Increasing this will make it more likely to find a good result (unless it is set very high).

Decreasing this will speed up execution.

This ratio is not exposed as a parameter in the original paper, but is instead computed recursively for a few iterations. It is roughly equivalent to the reciprocal of the probability of rejecting a good model. You can use that to control the probability that a good model is rejected.

Default: 1e6

pub fn initial_epsilon(self, initial_epsilon: f32) -> Self

Initial anticipated probability of an inlier being part of a good model

This is an estimation that will be updated as ARRSAC executes. The initial estimate is purposefully low, which will accept more models. As models are accepted, it will gradually increase it to match the best model found so far, which makes it more restrictive.

Default: 0.1

pub fn initial_delta(self, initial_delta: f32) -> Self

Initial anticipated probability of an inlier being part of a bad model

This is an estimation that will be updated as ARRSAC executes. The initial estimate is almost certainly incorrect. This can be modified for different data to get better/faster results. As models are rejected, it will update this value until it has evaluated it max_delta_estimations times.

Default: 0.05

pub fn inlier_threshold(self, inlier_threshold: f32) -> Self

Residual threshold for determining if a data point is an inlier or an outlier of a model

Trait Implementations

impl<E, R, Data> Consensus<E, Data> for Arrsac<R> where
    E: Estimator<Data>,
    R: RngCore, 

type Inliers = Vec<usize>

Iterator over the indices of the inliers in the clonable iterator.

fn model<I>(&mut self, estimator: &E, data: I) -> Option<E::Model> where
    I: Iterator<Item = Data> + Clone, 

Takes a slice over the data and an estimator instance. It returns None if no valid model could be found for the data and Some if a model was found.

fn model_inliers<I>(
    &mut self,
    estimator: &E,
    data: I
) -> Option<(E::Model, Self::Inliers)> where
    I: Iterator<Item = Data> + Clone, 

Takes a slice over the data and an estimator instance. It returns None if no valid model could be found for the data and Some if a model was found. It includes the inliers consistent with the model.