ステレオ対応付け

詳細説明

名前空間
namespace	cv::fisheye
	この名前空間のメソッドは、いわゆる魚眼カメラモデルを用いる。

クラス
class	cv::StereoBM
	ブロックマッチングアルゴリズムを用いてステレオ対応を計算するクラス。K. Konolige によって導入され、OpenCV に提供された。 詳細...
class	cv::StereoMatcher
	ステレオ対応アルゴリズムの基底クラス。 詳細...
class	cv::StereoSGBM
	このクラスは、H. Hirschmullerのアルゴリズムを改変したもの [128] を実装しており、元のアルゴリズムとは以下の点で異なる: 続き...

列挙型
enum	{   cv::StereoSGBM::MODE_SGBM = 0 ,   cv::StereoSGBM::MODE_HH = 1 ,   cv::StereoSGBM::MODE_SGBM_3WAY = 2 ,   cv::StereoSGBM::MODE_HH4 = 3 }
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 }

関数
virtual void	cv::StereoMatcher::compute (InputArray left, InputArray right, OutputArray disparity)=0
	指定したステレオペアの視差マップを計算する。
static Ptr< StereoBM >	cv::StereoBM::create (int numDisparities=0, int blockSize=21)
	StereoBM オブジェクトを生成する。
static Ptr< StereoSGBM >	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)
	StereoSGBMオブジェクトを生成する。
void	cv::filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
	視差マップ中の小さなノイズの塊（スペックル）を除去する。
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)
	(stereoRectify が返す) 平行化された画像の有効ROIから、有効な視差ROIを計算する
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)
	視差画像を3D空間へ再投影する。
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::fisheye::stereoRectify (InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize=Size(), double balance=0.0, double fov_scale=1.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)
	キャリブレーション済みステレオカメラの各眼について矯正変換を計算する。
bool	cv::stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
	未キャリブレーションのステレオカメラについて矯正変換を計算する。
void	cv::validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
	左右チェックを用いて視差を検証する。行列 "cost" はステレオ対応アルゴリズムによって計算されている必要がある

列挙型詳解

anonymous enum

anonymous enum

列挙値
MODE_SGBM
MODE_HH
MODE_SGBM_3WAY
MODE_HH4

anonymous enum

anonymous enum

列挙値
DISP_SHIFT
DISP_SCALE

anonymous enum

anonymous enum

列挙値
PREFILTER_NORMALIZED_RESPONSE
PREFILTER_XSOBEL

関数詳解

compute()

virtual void cv::StereoMatcher::compute ( InputArray left, InputArray right, OutputArray disparity )

pure virtual

Python:
	cv.StereoMatcher.compute(	left, right[, disparity]	) ->	disparity

#include <opencv2/stereo.hpp>

指定されたステレオペアに対して視差マップを計算する。

引数

left	左側の 8 ビットシングルチャンネル画像。
right	左画像と同じサイズかつ同じ型の右画像。
disparity	出力される視差マップ。入力画像と同じサイズを持つ。StereoBM や StereoSGBM といった一部のアルゴリズムは 16 ビット固定小数点の視差マップ（各視差値は 4 ビットの小数部を持つ）を計算するのに対し、他のアルゴリズムは 32 ビット浮動小数点の視差マップを出力する。

cv::cuda::StereoSGM で実装されている。

create() [1/2]

static Ptr< StereoBM > cv::StereoBM::create ( int numDisparities = 0, int blockSize = 21 )

static

Python:
	cv.StereoBM.create(	[, numDisparities[, blockSize]]	) ->	retval
	cv.StereoBM_create(	[, numDisparities[, blockSize]]	) ->	retval

#include <opencv2/stereo.hpp>

StereoBM オブジェクトを生成する。

引数

numDisparities	視差の探索範囲。各ピクセルについて、アルゴリズムは0（デフォルトの最小視差）からnumDisparitiesまでの範囲で最適な視差を探索する。最小視差を変更することで、探索範囲をシフトできる。
blockSize	アルゴリズムが比較するブロックの一辺の長さ。ブロックは現在のピクセルを中心とするため、サイズは奇数でなければならない。ブロックサイズを大きくすると、視差マップは滑らかになるが精度は低下する。ブロックサイズを小さくすると、より詳細な視差マップが得られるが、アルゴリズムが誤った対応を見つける可能性が高くなる。

