OpenCV  5.0.0-pre Open Source Computer Vision
Stereo Correspondence

Classes

class  cv::StereoBM
Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K. Konolige. More...

class  cv::StereoMatcher
The base class for stereo correspondence algorithms. More...

class  cv::StereoSGBM
The class implements the modified H. Hirschmuller algorithm [111] that differs from the original one as follows: More...

Enumerations

enum  {
cv::StereoMatcher::DISP_SHIFT = 4,
cv::StereoMatcher::DISP_SCALE = (1 << DISP_SHIFT)
}

enum  {
cv::StereoBM::PREFILTER_NORMALIZED_RESPONSE = 0,
cv::StereoBM::PREFILTER_XSOBEL = 1
}

enum  {
cv::StereoSGBM::MODE_SGBM = 0,
cv::StereoSGBM::MODE_HH = 1,
cv::StereoSGBM::MODE_SGBM_3WAY = 2,
cv::StereoSGBM::MODE_HH4 = 3
}

Functions

virtual void cv::StereoMatcher::compute (InputArray left, InputArray right, OutputArray disparity)=0
Computes disparity map for the specified stereo pair. More...

static Ptr< StereoBMcv::StereoBM::create (int numDisparities=0, int blockSize=21)
Creates StereoBM object. More...

static Ptr< StereoSGBMcv::StereoSGBM::create (int minDisparity=0, int numDisparities=16, int blockSize=3, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, int mode=StereoSGBM::MODE_SGBM)
Creates StereoSGBM object. More...

void cv::filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
Filters off small noise blobs (speckles) in the disparity map. More...

virtual int cv::StereoMatcher::getBlockSize () const =0

virtual int cv::StereoMatcher::getDisp12MaxDiff () const =0

virtual int cv::StereoMatcher::getMinDisparity () const =0

virtual int cv::StereoSGBM::getMode () const =0

virtual int cv::StereoMatcher::getNumDisparities () const =0

virtual int cv::StereoSGBM::getP1 () const =0

virtual int cv::StereoSGBM::getP2 () const =0

virtual int cv::StereoBM::getPreFilterCap () const =0

virtual int cv::StereoSGBM::getPreFilterCap () const =0

virtual int cv::StereoBM::getPreFilterSize () const =0

virtual int cv::StereoBM::getPreFilterType () const =0

virtual Rect cv::StereoBM::getROI1 () const =0

virtual Rect cv::StereoBM::getROI2 () const =0

virtual int cv::StereoBM::getSmallerBlockSize () const =0

virtual int cv::StereoMatcher::getSpeckleRange () const =0

virtual int cv::StereoMatcher::getSpeckleWindowSize () const =0

virtual int cv::StereoBM::getTextureThreshold () const =0

virtual int cv::StereoBM::getUniquenessRatio () const =0

virtual int cv::StereoSGBM::getUniquenessRatio () const =0

Rect cv::getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by stereoRectify) More...

float cv::rectify3Collinear (InputArray _cameraMatrix1, InputArray _distCoeffs1, InputArray _cameraMatrix2, InputArray _distCoeffs2, InputArray _cameraMatrix3, InputArray _distCoeffs3, InputArrayOfArrays _imgpt1, InputArrayOfArrays _imgpt3, Size imageSize, InputArray _Rmat12, InputArray _Tmat12, InputArray _Rmat13, InputArray _Tmat13, OutputArray _Rmat1, OutputArray _Rmat2, OutputArray _Rmat3, OutputArray _Pmat1, OutputArray _Pmat2, OutputArray _Pmat3, OutputArray _Qmat, double alpha, Size newImgSize, Rect *roi1, Rect *roi2, int flags)

void cv::reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
Reprojects a disparity image to 3D space. More...

virtual void cv::StereoMatcher::setBlockSize (int blockSize)=0

virtual void cv::StereoMatcher::setDisp12MaxDiff (int disp12MaxDiff)=0

virtual void cv::StereoMatcher::setMinDisparity (int minDisparity)=0

virtual void cv::StereoSGBM::setMode (int mode)=0

virtual void cv::StereoMatcher::setNumDisparities (int numDisparities)=0

virtual void cv::StereoSGBM::setP1 (int P1)=0

virtual void cv::StereoSGBM::setP2 (int P2)=0

virtual void cv::StereoBM::setPreFilterCap (int preFilterCap)=0

virtual void cv::StereoSGBM::setPreFilterCap (int preFilterCap)=0

