boofcv.factory.sfm

Class FactoryVisualOdometry

java.lang.Object

boofcv.factory.sfm.FactoryVisualOdometry

public class FactoryVisualOdometry
extends java.lang.Object

Factory for creating visual odometry algorithms.

Constructor Summary

Constructors

Constructor and Description
FactoryVisualOdometry()

Method Summary

Modifier and Type	Method and Description
static <Vis extends ImageGray,Depth extends ImageGray> DepthVisualOdometry<Vis,Depth>	depthDepthPnP(double inlierPixelTol, int thresholdAdd, int thresholdRetire, int ransacIterations, int refineIterations, boolean doublePass, DepthSparse3D<Depth> sparseDepth, PointTrackerTwoPass<Vis> tracker, java.lang.Class<Vis> visualType, java.lang.Class<Depth> depthType) Depth sensor based visual odometry algorithm which runs a sparse feature tracker in the visual camera and estimates the range of tracks once when first detected using the depth sensor.
static <T extends ImageGray> MonocularPlaneVisualOdometry<T>	monoPlaneInfinity(int thresholdAdd, int thresholdRetire, double inlierPixelTol, int ransacIterations, PointTracker<T> tracker, ImageType<T> imageType) Monocular plane based visual odometry algorithm which uses both points on the plane and off plane for motion estimation.
static <T extends ImageGray> MonocularPlaneVisualOdometry<T>	monoPlaneOverhead(double cellSize, double maxCellsPerPixel, double mapHeightFraction, double inlierGroundTol, int ransacIterations, int thresholdRetire, int absoluteMinimumTracks, double respawnTrackFraction, double respawnCoverageFraction, PointTracker<T> tracker, ImageType<T> imageType) Monocular plane based visual odometry algorithm which creates a synthetic overhead view and tracks image features inside this synthetic view.
static <T extends ImageBase> MonocularPlaneVisualOdometry<T>	scaleInput(MonocularPlaneVisualOdometry<T> vo, double scaleFactor) Wraps around a MonocularPlaneVisualOdometry instance and will rescale the input images and adjust the cameras intrinsic parameters automatically.
static <T extends ImageBase> StereoVisualOdometry<T>	scaleInput(StereoVisualOdometry<T> vo, double scaleFactor) Wraps around a StereoVisualOdometry instance and will rescale the input images and adjust the cameras intrinsic parameters automatically.
static <T extends ImageGray> StereoVisualOdometry<T>	stereoDepth(double inlierPixelTol, int thresholdAdd, int thresholdRetire, int ransacIterations, int refineIterations, boolean doublePass, StereoDisparitySparse<T> sparseDisparity, PointTrackerTwoPass<T> tracker, java.lang.Class<T> imageType) Stereo vision based visual odometry algorithm which runs a sparse feature tracker in the left camera and estimates the range of tracks once when first detected using disparity between left and right cameras.
static <T extends ImageGray,Desc extends TupleDesc> StereoVisualOdometry<T>	stereoDualTrackerPnP(int thresholdAdd, int thresholdRetire, double inlierPixelTol, double epipolarPixelTol, int ransacIterations, int refineIterations, PointTracker<T> trackerLeft, PointTracker<T> trackerRight, DescribeRegionPoint<T,Desc> descriptor, java.lang.Class<T> imageType) Creates a stereo visual odometry algorithm that independently tracks features in left and right camera.
static <T extends ImageGray,Desc extends TupleDesc> StereoVisualOdometry<T>	stereoQuadPnP(double inlierPixelTol, double epipolarPixelTol, double maxDistanceF2F, double maxAssociationError, int ransacIterations, int refineIterations, DetectDescribeMulti<T,Desc> detector, java.lang.Class<T> imageType) Stereo visual odometry which uses the two most recent stereo observations (total of four views) to estimate motion.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FactoryVisualOdometry

public FactoryVisualOdometry()

Method Detail

monoPlaneInfinity

public static <T extends ImageGray> MonocularPlaneVisualOdometry<T> monoPlaneInfinity(int thresholdAdd,
                                                                                      int thresholdRetire,
                                                                                      double inlierPixelTol,
                                                                                      int ransacIterations,
                                                                                      PointTracker<T> tracker,
                                                                                      ImageType<T> imageType)