この関数は StereoBM オブジェクトを生成する。その後 StereoBM::compute() を呼び出して、特定のステレオ対の視差を計算できる。

create() [2/2]

static Ptr< StereoSGBM > 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[, numDisparities[, blockSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, mode]]]]]]]]]]]	) ->	retval
	cv.StereoSGBM_create(	[, minDisparity[, numDisparities[, blockSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, mode]]]]]]]]]]]	) ->	retval

#include <opencv2/stereo.hpp>

StereoSGBMオブジェクトを生成する。

引数

minDisparity	最小視差値。通常はゼロだが、レクティフィケーションアルゴリズムが画像をシフトすることがあるため、それに応じてこの引数を調整する必要がある。
numDisparities	最大視差から最小視差を引いた値。この値は常にゼロより大きい。現在の実装では、この引数は16で割り切れなければならない。
blockSize	マッチングするブロックサイズ。1以上の奇数でなければならない。通常は3..11の範囲のどこかにあるべきである。
P1	視差の平滑性を制御する第1引数。下記を参照。
P2	視差の平滑性を制御する第2引数。値が大きいほど視差は平滑になる。P1 は隣接ピクセル間で視差がプラスマイナス1だけ変化することに対するペナルティである。P2 は隣接ピクセル間で視差が1を超えて変化することに対するペナルティである。アルゴリズムは P2 > P1 であることを要求する。妥当に良い P1 と P2 の値が示されている stereo_match.cpp サンプルを参照 (それぞれ 8*number_of_image_channels*blockSize*blockSize と 32*number_of_image_channels*blockSize*blockSize など)。
disp12MaxDiff	左右視差チェックにおける許容される最大の差(整数ピクセル単位)。チェックを無効にするには非正の値を設定する。
preFilterCap	プレフィルタされた画像ピクセルの切り捨て値。アルゴリズムはまず各ピクセルでx微分を計算し、その値を[-preFilterCap, preFilterCap]の区間でクリップする。結果の値はBirchfield-Tomasiのピクセルコスト関数に渡される。
uniquenessRatio	見つかったマッチを正しいと見なすために、計算されたコスト関数の最良(最小)値が次に良い値に対して「勝つ」べきマージン(パーセンテージ)。通常、5-15の範囲の値で十分である。
speckleWindowSize	ノイズスペックルと見なして無効化する、滑らかな視差領域の最大サイズ。スペックルフィルタリングを無効にするには0を設定する。それ以外の場合は50-200の範囲のどこかに設定する。
speckleRange	各連結成分内における視差の最大変動量。スペックルフィルタリングを行う場合は正の値を設定する。この値は内部的に16倍される。通常は1または2で十分である。
mode	フルスケールの2パス動的計画法アルゴリズムを実行するには StereoSGBM::MODE_HH に設定する。これは O(W*H*numDisparities) バイトを消費し、640x480 のステレオでは大きく、HD サイズの画像では膨大になる。デフォルトでは false に設定されている。

1番目のコンストラクタはStereoSGBMをすべてのデフォルト引数で初期化する。したがって、最低限StereoSGBM::numDisparitiesを設定するだけでよい。2番目のコンストラクタでは各引数を任意の値に設定できる。

filterSpeckles()

void cv::filterSpeckles	(	InputOutputArray	img,
		double	newVal,
		int	maxSpeckleSize,
		double	maxDiff,
		InputOutputArray	buf = noArray() )

Python:
	cv.filterSpeckles(	img, newVal, maxSpeckleSize, maxDiff[, buf]	) ->	img, buf

#include <opencv2/stereo.hpp>

視差マップ内の小さなノイズblob（スペックル）を除去する。

引数

img	入力となる16ビット符号付き視差画像
newVal	スペックル（小さな斑点）を塗りつぶすために使用する視差値
maxSpeckleSize	スペックルとみなす最大スペックルサイズ。これより大きなblobはアルゴリズムの影響を受けない
maxDiff	隣接する視差ピクセルを同じblobにまとめるための最大差。StereoBM、StereoSGBM、およびその他のアルゴリズムは、視差値が16倍された固定小数点の視差マップを返すため、このパラメータ値を指定する際にはこのスケール係数を考慮する必要があることに注意。
buf	関数内でのメモリ割り当てを避けるための省略可能な一時バッファ。

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>

