boofcv.factory.feature.disparity

Class FactoryStereoDisparity

java.lang.Object

boofcv.factory.feature.disparity.FactoryStereoDisparity

public class FactoryStereoDisparity
extends java.lang.Object

Creates high level interfaces for computing the disparity between two rectified stereo images. Algorithms which select the best disparity for each region independent of all the others are referred to as Winner Takes All (WTA) in the literature. Dense algorithms compute the disparity for the whole image while sparse algorithms do it in a per pixel basis as requested.

Typically disparity calculations with regions will produce less erratic results, but their precision will be decreased. This is especially evident along the border of objects. Computing a wider range of disparities can better results, but is very computationally expensive.

Dense vs Sparse. Here dense refers to computing the disparity across the whole image at once. Sparse refers to computing the disparity for a single pixel at a time as requested by the user,

Constructor Summary

Constructors

Constructor and Description
FactoryStereoDisparity()

Method Summary

Modifier and Type	Method and Description
static <T extends ImageGray> StereoDisparitySparse<T>	regionSparseWta(int minDisparity, int maxDisparity, int regionRadiusX, int regionRadiusY, double maxPerPixelError, double texture, boolean subpixelInterpolation, java.lang.Class<T> imageType) WTA algorithms that computes disparity on a sparse per-pixel basis as requested..
static <T extends ImageGray> StereoDisparity<T,GrayF32>	regionSubpixelWta(DisparityAlgorithms whichAlg, int minDisparity, int maxDisparity, int regionRadiusX, int regionRadiusY, double maxPerPixelError, int validateRtoL, double texture, java.lang.Class<T> imageType) Returns an algorithm for computing a dense disparity images with sub-pixel disparity accuracy.
static <T extends ImageGray> StereoDisparity<T,GrayU8>	regionWta(DisparityAlgorithms whichAlg, int minDisparity, int maxDisparity, int regionRadiusX, int regionRadiusY, double maxPerPixelError, int validateRtoL, double texture, java.lang.Class<T> imageType) Crates algorithms for computing dense disparity images up to pixel level accuracy.

Methods inherited from class java.lang.Object

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

Constructor Detail

FactoryStereoDisparity

public FactoryStereoDisparity()

Method Detail

regionWta

public static <T extends ImageGray> StereoDisparity<T,GrayU8> regionWta(DisparityAlgorithms whichAlg,
                                                                        int minDisparity,
                                                                        int maxDisparity,
                                                                        int regionRadiusX,
                                                                        int regionRadiusY,
                                                                        double maxPerPixelError,
                                                                        int validateRtoL,
                                                                        double texture,
                                                                        java.lang.Class<T> imageType)

Crates algorithms for computing dense disparity images up to pixel level accuracy.

NOTE: For RECT_FIVE the size of the sub-regions it uses is what is specified.

Parameters:

minDisparity - Minimum disparity that it will check. Must be ≥ 0 and < maxDisparity

maxDisparity - Maximum disparity that it will calculate. Must be > 0

regionRadiusX - Radius of the rectangular region along x-axis.

regionRadiusY - Radius of the rectangular region along y-axis.

maxPerPixelError - Maximum allowed error in a region per pixel. Set to < 0 to disable.

validateRtoL - Tolerance for how difference the left to right associated values can be. Try 6

texture - Tolerance for how similar optimal region is to other region. Closer to zero is more tolerant. Try 0.1

imageType - Type of input image.

Returns:

Rectangular region based WTA disparity.algorithm.

regionSubpixelWta

public static <T extends ImageGray> StereoDisparity<T,GrayF32> regionSubpixelWta(DisparityAlgorithms whichAlg,
                                                                                 int minDisparity,
                                                                                 int maxDisparity,
                                                                                 int regionRadiusX,
                                                                                 int regionRadiusY,
                                                                                 double maxPerPixelError,
                                                                                 int validateRtoL,
                                                                                 double texture,
                                                                                 java.lang.Class<T> imageType)

Returns an algorithm for computing a dense disparity images with sub-pixel disparity accuracy.

NOTE: For RECT_FIVE the size of the sub-regions it uses is what is specified.

Parameters:

minDisparity - Minimum disparity that it will check. Must be ≥ 0 and < maxDisparity

maxDisparity - Maximum disparity that it will calculate. Must be > 0

regionRadiusX - Radius of the rectangular region along x-axis. Try 3.

regionRadiusY - Radius of the rectangular region along y-axis. Try 3.

maxPerPixelError - Maximum allowed error in a region per pixel. Set to < 0 to disable.

validateRtoL - Tolerance for how difference the left to right associated values can be. Try 6

texture - Tolerance for how similar optimal region is to other region. Disable with a value ≤ 0. Closer to zero is more tolerant. Try 0.1

imageType - Type of input image.

Returns:

Rectangular region based WTA disparity.algorithm.

regionSparseWta

public static <T extends ImageGray> StereoDisparitySparse<T> regionSparseWta(int minDisparity,
                                                                             int maxDisparity,
                                                                             int regionRadiusX,
                                                                             int regionRadiusY,
                                                                             double maxPerPixelError,
                                                                             double texture,
                                                                             boolean subpixelInterpolation,
                                                                             java.lang.Class<T> imageType)

WTA algorithms that computes disparity on a sparse per-pixel basis as requested..

Type Parameters:

T - Image type

Parameters:

minDisparity - Minimum disparity that it will check. Must be ≥ 0 and < maxDisparity

maxDisparity - Maximum disparity that it will calculate. Must be > 0

regionRadiusX - Radius of the rectangular region along x-axis.

regionRadiusY - Radius of the rectangular region along y-axis.

maxPerPixelError - Maximum allowed error in a region per pixel. Set to < 0 to disable.

texture - Tolerance for how similar optimal region is to other region. Closer to zero is more tolerant. Try 0.1

subpixelInterpolation - true to turn on sub-pixel interpolation

imageType - Type of input image.

Returns:

Sparse disparity algorithm