virtual void cv::StereoBM::setPreFilterSize (int preFilterSize)=0

virtual void cv::StereoBM::setPreFilterType (int preFilterType)=0

virtual void cv::StereoBM::setROI1 (Rect roi1)=0

virtual void cv::StereoBM::setROI2 (Rect roi2)=0

virtual void cv::StereoBM::setSmallerBlockSize (int blockSize)=0

virtual void cv::StereoMatcher::setSpeckleRange (int speckleRange)=0

virtual void cv::StereoMatcher::setSpeckleWindowSize (int speckleWindowSize)=0

virtual void cv::StereoBM::setTextureThreshold (int textureThreshold)=0

virtual void cv::StereoBM::setUniquenessRatio (int uniquenessRatio)=0

virtual void cv::StereoSGBM::setUniquenessRatio (int uniquenessRatio)=0

void cv::stereoRectify (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=STEREO_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), Rect *validPixROI1=0, Rect *validPixROI2=0)
Computes rectification transforms for each head of a calibrated stereo camera. More...

bool cv::stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
Computes a rectification transform for an uncalibrated stereo camera. More...

void cv::validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm More...

◆ anonymous enum

 anonymous enum
Enumerator
DISP_SHIFT
DISP_SCALE

◆ anonymous enum

 anonymous enum
Enumerator
PREFILTER_NORMALIZED_RESPONSE
PREFILTER_XSOBEL

◆ anonymous enum

 anonymous enum
Enumerator
MODE_SGBM
MODE_HH
MODE_SGBM_3WAY
MODE_HH4

◆ compute()

 virtual void cv::StereoMatcher::compute ( InputArray left, InputArray right, OutputArray disparity )
pure virtual
Python:
cv.StereoMatcher.compute(left, right[, disparity=None]) -> disparity

#include <opencv2/stereo.hpp>

Computes disparity map for the specified stereo pair.

Parameters
 left Left 8-bit single-channel image. right Right image of the same size and the same type as the left one. disparity Output disparity map. It has the same size as the input images. Some algorithms, like StereoBM or StereoSGBM compute 16-bit fixed-point disparity map (where each disparity value has 4 fractional bits), whereas other algorithms output 32-bit floating-point disparity map.

Implemented in cv::cuda::StereoSGM.

◆ create() [1/2]

 static Ptr cv::StereoBM::create ( int numDisparities = 0, int blockSize = 21 )
static
Python:
cv.StereoBM_create([, numDisparities=0, blockSize=21]) -> retval

#include <opencv2/stereo.hpp>

Creates StereoBM object.

Parameters
 numDisparities the disparity search range. For each pixel algorithm will find the best disparity from 0 (default minimum disparity) to numDisparities. The search range can then be shifted by changing the minimum disparity. blockSize the linear size of the blocks compared by the algorithm. The size should be odd (as the block is centered at the current pixel). Larger block size implies smoother, though less accurate disparity map. Smaller block size gives more detailed disparity map, but there is higher chance for algorithm to find a wrong correspondence.

The function create StereoBM object. You can then call StereoBM::compute() to compute disparity for a specific stereo pair.

◆ create() [2/2]

 static Ptr cv::StereoSGBM::create ( int minDisparity = 0, int numDisparities = 16, int blockSize = 3, int P1 = 0, int P2 = 0, int disp12MaxDiff = 0, int preFilterCap = 0, int uniquenessRatio = 0, int speckleWindowSize = 0, int speckleRange = 0, int mode = StereoSGBM::MODE_SGBM )
static
Python:
cv.StereoSGBM_create([, minDisparity=0, numDisparities=16, blockSize=3, P1=0, P2=0, disp12MaxDiff=0, preFilterCap=0, uniquenessRatio=0, speckleWindowSize=0, speckleRange=0, mode=StereoSGBM::MODE_SGBM]) -> retval

#include <opencv2/stereo.hpp>

Creates StereoSGBM object.