(stereoRectify が返す) 平行化された画像の有効ROIから、有効な視差ROIを計算する

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[, handleMissingValues[, ddepth]]]	) ->	_3dImage

#include <opencv2/stereo.hpp>

視差画像を 3D 空間に再投影する。

引数

disparity	入力のシングルチャンネル視差画像。8ビット符号なし、16ビット符号付き、32ビット符号付き、または32ビット浮動小数点。8ビット/16ビット符号付き形式の値は小数部を持たないと仮定される。視差が StereoBM や StereoSGBM あるいは他のアルゴリズムで計算された16ビット符号付き形式の場合、ここで使用する前に16で割る(そしてfloatにスケーリングする)必要がある。
_3dImage	disparity と同じサイズの 3 チャンネル浮動小数点画像を出力する。_3dImage(x,y) の各要素は、視差マップから計算された点 (x,y) の 3 次元座標を含む。stereoRectify で得られた Q を使用した場合、返される点は第1カメラの平行化された座標系で表される。
Q	stereoRectify で取得できる \(4 \times 4\) の透視変換行列。
handleMissingValues	関数が欠損値(すなわち視差が計算されなかった点)を処理すべきかどうかを示す。handleMissingValues=true の場合、外れ値に対応する最小の視差を持つピクセル(StereoMatcher::compute を参照)は、非常に大きな Z 値(現在は 10000 に設定)を持つ 3 次元点に変換される。
ddepth	省略可能な出力配列のビット深度。-1 の場合、出力画像のビット深度は CV_32F になる。ddepth には CV_16S、CV_32S、CV_32F も設定できる。

この関数は、シングルチャンネルの視差マップを、3D 表面を表す 3 チャンネル画像に変換する。すなわち、各ピクセル (x,y) と対応する視差 d=disparity(x,y) について、次を計算する。

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

参照

点の疎な集合 {(x,y,d),...} を 3D 空間に再投影するには、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() [1/2]

void cv::fisheye::stereoRectify	(	InputArray	K1,
		InputArray	D1,
		InputArray	K2,
		InputArray	D2,
		const Size &	imageSize,
		InputArray	R,
		InputArray	tvec,
		OutputArray	R1,
		OutputArray	R2,
		OutputArray	P1,
		OutputArray	P2,
		OutputArray	Q,
		int	flags,
		const Size &	newImageSize = Size(),
		double	balance = 0.0,
		double	fov_scale = 1.0 )

Python:
	cv.fisheye.stereoRectify(	K1, D1, K2, D2, imageSize, R, tvec, flags[, R1[, R2[, P1[, P2[, Q[, newImageSize[, balance[, fov_scale]]]]]]]]	) ->	R1, R2, P1, P2, Q

#include <opencv2/stereo.hpp>

魚眼カメラモデルのステレオ平行化。

引数

K1	1台目のカメラの内部行列。
D1	1台目のカメラの歪みパラメータ。
K2	2台目のカメラの内部行列。
D2	2台目のカメラの歪みパラメータ。
imageSize	ステレオキャリブレーションに使用される画像のサイズ。
R	1台目と2台目のカメラの座標系の間の回転行列。
tvec	カメラの座標系の間の並進ベクトル。
R1	1台目のカメラの出力される 3x3 平行化変換 (回転行列)。
R2	2台目のカメラの出力される 3x3 平行化変換 (回転行列)。
P1	1台目のカメラの新しい (平行化された) 座標系における出力される 3x4 射影行列。
P2	2台目のカメラの新しい (平行化された) 座標系における出力される 3x4 射影行列。
Q	\(4 \times 4\) の視差から深度へのマッピング行列を出力する(reprojectImageTo3D を参照)。
flags	ゼロまたは cv::CALIB_ZERO_DISPARITY となりうる動作フラグ。このフラグが設定されている場合、関数は各カメラの主点が平行化されたビューで同じピクセル座標を持つようにする。フラグが設定されていない場合、関数は(エピポーラ線の向きに応じて)有用な画像領域を最大化するために、画像を水平方向または垂直方向にシフトすることがある。
newImageSize	平行化後の新しい画像解像度。同じサイズを initUndistortRectifyMap に渡すべきである(OpenCV samples ディレクトリの stereo_calib.cpp サンプルを参照)。(0,0) が渡された場合(デフォルト)、元の imageSize に設定される。より大きな値に設定すると、特に大きな放射状歪みがある場合に、元の画像の細部を保持するのに役立つ。
balance	最小焦点距離と最大焦点距離の範囲内で新しい焦点距離を設定する。Balance は [0, 1] の範囲である。
fov_scale	新しい焦点距離の除数。