Monocular plane based visual odometry algorithm which uses both points on the plane and off plane for motion estimation.

Type Parameters:

T -

Parameters:

thresholdAdd - New points are spawned when the number of on plane inliers drops below this value.

thresholdRetire - Tracks are dropped when they are not contained in the inlier set for this many frames in a row. Try 2

inlierPixelTol - Threshold used to determine inliers in pixels. Try 1.5

ransacIterations - Number of RANSAC iterations. Try 200

tracker - Image feature tracker

imageType - Type of input image it processes

Returns:

New instance of

See Also:

VisOdomMonoPlaneInfinity

monoPlaneOverhead

public static <T extends ImageGray> MonocularPlaneVisualOdometry<T> monoPlaneOverhead(double cellSize,
                                                                                      double maxCellsPerPixel,
                                                                                      double mapHeightFraction,
                                                                                      double inlierGroundTol,
                                                                                      int ransacIterations,
                                                                                      int thresholdRetire,
                                                                                      int absoluteMinimumTracks,
                                                                                      double respawnTrackFraction,
                                                                                      double respawnCoverageFraction,
                                                                                      PointTracker<T> tracker,
                                                                                      ImageType<T> imageType)

Monocular plane based visual odometry algorithm which creates a synthetic overhead view and tracks image features inside this synthetic view.

Parameters:

cellSize - (Overhead) size of ground cells in overhead image in world units

maxCellsPerPixel - (Overhead) Specifies the minimum resolution. Higher values allow lower resolutions. Try 20

mapHeightFraction - (Overhead) Truncates the overhead view. Must be from 0 to 1.0. 1.0 includes the entire image.

inlierGroundTol - (RANSAC) RANSAC tolerance in overhead image pixels

ransacIterations - (RANSAC) Number of iterations used when estimating motion

thresholdRetire - (2D Motion) Drop tracks if they are not in inliers set for this many turns.

absoluteMinimumTracks - (2D Motion) Spawn tracks if the number of inliers drops below the specified number

respawnTrackFraction - (2D Motion) Spawn tracks if the number of tracks has dropped below this fraction of the original number

respawnCoverageFraction - (2D Motion) Spawn tracks if the total coverage drops below this relative fraction

tracker - Image feature tracker

imageType - Type of image being processed

Returns:

MonocularPlaneVisualOdometry

See Also:

VisOdomMonoOverheadMotion2D

stereoDepth

public static <T extends ImageGray> StereoVisualOdometry<T> stereoDepth(double inlierPixelTol,
                                                                        int thresholdAdd,
                                                                        int thresholdRetire,
                                                                        int ransacIterations,
                                                                        int refineIterations,
                                                                        boolean doublePass,
                                                                        StereoDisparitySparse<T> sparseDisparity,
                                                                        PointTrackerTwoPass<T> tracker,
                                                                        java.lang.Class<T> imageType)

Stereo vision based visual odometry algorithm which runs a sparse feature tracker in the left camera and estimates the range of tracks once when first detected using disparity between left and right cameras.

Parameters:

thresholdAdd - Add new tracks when less than this number are in the inlier set. Tracker dependent. Set to a value ≤ 0 to add features every frame.

thresholdRetire - Discard a track if it is not in the inlier set after this many updates. Try 2

sparseDisparity - Estimates the 3D location of features

imageType - Type of image being processed.

Returns:

StereoVisualOdometry

See Also:

VisOdomPixelDepthPnP

depthDepthPnP

public static <Vis extends ImageGray,Depth extends ImageGray> DepthVisualOdometry<Vis,Depth> depthDepthPnP(double inlierPixelTol,
                                                                                                           int thresholdAdd,
                                                                                                           int thresholdRetire,
                                                                                                           int ransacIterations,
                                                                                                           int refineIterations,
                                                                                                           boolean doublePass,
                                                                                                           DepthSparse3D<Depth> sparseDepth,
                                                                                                           PointTrackerTwoPass<Vis> tracker,
                                                                                                           java.lang.Class<Vis> visualType,
                                                                                                           java.lang.Class<Depth> depthType)