Parameters
 minDisparity Minimum possible disparity value. Normally, it is zero but sometimes rectification algorithms can shift images, so this parameter needs to be adjusted accordingly. numDisparities Maximum disparity minus minimum disparity. The value is always greater than zero. In the current implementation, this parameter must be divisible by 16. blockSize Matched block size. It must be an odd number >=1 . Normally, it should be somewhere in the 3..11 range. P1 The first parameter controlling the disparity smoothness. See below. P2 The second parameter controlling the disparity smoothness. The larger the values are, the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1 between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor pixels. The algorithm requires P2 > P1 . See stereo_match.cpp sample where some reasonably good P1 and P2 values are shown (like 8*number_of_image_channels*blockSize*blockSize and 32*number_of_image_channels*blockSize*blockSize , respectively). disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right disparity check. Set it to a non-positive value to disable the check. preFilterCap Truncation value for the prefiltered image pixels. The algorithm first computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval. The result values are passed to the Birchfield-Tomasi pixel cost function. uniquenessRatio Margin in percentage by which the best (minimum) computed cost function value should "win" the second best value to consider the found match correct. Normally, a value within the 5-15 range is good enough. speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the 50-200 range. speckleRange Maximum disparity variation within each connected component. If you do speckle filtering, set the parameter to a positive value, it will be implicitly multiplied by 16. Normally, 1 or 2 is good enough. mode Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming algorithm. It will consume O(W*H*numDisparities) bytes, which is large for 640x480 stereo and huge for HD-size pictures. By default, it is set to false .

The first constructor initializes StereoSGBM with all the default parameters. So, you only have to set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter to a custom value.

◆ filterSpeckles()

 void cv::filterSpeckles ( InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf = noArray() )
Python:
cv.filterSpeckles(img, newVal, maxSpeckleSize, maxDiff[, buf=Mat()]) -> img, buf
cv.filterSpeckles(img, newVal, maxSpeckleSize, maxDiff[, buf=UMat()]) -> img, buf

#include <opencv2/stereo.hpp>

Filters off small noise blobs (speckles) in the disparity map.

Parameters
 img The input 16-bit signed disparity image newVal The disparity value used to paint-off the speckles maxSpeckleSize The maximum speckle size to consider it a speckle. Larger blobs are not affected by the algorithm maxDiff Maximum difference between neighbor disparity pixels to put them into the same blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point disparity map, where disparity values are multiplied by 16, this scale factor should be taken into account when specifying this parameter value. buf The optional temporary buffer to avoid memory allocation within the function.

◆ getBlockSize()

 virtual int cv::StereoMatcher::getBlockSize ( ) const