stereoRectify() [2/2]

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[, R2[, P1[, P2[, Q[, flags[, alpha[, newImageSize]]]]]]]]	) ->	R1, R2, P1, P2, Q, validPixROI1, validPixROI2

#include <opencv2/stereo.hpp>

キャリブレーション済みステレオカメラの各ヘッドに対する平行化(rectification)変換を計算する。

引数

cameraMatrix1	1台目のカメラの内部行列。
distCoeffs1	1台目のカメラの歪みパラメータ。
cameraMatrix2	2台目のカメラの内部行列。
distCoeffs2	2台目のカメラの歪みパラメータ。
imageSize	ステレオキャリブレーションに使用される画像のサイズ。
R	1台目のカメラの座標系から2台目のカメラへの回転行列。stereoCalibrate を参照。
T	1台目のカメラの座標系から2台目のカメラへの並進ベクトル。stereoCalibrate を参照。
R1	1台目のカメラに対する出力の3x3整列変換（回転行列）。この行列は、整列前の1台目のカメラの座標系で与えられた点を、整列後の1台目のカメラの座標系の点へ変換する。より技術的に言えば、整列前の1台目のカメラの座標系から整列後の1台目のカメラの座標系への基底変換を行う。
R2	2台目のカメラに対する出力の3x3整列変換（回転行列）。この行列は、整列前の2台目のカメラの座標系で与えられた点を、整列後の2台目のカメラの座標系の点へ変換する。より技術的に言えば、整列前の2台目のカメラの座標系から整列後の2台目のカメラの座標系への基底変換を行う。
P1	1台目のカメラに対する新しい（整列後の）座標系での出力の3x4射影行列。すなわち、整列後の1台目のカメラ座標系で与えられた点を、整列後の1台目のカメラの画像へ射影する。
P2	2台目のカメラに対する新しい（整列後の）座標系での出力の3x4射影行列。すなわち、整列後の1台目のカメラ座標系で与えられた点を、整列後の2台目のカメラの画像へ射影する。
Q	出力の \(4 \times 4\) 視差から深度への変換行列（reprojectImageTo3D を参照）。
flags	0、または STEREO_ZERO_DISPARITY を指定できる操作フラグ。このフラグを設定すると、各カメラの主点が平行化後の画像で同じピクセル座標を持つようになる。フラグを設定しない場合でも、関数は有用な画像領域を最大化するために、(エピポーラ線の向きに応じて) 画像を水平方向または垂直方向にシフトすることがある。
alpha	自由スケーリングパラメータ。-1 または省略された場合、関数はデフォルトのスケーリングを行う。それ以外の場合、このパラメータは 0 から 1 の間でなければならない。alpha=0 は、有効なピクセルのみが見えるように整列後の画像を拡大しシフトすることを意味する（整列後に黒い領域がない）。alpha=1 は、カメラからの元画像のすべてのピクセルが整列後の画像に保持されるように整列後の画像を間引きしシフトすることを意味する（元画像のピクセルが失われない）。中間の値は、これら2つの両極端の場合の中間の結果を与える。
newImageSize	平行化後の新しい画像解像度。同じサイズを initUndistortRectifyMap に渡す必要がある (OpenCV の samples ディレクトリにある stereo_calib.cpp サンプルを参照)。(0,0) を渡した場合 (デフォルト) は、元の imageSize に設定される。より大きな値に設定すると、特に大きな放射状歪みがある場合に、元画像のディテールを保持するのに役立つ。
validPixROI1	すべてのピクセルが有効である整列後の画像内の出力矩形（省略可能）。alpha=0 の場合、ROI は画像全体を覆う。それ以外の場合、ROI はより小さくなる可能性が高い（下の図を参照）。
validPixROI2	すべてのピクセルが有効である整列後の画像内の出力矩形（省略可能）。alpha=0 の場合、ROI は画像全体を覆う。それ以外の場合、ROI はより小さくなる可能性が高い（下の図を参照）。