Depth sensor based visual odometry algorithm which runs a sparse feature tracker in the visual camera and estimates the range of tracks once when first detected using the depth sensor.

Parameters:

thresholdAdd - Add new tracks when less than this number are in the inlier set. Tracker dependent. Set to a value ≤ 0 to add features every frame.

thresholdRetire - Discard a track if it is not in the inlier set after this many updates. Try 2

sparseDepth - Extracts depth of pixels from a depth sensor.

visualType - Type of visual image being processed.

depthType - Type of depth image being processed.

Returns:

StereoVisualOdometry

See Also:

VisOdomPixelDepthPnP

stereoDualTrackerPnP

public static <T extends ImageGray,Desc extends TupleDesc> StereoVisualOdometry<T> stereoDualTrackerPnP(int thresholdAdd,
                                                                                                        int thresholdRetire,
                                                                                                        double inlierPixelTol,
                                                                                                        double epipolarPixelTol,
                                                                                                        int ransacIterations,
                                                                                                        int refineIterations,
                                                                                                        PointTracker<T> trackerLeft,
                                                                                                        PointTracker<T> trackerRight,
                                                                                                        DescribeRegionPoint<T,Desc> descriptor,
                                                                                                        java.lang.Class<T> imageType)

Creates a stereo visual odometry algorithm that independently tracks features in left and right camera.

Parameters:

thresholdAdd - When the number of inliers is below this number new features are detected

thresholdRetire - When a feature has not been in the inlier list for this many ticks it is dropped

inlierPixelTol - Tolerance in pixels for defining an inlier during robust model matching. Typically 1.5

epipolarPixelTol - Tolerance in pixels for enforcing the epipolar constraint

ransacIterations - Number of iterations performed by RANSAC. Try 300 or more.

refineIterations - Number of iterations done during non-linear optimization. Try 50 or more.

trackerLeft - Tracker used for left camera

trackerRight - Tracker used for right camera

imageType - Type of image being processed

Returns:

Stereo visual odometry algorithm.

See Also:

VisOdomDualTrackPnP

stereoQuadPnP

public static <T extends ImageGray,Desc extends TupleDesc> StereoVisualOdometry<T> stereoQuadPnP(double inlierPixelTol,
                                                                                                 double epipolarPixelTol,
                                                                                                 double maxDistanceF2F,
                                                                                                 double maxAssociationError,
                                                                                                 int ransacIterations,
                                                                                                 int refineIterations,
                                                                                                 DetectDescribeMulti<T,Desc> detector,
                                                                                                 java.lang.Class<T> imageType)

Stereo visual odometry which uses the two most recent stereo observations (total of four views) to estimate motion.

See Also:

VisOdomQuadPnP

scaleInput

public static <T extends ImageBase> StereoVisualOdometry<T> scaleInput(StereoVisualOdometry<T> vo,
                                                                       double scaleFactor)

Wraps around a StereoVisualOdometry instance and will rescale the input images and adjust the cameras intrinsic parameters automatically. Rescaling input images is often an easy way to improve runtime performance with a minimal hit on pose accuracy.

Type Parameters:

T - Image type

Parameters:

vo - Visual odometry algorithm which is being wrapped

scaleFactor - Scale factor that the image should be reduced by, Try 0.5 for half size.

Returns:

StereoVisualOdometry

scaleInput

public static <T extends ImageBase> MonocularPlaneVisualOdometry<T> scaleInput(MonocularPlaneVisualOdometry<T> vo,
                                                                               double scaleFactor)

Wraps around a MonocularPlaneVisualOdometry instance and will rescale the input images and adjust the cameras intrinsic parameters automatically. Rescaling input images is often an easy way to improve runtime performance with a minimal hit on pose accuracy.

Type Parameters:

T - Image type

Parameters:

vo - Visual odometry algorithm which is being wrapped

scaleFactor - Scale factor that the image should be reduced by, Try 0.5 for half size.

Returns:

StereoVisualOdometry