At the root of computer vision is a heavy amount of math and probability. Theia contains various math functions implemented with a generic interface for ease of use.
Closed Form Polynomial Solver¶
Many problems in vision rely on solving a polynomial quickly. For small degrees (n <= 4) this can be done in closed form, making them exceptionally fast. We have implemented solvers for these cases.
SolveQuadraticReals(double a, double b, double c, double *roots)¶
SolveQuadratic(double a, double b, double c, std::complex<double> *roots)¶
Provides solutions to the equation \(a*x^2 + b*x + c = 0\)
The closed form solutions for cubic and quartic solvers are known to be numerically unstable. We recommend using the generic polynomial solvers (below) instead. This will sacrifice efficiency a small amount for a significant improvement in solution quality.
SolveCubicReals(double a, double b, double c, double d, double *roots)¶
SolveCubic(double a, double b, double c, double d, std::complex<double> *roots)¶
Provides solutions to the equation \(a*x^3 + b*x^2 + c*x + d = 0\) using Cardano’s method.
SolveQuarticReals(double a, double b, double c, double d, double e, double *roots)¶
Generic Polynomial Solver¶
For polynomials of degree > 4 there are no closed-form solutions, making the problem of finding roots much more difficult. However, we have implemented several functions that will solve for polynomial roots. For all polynomials we require that the largest degree appears first and the smallest degree appears last in the input VectorXd such that:
Where \(p(i)\) is the input VectorXd.
FindPolynomialRoots(const Eigen::VectorXd &polynomial, Eigen::VectorXd *real, Eigen::VectorXd *imaginary)¶
This function finds the roots of the input polynomial using one of the methods below. All methods in Theia that require finding polynomial roots use this method. This is so that we can easily change the default root-finding method of choice (i.e. Companion Matrix to Jenkins-Traub, etc.) by modifying this function once instead of modify every instance where we want to find polynomial roots. This allows us to easily swap in new polynomial root-solvers (that may be more efficient or numerically stable) as they are implemented.
FindPolynomialRootsJenkinsTraub(const Eigen::VectorXd &polynomial, Eigen::VectorXd *real, Eigen::VectorXd *imaginary)¶
The Jenkins Traub algorithm is a three-stage algorithm for finding roots of polynomials with real coefficients as outlined in [JenkinsTraub]. Please note that this variant is different than the complex-coefficient version, and is estimated to be up to 4 times faster.
The algorithm works by computing shifts in so-called “K-polynomials” that deflate the polynomial to reveal the roots. Once a root is found (or in the real-polynomial case, a pair of roots) then it is divided from the polynomial and the process is repeated. This method is consider to be “pratically a standard in black-box polynomial root finder” (Numerical Recipes 2007) and is based on the Rpoly++ implementation.
FindPolynomialRootsCompanionMatrix(const Eigen::VectorXd &polynomial, Eigen::VectorXd *real, Eigen::VectorXd *imaginary)¶
Roots are computed using the Companion Matrix with balancing to help improve the condition of the matrix system we solve. This is a reliable, stable method for computing roots but is most often the slowest method.
FindRootIterativeLaguere(const Eigen::VectorXd &polynomial, const double x0, const double epsilon, const int max_iter)¶
Finds a single polynomials root iteratively based on the starting position \(x_0\) and guaranteed precision of epsilon using Laguerre’s Method.
Theia implements many useful linear algebra methods including optimizations, factorizations, and utility methods.
We implement a robust \(L_1\) solver that minimizes \(||Ax - b||_1\) under \(L_1\) norm. This problem may be cast as a simple and efficient linear program and solved with interior point methods. The interface is fairly generic and may be used with sparse or dense matrices. An initial guess is needed for \(x\) to perform the minimization.
The maximum number of iterations to perform before stopping.
Eigen::MatrixXd A; Eigen::VectorXd b, x; // Fill A and b with known values. L1Solver::Options option; L1Solver<Eigen::MatrixXd> l1_solver(options, A); l1_solver.Solve(b, &x); // x now contains the solution that minimizes ||Ax - b|| under L1 norm.
This class finds the dominant eigenvalue/eigenvector pair of a given matrix using power iterations. We use a generic interface that utilizes the
LinearOperatorclass so that the user may determine who the dominant eigenvalues are computed. For instance, by passing the
DominantEigensolverperforms inverse power iterations and thus the smallest eigenvalue/eigenvector pair may be computed. This is useful for recovering a null space vector.
GaussJordan(Eigen::MatrixBase<Derived> *input, int max_rows = 99999)¶
Perform traditional Gauss-Jordan elimination on an Eigen3 matrix. If
max_rowsis specified, it will on perform Gauss-Jordan on the first
max_rowsnumber of rows. This is useful for problems where your system is extremely overdetermined and you do not need all rows to be solved.
Sequential Probability Ratio Test¶
CalculateSPRTDecisionThreshold(double sigma, double epsilon, double time_compute_model_ratio = 200.0, int num_models_verified = 1)¶
sigma: Probability of rejecting a good model (Bernoulli parameter).
epsilon: Inlier ratio.
time_compute_model_ratio: Computing the model parameters from a sample takes the same time as verification of time_compute_model_ratio data points. Matas et. al. use 200.
num_model_verified: Number of models that are verified per sample.
Returns: The SPRT decision threshold based on the input parameters.
SequentialProbabilityRatioTest(const std::vector<double> &residuals, double error_thresh, double sigma, double epsilon, double decision_threshold, int *num_tested_points, double *observed_inlier_ratio)¶
Modified version of Wald’s SPRT as [Matas] et. al. implement it in “Randomized RANSAC with Sequential Probability Ratio Test”. See the paper for more details.
residuals: Error residuals to use for SPRT analysis.
error_thresh: Error threshold for determining when Datum fits the model.
sigma: Probability of rejecting a good model.
epsilon: Inlier ratio.
decision_threshold: The decision threshold at which to terminate.
observed_inlier_ratio: Output parameter of inlier ratio tested.