この関数は、両カメラの画像平面を (仮想的に) 同一平面にするための各カメラの回転行列を計算する。その結果、すべてのエピポーラ線が平行になり、密なステレオ対応問題が簡略化される。関数は stereoCalibrate で計算した行列を入力として受け取る。出力として、2つの回転行列と、新しい座標系における2つの射影行列を提供する。この関数は次の2つのケースを区別する:

• 水平ステレオ: 第1カメラと第2カメラのビューが、主にx軸に沿って互いにずれている(垂直方向の小さなずれも起こりうる)。平行化された画像では、左右のカメラの対応するエピポーラ線は水平で、同じy座標を持つ。P1 と P2 は次のようになる:

  \[\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 \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\]

  \[\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \]

  ここで \(T_x\) はカメラ間の水平方向のシフトであり、STEREO_ZERO_DISPARITY が設定されている場合は \(cx_1=cx_2\) となる。

• 垂直ステレオ: 第1カメラと第2カメラのビューが、主に垂直方向に互いにずれている(おそらく水平方向にも少しずれている)。平行化された画像のエピポーラ線は垂直で、同じx座標を持つ。P1 と P2 は次のようになる:

  \[\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 \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\]

  \[\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \]

  ここで \(T_y\) はカメラ間の垂直方向のシフトであり、STEREO_ZERO_DISPARITY が設定されている場合は \(cy_1=cy_2\) となる。

見て分かるとおり、P1 と P2 の最初の3列が、実質的に新しい「平行化された」カメラ行列となる。これらの行列を R1 および R2 とともに initUndistortRectifyMap に渡すことで、各カメラの平行化マップを初期化できる。

以下に stereo_calib.cpp サンプルのスクリーンショットを示す。いくつかの赤い水平線が対応する画像領域を通っている。これは画像が良好に平行化されていることを意味し、ほとんどのステレオ対応アルゴリズムがこれに依存している。緑色の矩形は roi1 と roi2 である。それらの内部がすべて有効なピクセルであることが分かる。

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[, H2[, threshold]]]	) ->	retval, H1, H2

#include <opencv2/stereo.hpp>

キャリブレーションされていないステレオカメラの平行化変換を計算する。

引数

points1	1枚目の画像内の特徴点の配列。
points2	2枚目の画像における対応点。findFundamentalMat と同じ形式がサポートされている。
F	入力の基礎行列 (fundamental matrix)。同じ点の組のセットから findFundamentalMat を使って計算できる。
imgSize	画像のサイズ。
H1	1枚目の画像に対する出力の整列ホモグラフィ行列。
H2	2枚目の画像に対する出力の整列ホモグラフィ行列。
threshold	外れ値を除去するために使用するしきい値（省略可能）。このパラメータが 0 より大きい場合、エピポーラ幾何に従わないすべての点対（すなわち \(|\texttt{points2[i]}^T \cdot \texttt{F} \cdot \texttt{points1[i]}|>\texttt{threshold}\) となる点）は、ホモグラフィを計算する前に除外される。それ以外の場合、すべての点がインライアとみなされる。

この関数は、カメラの内部パラメータや空間内での相対位置を知らなくても平行化変換を計算する。これが「uncalibrated (未較正)」という接尾辞の由来である。stereoRectify との関連するもう1つの違いは、この関数がオブジェクト (3D) 空間における平行化変換ではなく、ホモグラフィ行列 H1 と H2 で符号化された平面的な透視変換を出力する点である。この関数はアルゴリズム [122] を実装している。

覚え書き

このアルゴリズムはカメラの内部パラメータを知る必要はないが、エピポーラ幾何に強く依存する。したがって、カメラのレンズに大きな歪みがある場合は、基礎行列を計算してこの関数を呼び出す前に補正しておくほうがよい。例えば、calibrateCamera を使ってステレオカメラの各ヘッドごとに歪み係数を個別に推定できる。その後、undistort を使って画像を補正するか、あるいは undistortPoints を使って点の座標だけを補正できる。

validateDisparity()

void cv::validateDisparity	(	InputOutputArray	disparity,
		InputArray	cost,
		int	minDisparity,
		int	numberOfDisparities,
		int	disp12MaxDisp = 1 )

Python:
	cv.validateDisparity(	disparity, cost, minDisparity, numberOfDisparities[, disp12MaxDisp]	) ->	disparity

#include <opencv2/stereo.hpp>

左右チェックを用いて視差を検証する。行列「cost」はステレオ対応アルゴリズムによって計算されるべきである。