Struct cv::PoseSolver

pub struct PoseSolver<'a> { /* fields omitted */ }

Allows pose solving to be parameterized if defaults are not sufficient.

Implementations

impl<'a> PoseSolver<'a>

pub fn epsilon(self, epsilon: f64) -> PoseSolver<'a>

Set the epsilon to be used in SVD.

pub fn max_iterations(self, max_iterations: usize) -> PoseSolver<'a>

Set the max number of iterations to be used in SVD.

pub fn consensus_ratio(self, consensus_ratio: f64) -> PoseSolver<'a>

Set the level of agreement required for the pose to be accepted.

pub fn solve_unscaled<P>(
    &self,
    triangulator: impl TriangulatorRelative,
    correspondences: impl Iterator<Item = FeatureMatch<P>>
) -> Option<UnscaledRelativeCameraPose> where
    P: Bearing + Copy, 

Solve the pose given correspondences.

pub fn solve_unscaled_inliers<P>(
    &self,
    triangulator: impl TriangulatorRelative,
    correspondences: impl Iterator<Item = FeatureMatch<P>>
) -> Option<(UnscaledRelativeCameraPose, Vec<usize>)> where
    P: Bearing + Copy, 

Same as PoseSolver::solve_unscaled, but also communicates the inliers.

The alloc feature must be enabled to use this method.

pub fn solve<P>(
    &self,
    triangulator: impl TriangulatorProject,
    correspondences: impl Clone + Iterator<Item = (CameraPoint, P)>
) -> Option<RelativeCameraPose> where
    P: Bearing + Copy, 

Return the RelativeCameraPose that transforms a CameraPoint of image A (source of a) to the corresponding CameraPoint of image B (source of b). This determines the average expected translation from the points themselves and if the points agree with the rotation (points must be in front of the camera). The function takes an iterator containing tuples in the form (depth, a, b):

• depth - The actual depth (z axis, not distance) of normalized keypoint a
• a - A keypoint from image A
• b - A keypoint from image B

self must satisfy the constraint:

transpose(homogeneous(a)) * E * homogeneous(b) = 0

Also, a and b must be a correspondence.

This will take the average translation over the entire iterator. This is done to smooth out noise and outliers (if present).

epsilon is a small value to which SVD must converge to before terminating.

max_iterations is the maximum number of iterations that SVD will run on this matrix. Use this to cap the execution time. A max_iterations of 0 may execute indefinitely and is not recommended except for non-production code.

consensus_ratio is the ratio of points which must be in front of the camera for the model to be accepted and return Some. Otherwise, None is returned. Set this to about 0.45 to have approximate majority consensus.

bearing_scale is a function that is passed a translation bearing vector, an untranslated (but rotated) camera point, and a normalized key point where the actual point exists. It must return the scalar which the translation bearing vector must by multiplied by to get the actual translation. It may return None if it fails.

correspondences must provide an iterator of tuples containing the matches of a 3d CameraPoint a from camera A and the matching NormalizedKeyPoint b from camera B.

This does not communicate which points were outliers to each model.

pub fn solve_inliers<P>(
    &self,
    triangulator: impl TriangulatorProject,
    correspondences: impl Clone + Iterator<Item = (CameraPoint, P)>
) -> Option<(RelativeCameraPose, Vec<usize>)> where
    P: Bearing + Copy, 

Same as PoseSolver::solve, but it also communicates the inliers.

The alloc feature must be enabled to use this method.

Trait Implementations

impl<'a> Clone for PoseSolver<'a>

fn clone(&self) -> PoseSolver<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for PoseSolver<'a>

impl<'a> Debug for PoseSolver<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.