pure virtual
Python:
cv.StereoMatcher.getBlockSize([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getDisp12MaxDiff()

 virtual int cv::StereoMatcher::getDisp12MaxDiff ( ) const
pure virtual
Python:
cv.StereoMatcher.getDisp12MaxDiff([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getMinDisparity()

 virtual int cv::StereoMatcher::getMinDisparity ( ) const
pure virtual
Python:
cv.StereoMatcher.getMinDisparity([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getMode()

 virtual int cv::StereoSGBM::getMode ( ) const
pure virtual
Python:
cv.StereoSGBM.getMode([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getNumDisparities()

 virtual int cv::StereoMatcher::getNumDisparities ( ) const
pure virtual
Python:
cv.StereoMatcher.getNumDisparities([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getP1()

 virtual int cv::StereoSGBM::getP1 ( ) const
pure virtual
Python:
cv.StereoSGBM.getP1([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getP2()

 virtual int cv::StereoSGBM::getP2 ( ) const
pure virtual
Python:
cv.StereoSGBM.getP2([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getPreFilterCap() [1/2]

 virtual int cv::StereoBM::getPreFilterCap ( ) const
pure virtual
Python:
cv.StereoBM.getPreFilterCap([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getPreFilterCap() [2/2]

 virtual int cv::StereoSGBM::getPreFilterCap ( ) const
pure virtual
Python:
cv.StereoSGBM.getPreFilterCap([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getPreFilterSize()

 virtual int cv::StereoBM::getPreFilterSize ( ) const
pure virtual
Python:
cv.StereoBM.getPreFilterSize([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getPreFilterType()

 virtual int cv::StereoBM::getPreFilterType ( ) const
pure virtual
Python:
cv.StereoBM.getPreFilterType([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getROI1()

 virtual Rect cv::StereoBM::getROI1 ( ) const
pure virtual
Python:
cv.StereoBM.getROI1([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getROI2()

 virtual Rect cv::StereoBM::getROI2 ( ) const
pure virtual
Python:
cv.StereoBM.getROI2([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getSmallerBlockSize()

 virtual int cv::StereoBM::getSmallerBlockSize ( ) const
pure virtual
Python:
cv.StereoBM.getSmallerBlockSize([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getSpeckleRange()

 virtual int cv::StereoMatcher::getSpeckleRange ( ) const
pure virtual
Python:
cv.StereoMatcher.getSpeckleRange([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getSpeckleWindowSize()

 virtual int cv::StereoMatcher::getSpeckleWindowSize ( ) const
pure virtual
Python:
cv.StereoMatcher.getSpeckleWindowSize([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getTextureThreshold()

 virtual int cv::StereoBM::getTextureThreshold ( ) const
pure virtual
Python:
cv.StereoBM.getTextureThreshold([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getUniquenessRatio() [1/2]

 virtual int cv::StereoBM::getUniquenessRatio ( ) const
pure virtual
Python:
cv.StereoBM.getUniquenessRatio([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getUniquenessRatio() [2/2]

 virtual int cv::StereoSGBM::getUniquenessRatio ( ) const
pure virtual
Python:
cv.StereoSGBM.getUniquenessRatio([, ]) -> retval

#include <opencv2/stereo.hpp>

◆ getValidDisparityROI()

 Rect cv::getValidDisparityROI ( Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize )
Python:
cv.getValidDisparityROI(roi1, roi2, minDisparity, numberOfDisparities, blockSize[, ]) -> retval

#include <opencv2/stereo.hpp>

computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by stereoRectify)

◆ rectify3Collinear()

 float cv::rectify3Collinear ( InputArray _cameraMatrix1, InputArray _distCoeffs1, InputArray _cameraMatrix2, InputArray _distCoeffs2, InputArray _cameraMatrix3, InputArray _distCoeffs3, InputArrayOfArrays _imgpt1, InputArrayOfArrays _imgpt3, Size imageSize, InputArray _Rmat12, InputArray _Tmat12, InputArray _Rmat13, InputArray _Tmat13, OutputArray _Rmat1, OutputArray _Rmat2, OutputArray _Rmat3, OutputArray _Pmat1, OutputArray _Pmat2, OutputArray _Pmat3, OutputArray _Qmat, double alpha, Size newImgSize, Rect * roi1, Rect * roi2, int flags )

#include <opencv2/stereo.hpp>

◆ reprojectImageTo3D()

 void cv::reprojectImageTo3D ( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues = false, int ddepth = -1 )
Python:
cv.reprojectImageTo3D(disparity, Q[, _3dImage=None, handleMissingValues=false, ddepth=-1]) -> _3dImage

#include <opencv2/stereo.hpp>

Reprojects a disparity image to 3D space.

Parameters
 disparity Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image. The values of 8-bit / 16-bit signed formats are assumed to have no fractional bits. If the disparity is 16-bit signed format, as computed by StereoBM or StereoSGBM and maybe other algorithms, it should be divided by 16 (and scaled to float) before being used here. _3dImage Output 3-channel floating-point image of the same size as disparity. Each element of _3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity map. If one uses Q obtained by stereoRectify, then the returned points are represented in the first camera's rectified coordinate system. Q $$4 \times 4$$ perspective transformation matrix that can be obtained with stereoRectify. handleMissingValues Indicates, whether the function should handle missing values (i.e. points where the disparity was not computed). If handleMissingValues=true, then pixels with the minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed to 3D points with a very large Z value (currently set to 10000). ddepth The optional output array depth. If it is -1, the output image will have CV_32F depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.

The function transforms a single-channel disparity map to a 3-channel image representing a 3D surface. That is, for each pixel (x,y) and the corresponding disparity d=disparity(x,y) , it computes:

$\begin{bmatrix} X \\ Y \\ Z \\ W \end{bmatrix} = Q \begin{bmatrix} x \\ y \\ \texttt{disparity} (x,y) \\ z \end{bmatrix}.$

To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform.

◆ setBlockSize()

 virtual void cv::StereoMatcher::setBlockSize ( int blockSize )
pure virtual
Python:
cv.StereoMatcher.setBlockSize(blockSize[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setDisp12MaxDiff()

 virtual void cv::StereoMatcher::setDisp12MaxDiff ( int disp12MaxDiff )
pure virtual
Python:
cv.StereoMatcher.setDisp12MaxDiff(disp12MaxDiff[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setMinDisparity()

 virtual void cv::StereoMatcher::setMinDisparity ( int minDisparity )
pure virtual
Python:
cv.StereoMatcher.setMinDisparity(minDisparity[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setMode()

 virtual void cv::StereoSGBM::setMode ( int mode )
pure virtual
Python:
cv.StereoSGBM.setMode(mode[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setNumDisparities()

 virtual void cv::StereoMatcher::setNumDisparities ( int numDisparities )
pure virtual
Python:
cv.StereoMatcher.setNumDisparities(numDisparities[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setP1()

 virtual void cv::StereoSGBM::setP1 ( int P1 )
pure virtual
Python:
cv.StereoSGBM.setP1(P1[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setP2()

 virtual void cv::StereoSGBM::setP2 ( int P2 )
pure virtual
Python:
cv.StereoSGBM.setP2(P2[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setPreFilterCap() [1/2]

 virtual void cv::StereoBM::setPreFilterCap ( int preFilterCap )
pure virtual
Python:
cv.StereoBM.setPreFilterCap(preFilterCap[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setPreFilterCap() [2/2]

 virtual void cv::StereoSGBM::setPreFilterCap ( int preFilterCap )
pure virtual
Python:
cv.StereoSGBM.setPreFilterCap(preFilterCap[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setPreFilterSize()

 virtual void cv::StereoBM::setPreFilterSize ( int preFilterSize )
pure virtual
Python:
cv.StereoBM.setPreFilterSize(preFilterSize[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setPreFilterType()

 virtual void cv::StereoBM::setPreFilterType ( int preFilterType )
pure virtual
Python:
cv.StereoBM.setPreFilterType(preFilterType[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setROI1()

 virtual void cv::StereoBM::setROI1 ( Rect roi1 )
pure virtual
Python:
cv.StereoBM.setROI1(roi1[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setROI2()

 virtual void cv::StereoBM::setROI2 ( Rect roi2 )
pure virtual
Python:
cv.StereoBM.setROI2(roi2[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setSmallerBlockSize()

 virtual void cv::StereoBM::setSmallerBlockSize ( int blockSize )
pure virtual
Python:
cv.StereoBM.setSmallerBlockSize(blockSize[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setSpeckleRange()

 virtual void cv::StereoMatcher::setSpeckleRange ( int speckleRange )
pure virtual
Python:
cv.StereoMatcher.setSpeckleRange(speckleRange[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setSpeckleWindowSize()

 virtual void cv::StereoMatcher::setSpeckleWindowSize ( int speckleWindowSize )
pure virtual
Python:
cv.StereoMatcher.setSpeckleWindowSize(speckleWindowSize[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setTextureThreshold()

 virtual void cv::StereoBM::setTextureThreshold ( int textureThreshold )
pure virtual
Python:
cv.StereoBM.setTextureThreshold(textureThreshold[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setUniquenessRatio() [1/2]

 virtual void cv::StereoBM::setUniquenessRatio ( int uniquenessRatio )
pure virtual
Python:
cv.StereoBM.setUniquenessRatio(uniquenessRatio[, ]) -> None

#include <opencv2/stereo.hpp>

◆ setUniquenessRatio() [2/2]

 virtual void cv::StereoSGBM::setUniquenessRatio ( int uniquenessRatio )
pure virtual
Python:
cv.StereoSGBM.setUniquenessRatio(uniquenessRatio[, ]) -> None

#include <opencv2/stereo.hpp>

◆ stereoRectify()

 void cv::stereoRectify ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags = STEREO_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect * validPixROI1 = 0, Rect * validPixROI2 = 0 )
Python:
cv.stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, R1=None, R2=None, P1=None, P2=None, Q=None, flags=STEREO_ZERO_DISPARITY, alpha=-1, newImageSize=Size()]) -> R1, R2, P1, P2, Q, validPixROI1, validPixROI2

#include <opencv2/stereo.hpp>

Computes rectification transforms for each head of a calibrated stereo camera.

Parameters
 cameraMatrix1 First camera intrinsic matrix. distCoeffs1 First camera distortion parameters. cameraMatrix2 Second camera intrinsic matrix. distCoeffs2 Second camera distortion parameters. imageSize Size of the image used for stereo calibration. R Rotation matrix from the coordinate system of the first camera to the second camera, see stereoCalibrate. T Translation vector from the coordinate system of the first camera to the second camera, see stereoCalibrate. R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix brings points given in the unrectified first camera's coordinate system to points in the rectified first camera's coordinate system. In more technical terms, it performs a change of basis from the unrectified first camera's coordinate system to the rectified first camera's coordinate system. R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix brings points given in the unrectified second camera's coordinate system to points in the rectified second camera's coordinate system. In more technical terms, it performs a change of basis from the unrectified second camera's coordinate system to the rectified second camera's coordinate system. P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera, i.e. it projects points given in the rectified first camera coordinate system into the rectified first camera's image. P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera, i.e. it projects points given in the rectified first camera coordinate system into the rectified second camera's image. Q Output $$4 \times 4$$ disparity-to-depth mapping matrix (see reprojectImageTo3D). flags Operation flags that may be zero or STEREO_ZERO_DISPARITY . If the flag is set, the function makes the principal points of each camera have the same pixel coordinates in the rectified views. And if the flag is not set, the function may still shift the images in the horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the useful image area. alpha Free scaling parameter. If it is -1 or absent, the function performs the default scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified images are zoomed and shifted so that only valid pixels are visible (no black areas after rectification). alpha=1 means that the rectified image is decimated and shifted so that all the pixels from the original images from the cameras are retained in the rectified images (no source image pixels are lost). Any intermediate value yields an intermediate result between those two extreme cases. newImageSize New image resolution after rectification. The same size should be passed to initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0) is passed (default), it is set to the original imageSize . Setting it to a larger value can help you preserve details in the original image, especially when there is a big radial distortion. validPixROI1 Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller (see the picture below). validPixROI2 Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller (see the picture below).

The function computes the rotation matrices for each camera that (virtually) make both camera image planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies the dense stereo correspondence problem. The function takes the matrices computed by stereoCalibrate as input. As output, it provides two rotation matrices and also two projection matrices in the new coordinates. The function distinguishes the following two cases:

• Horizontal stereo: the first and the second camera views are shifted relative to each other mainly along the x-axis (with possible small vertical shift). In the rectified images, the corresponding epipolar lines in the left and right cameras are horizontal and have the same y-coordinate. P1 and P2 look like:

$\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}$

$\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x*f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,$

where $$T_x$$ is a horizontal shift between the cameras and $$cx_1=cx_2$$ if STEREO_ZERO_DISPARITY is set.

• Vertical stereo: the first and the second camera views are shifted relative to each other mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:

$\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}$

$\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y*f \\ 0 & 0 & 1 & 0 \end{bmatrix},$

where $$T_y$$ is a vertical shift between the cameras and $$cy_1=cy_2$$ if STEREO_ZERO_DISPARITY is set.

As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera matrices. The matrices, together with R1 and R2 , can then be passed to initUndistortRectifyMap to initialize the rectification map for each camera.

See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through the corresponding image regions. This means that the images are well rectified, which is what most stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that their interiors are all valid pixels.

image

◆ stereoRectifyUncalibrated()

 bool cv::stereoRectifyUncalibrated ( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold = 5 )
Python:
cv.stereoRectifyUncalibrated(points1, points2, F, imgSize[, H1=None, H2=None, threshold=5]) -> retval, H1, H2

#include <opencv2/stereo.hpp>

Computes a rectification transform for an uncalibrated stereo camera.

Parameters
 points1 Array of feature points in the first image. points2 The corresponding points in the second image. The same formats as in findFundamentalMat are supported. F Input fundamental matrix. It can be computed from the same set of point pairs using findFundamentalMat . imgSize Size of the image. H1 Output rectification homography matrix for the first image. H2 Output rectification homography matrix for the second image. threshold Optional threshold used to filter out the outliers. If the parameter is greater than zero, all the point pairs that do not comply with the epipolar geometry (that is, the points for which $$|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}$$ ) are rejected prior to computing the homographies. Otherwise, all the points are considered inliers.

The function computes the rectification transformations without knowing intrinsic parameters of the cameras and their relative position in the space, which explains the suffix "uncalibrated". Another related difference from stereoRectify is that the function outputs not the rectification transformations in the object (3D) space, but the planar perspective transformations encoded by the homography matrices H1 and H2 . The function implements the algorithm [104] .

Note
While the algorithm does not need to know the intrinsic parameters of the cameras, it heavily depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion, it would be better to correct it before computing the fundamental matrix and calling this function. For example, distortion coefficients can be estimated for each head of stereo camera separately by using calibrateCamera . Then, the images can be corrected using undistort , or just the point coordinates can be corrected with undistortPoints .

◆ validateDisparity()

 void cv::validateDisparity ( InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1 )
Python:
cv.validateDisparity(disparity, cost, minDisparity, numberOfDisparities[, disp12MaxDisp=1]) -> disparity

#include <opencv2/stereo.hpp>

validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm