RBKltTracker¶

class RBKltTracker(self)¶

Bases: RBFeatureTracker

Methods

`__init__`
`computeVVSIter`
`display`
`extractFeatures`
`getFilteringBorderSize`
`getFilteringMaxReprojectionError`
`getKltTracker`
`getMinimumDistanceNewPoints`
`getMinimumMaskConfidence`
`getMinimumNumberOfPoints`
`initVVS`
`loadJsonConfiguration`	Overloaded function.
`onTrackingIterEnd`
`onTrackingIterStart`
`requiresDepth`
`requiresRGB`
`requiresSilhouetteCandidates`
`setFilteringBorderSize`
`setFilteringMaxReprojectionError`
`setMinimumDistanceNewPoints`
`setMinimumMaskConfidence`
`setMinimumNumberOfPoints`
`setShouldUseMask`
`shouldUseMask`
`trackFeatures`

Inherited Methods

`getLTR`	Get the right-side term of the Gauss-Newton optimization term.
`featuresShouldBeDisplayed`
`setTrackerWeight`
`L`
`LTR`
`computeCovarianceMatrix`
`weights`
`covWeightDiag`
`getNumFeatures`	Return the type of feature that is used by this tracker.
`getWeightedError`	Get a weighted version of the error vector.
`vvsHasConverged`	Returns whether the tracker is considered as having converged to the desired pose.
`userVvsWeight`
`getCovariance`	Retrieve the 6 x 6 pose covariance matrix, computed from the weights associated to each feature.
`computeJTR`
`getLTL`	Get the left-side term of the Gauss-Newton optimization term.
`numFeatures`
`vvsConverged`
`LTL`
`enableDisplay`
`weighted_error`
`updateCovariance`	Update the covariance matrix.
`cov`
`error`
`setFeaturesShouldBeDisplayed`
`getVVSTrackerWeight`	Get the importance of this tracker in the optimization step.

Operators

`__doc__`
`__init__`
`__module__`

Attributes

`L`
`LTL`
`LTR`
`__annotations__`
`cov`
`covWeightDiag`
`enableDisplay`
`error`
`numFeatures`
`userVvsWeight`
`vvsConverged`
`weighted_error`
`weights`

__init__(self)¶

static computeCovarianceMatrix(A: visp._visp.core.Matrix, b: visp._visp.core.ColVector, W: visp._visp.core.Matrix) → visp._visp.core.Matrix¶

static computeJTR(interaction: visp._visp.core.Matrix, error: visp._visp.core.ColVector, JTR: visp._visp.core.ColVector) → None¶

computeVVSIter(self, frame: visp._visp.rbt.RBFeatureTrackerInput, cMo: visp._visp.core.HomogeneousMatrix, iteration: int) → None¶

display(self, cam: visp._visp.core.CameraParameters, I: visp._visp.core.ImageGray, IRGB: visp._visp.core.ImageRGBa, depth: visp._visp.core.ImageGray) → None¶

extractFeatures(self, frame: visp._visp.rbt.RBFeatureTrackerInput, previousFrame: visp._visp.rbt.RBFeatureTrackerInput, cMo: visp._visp.core.HomogeneousMatrix) → None¶

featuresShouldBeDisplayed(self) → bool¶

getCovariance(self) → visp._visp.core.Matrix¶

Retrieve the 6 x 6 pose covariance matrix, computed from the weights associated to each feature.

The updateCovariance method should have been called before

getFilteringBorderSize(self) → int¶

getFilteringMaxReprojectionError(self) → float¶

getKltTracker(self) → visp._visp.klt.KltOpencv¶

getLTL(self) → visp._visp.core.Matrix¶: Get the left-side term of the Gauss-Newton optimization term.

getLTR(self) → visp._visp.core.ColVector¶: Get the right-side term of the Gauss-Newton optimization term.

getMinimumDistanceNewPoints(self) → float¶

getMinimumMaskConfidence(self) → float¶

getMinimumNumberOfPoints(self) → int¶

getNumFeatures(self) → int¶

Return the type of feature that is used by this tracker.

Get the number of features used to compute the pose update

Returns:: vpRBFeatureType

getVVSTrackerWeight(self) → float¶: Get the importance of this tracker in the optimization step. The default computation is the following: \(w / N\) , where \(w\) is the weight defined by setTrackerWeight, and \(N\) is the number of features.

getWeightedError(self) → visp._visp.core.ColVector¶: Get a weighted version of the error vector. This should not include the userVVSWeight, but may include reweighting to remove outliers, occlusions, etc.

initVVS(self, frame: visp._visp.rbt.RBFeatureTrackerInput, previousFrame: visp._visp.rbt.RBFeatureTrackerInput, cMo: visp._visp.core.HomogeneousMatrix) → None¶

loadJsonConfiguration(*args, **kwargs)¶

Overloaded function.

loadJsonConfiguration(self: visp._visp.rbt.RBKltTracker, j: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char> > >) -> None
loadJsonConfiguration(self: visp._visp.rbt.RBFeatureTracker, j: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char> > >) -> None

onTrackingIterEnd(self) → None¶

onTrackingIterStart(self) → None¶

requiresDepth(self) → bool¶

requiresRGB(self) → bool¶

requiresSilhouetteCandidates(self) → bool¶

setFeaturesShouldBeDisplayed(self, enableDisplay: bool) → None¶

setFilteringBorderSize(self, border: int) → None¶

setFilteringMaxReprojectionError(self, maxError: float) → None¶

setMinimumDistanceNewPoints(self, distance: float) → None¶

setMinimumMaskConfidence(self, confidence: float) → None¶

setMinimumNumberOfPoints(self, points: int) → None¶

setShouldUseMask(self, useMask: bool) → None¶

setTrackerWeight(self, weight: float) → None¶

shouldUseMask(self) → bool¶

trackFeatures(self, frame: visp._visp.rbt.RBFeatureTrackerInput, previousFrame: visp._visp.rbt.RBFeatureTrackerInput, cMo: visp._visp.core.HomogeneousMatrix) → None¶

updateCovariance(self: visp._visp.rbt.RBFeatureTracker, lambda: float) → None¶

Update the covariance matrix.

Parameters:

lambda: the visual servoing gain

vvsHasConverged(self) → bool¶: Returns whether the tracker is considered as having converged to the desired pose.