カメラキャリブレーションと3次元再構成

トピック
	魚眼カメラモデル

詳細説明

このセクションの関数は、いわゆるピンホールカメラモデルを使用する。シーンのビューは、シーンの3D点 \(P_w\) を透視変換によって画像平面へ射影し、対応するピクセル \(p\) を形成することで得られる。\(P_w\) と \(p\) はともに同次座標で表現される。すなわち、それぞれ3Dおよび2Dの同次ベクトルとして表される。射影幾何、同次ベクトル、同次変換についての簡単な紹介は、このセクションの導入の最後にある。より簡潔な表記のため、しばしば「同次」を省略し、同次ベクトルのことを単にベクトルと呼ぶ。

ピンホールカメラモデルによって与えられる歪みのない射影変換を以下に示す。

\[s \; p = A \begin{bmatrix} R|t \end{bmatrix} P_w,\]

ここで \(P_w\) はワールド座標系に対して表現された3D点、\(p\) は画像平面上の2Dピクセル、\(A\) はカメラ内部行列、\(R\) と \(t\) はワールド座標系からカメラ座標系（またはカメラフレーム）への座標変換を表す回転と並進であり、\(s\) は射影変換の任意のスケーリングであってカメラモデルの一部ではない。

カメラ内部行列 \(A\)（[324] と同じ表記を使用し、一般には \(K\) とも表記される）は、カメラ座標系で与えられた3D点を2Dピクセル座標へ射影する。すなわち

\[p = A P_c.\]

カメラ内部行列 \(A\) は、ピクセル単位で表される焦点距離 \(f_x\) と \(f_y\)、および通常は画像中心に近い主点 \((c_x, c_y)\) で構成される:

\[A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1},\]

したがって

\[s \vecthree{u}{v}{1} = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} \vecthree{X_c}{Y_c}{Z_c}.\]

内部パラメータの行列は、見ているシーンに依存しない。そのため、いったん推定すれば、（ズームレンズの場合）焦点距離が固定されている限り再利用できる。したがって、カメラからの画像がある係数でスケールされた場合、これらのパラメータはすべて同じ係数でスケール（それぞれ乗算/除算）する必要がある。

回転・並進を結合した行列 \([R|t]\) は、射影変換と同次変換の行列積である。3行4列の射影変換は、カメラ座標系で表現された3D点を画像平面上の2D点に写像し、正規化カメラ座標 \(x' = X_c / Z_c\) および \(y' = Y_c / Z_c\) で表す。

\[Z_c \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} \begin{bmatrix} X_c \\ Y_c \\ Z_c \\ 1 \end{bmatrix}.\]

同次変換は外部パラメータ \(R\) と \(t\) によって表され、ワールド座標系 \(w\) からカメラ座標系 \(c\) への基底変換を表す。したがって、ワールド座標における点 \(P\) の表現 \(P_w\) が与えられると、カメラ座標系における \(P\) の表現 \(P_c\) は次のように得られる。

\[P_c = \begin{bmatrix} R & t \\ 0 & 1 \end{bmatrix} P_w,\]

この同次変換は、3行3列の回転行列 \(R\) と、3行1列の並進ベクトル \(t\) から構成される。

\[\begin{bmatrix} R & t \\ 0 & 1 \end{bmatrix} = \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_x \\ r_{21} & r_{22} & r_{23} & t_y \\ r_{31} & r_{32} & r_{33} & t_z \\ 0 & 0 & 0 & 1 \end{bmatrix}, \]

したがって

\[\begin{bmatrix} X_c \\ Y_c \\ Z_c \\ 1 \end{bmatrix} = \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_x \\ r_{21} & r_{22} & r_{23} & t_y \\ r_{31} & r_{32} & r_{33} & t_z \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} X_w \\ Y_w \\ Z_w \\ 1 \end{bmatrix}.\]

射影変換と同次変換を組み合わせると、ワールド座標における3D点を画像平面上の2D点へ正規化カメラ座標で写像する射影変換が得られる。

\[Z_c \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} = \begin{bmatrix} R|t \end{bmatrix} \begin{bmatrix} X_w \\ Y_w \\ Z_w \\ 1 \end{bmatrix} = \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_x \\ r_{21} & r_{22} & r_{23} & t_y \\ r_{31} & r_{32} & r_{33} & t_z \end{bmatrix} \begin{bmatrix} X_w \\ Y_w \\ Z_w \\ 1 \end{bmatrix},\]

ただし \(x' = X_c / Z_c\) および \(y' = Y_c / Z_c\) である。内部パラメータと外部パラメータの式をまとめると、\(s \; p = A \begin{bmatrix} R|t \end{bmatrix} P_w\) を次のように書き下せる。

\[s \vecthree{u}{v}{1} = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_x \\ r_{21} & r_{22} & r_{23} & t_y \\ r_{31} & r_{32} & r_{33} & t_z \end{bmatrix} \begin{bmatrix} X_w \\ Y_w \\ Z_w \\ 1 \end{bmatrix}.\]

\(Z_c \ne 0\) のとき、上記の変換は次の式と等価である。

\[\begin{bmatrix} u \\ v \end{bmatrix} = \begin{bmatrix} f_x X_c/Z_c + c_x \\ f_y Y_c/Z_c + c_y \end{bmatrix}\]

ただし

\[\vecthree{X_c}{Y_c}{Z_c} = \begin{bmatrix} R|t \end{bmatrix} \begin{bmatrix} X_w \\ Y_w \\ Z_w \\ 1 \end{bmatrix}.\]

次の図はピンホールカメラモデルを示している。

Pinhole camera model

実際のレンズには通常、何らかの歪みがあり、その大半は放射状歪みで、わずかに接線方向の歪みも生じる。そこで、上記のモデルは次のように拡張される。

\[\begin{bmatrix} u \\ v \end{bmatrix} = \begin{bmatrix} f_x x'' + c_x \\ f_y y'' + c_y \end{bmatrix}\]

ここで

\[\begin{bmatrix} x'' \\ y'' \end{bmatrix} = \begin{bmatrix} x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2 p_1 x' y' + p_2(r^2 + 2 x'^2) + s_1 r^2 + s_2 r^4 \\ y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\ \end{bmatrix}\]

ただし

\[r^2 = x'^2 + y'^2\]

および

\[\begin{bmatrix} x'\\ y' \end{bmatrix} = \begin{bmatrix} X_c/Z_c \\ Y_c/Z_c \end{bmatrix},\]

ただし \(Z_c \ne 0\) のとき。

歪みパラメータのうち、放射状の係数は \(k_1\)、\(k_2\)、\(k_3\)、\(k_4\)、\(k_5\)、\(k_6\) であり、\(p_1\) と \(p_2\) は接線方向歪み係数、\(s_1\)、\(s_2\)、\(s_3\)、\(s_4\) は薄プリズム歪み係数である。OpenCVではより高次の係数は考慮しない。

次の図は、放射状歪みの代表的な2種類を示している。すなわち、樽型歪み（\( 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 \) が単調減少）と糸巻き型歪み（\( 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 \) が単調増加）である。実際のレンズでは放射状歪みは常に単調であり、推定器が非単調な結果を生成した場合は、キャリブレーションの失敗とみなすべきである。より一般には、放射状歪みは単調でなければならず、歪み関数は全単射でなければならない。失敗した推定結果は画像中心付近では一見良好に見えることがあるが、たとえばAR/SFMアプリケーションでは正しく機能しない。OpenCVのカメラキャリブレーションで用いられる最適化手法は、必要な整数計画法や多項式不等式をフレームワークがサポートしていないため、これらの制約を含んでいない。詳細は issue #15992 を参照のこと。

場合によっては、カメラ前方の斜めの面に焦点を合わせるためにイメージセンサが傾けられることがある（シャインプルーフの原理）。これは粒子画像流速測定（PIV）やレーザーファンによる三角測量に有用である。この傾きは \(x''\) と \(y''\) に透視歪みを生じさせる。この歪みは次のようにモデル化できる。たとえば [177] を参照のこと。

\[\begin{bmatrix} u \\ v \end{bmatrix} = \begin{bmatrix} f_x x''' + c_x \\ f_y y''' + c_y \end{bmatrix},\]

ここで

\[s\vecthree{x'''}{y'''}{1} = \vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}(\tau_x, \tau_y)} {0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)} {0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\]

また行列 \(R(\tau_x, \tau_y)\) は、それぞれ角度パラメータ \(\tau_x\) と \(\tau_y\) による2つの回転によって定義される。

\[ R(\tau_x, \tau_y) = \vecthreethree{\cos(\tau_y)}{0}{-\sin(\tau_y)}{0}{1}{0}{\sin(\tau_y)}{0}{\cos(\tau_y)} \vecthreethree{1}{0}{0}{0}{\cos(\tau_x)}{\sin(\tau_x)}{0}{-\sin(\tau_x)}{\cos(\tau_x)} = \vecthreethree{\cos(\tau_y)}{\sin(\tau_y)\sin(\tau_x)}{-\sin(\tau_y)\cos(\tau_x)} {0}{\cos(\tau_x)}{\sin(\tau_x)} {\sin(\tau_y)}{-\cos(\tau_y)\sin(\tau_x)}{\cos(\tau_y)\cos(\tau_x)}. \]

以下の関数では、係数は次のように渡される、あるいは返される。

\[(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\]

というベクトルである。つまり、ベクトルが4つの要素を含む場合、\(k_3=0\) を意味する。歪み係数は撮影されるシーンに依存しない。したがって、これらもカメラの内部パラメータに属する。そして、撮影される画像の解像度にかかわらず同じ値のままである。たとえば、あるカメラが320×240解像度の画像でキャリブレーションされた場合、まったく同じ歪み係数を同じカメラの640×480画像に使用できる。ただし \(f_x\)、\(f_y\)、\(c_x\)、\(c_y\) は適切にスケーリングする必要がある。

以下の関数は、上記のモデルを用いて次の処理を行う。

• 内部パラメータと外部パラメータが与えられたとき、3D点を画像平面に投影する。
• 内部パラメータ、いくつかの3D点、およびそれらの投影が与えられたとき、外部パラメータを計算する。
• 既知のキャリブレーションパターンを複数の視点から撮影した画像から、カメラの内部パラメータと外部パラメータを推定する（各視点は複数の3D-2D点対応で記述される）。
• ステレオカメラの「ヘッド」の相対的な位置と姿勢を推定し、カメラの光軸を平行にする平行化（rectification）変換を計算する。

同次座標
同次座標は射影幾何学で用いられる座標系である。これを用いることで、無限遠点を有限の座標で表現でき、デカルト座標に比べて式が簡潔になる。たとえば、アフィン変換を線形な同次変換として表現できるという利点がある。

n次元のデカルトベクトル \(P\) の末尾に1を付加することで、同次ベクトル \(P_h\) が得られる。たとえば3次元のデカルトベクトルの場合、写像 \(P \rightarrow P_h\) は次のとおりである。

\[\begin{bmatrix} X \\ Y \\ Z \end{bmatrix} \rightarrow \begin{bmatrix} X \\ Y \\ Z \\ 1 \end{bmatrix}.\]

逆写像 \(P_h \rightarrow P\) では、同次ベクトルのすべての要素をその最後の要素で割る。たとえば3次元の同次ベクトルの場合、その2次元デカルト座標表現は次のように得られる。

\[\begin{bmatrix} X \\ Y \\ W \end{bmatrix} \rightarrow \begin{bmatrix} X / W \\ Y / W \end{bmatrix},\]

ただし \(W \ne 0\) のとき。

この写像により、ある同次点のすべての定数倍 \(k P_h\)（\(k \ne 0\)）は、同じ点 \(P_h\) を表す。この性質を直感的に理解すると、射影変換のもとでは \(P_h\) のすべての定数倍が同じ点に写像される、ということである。これはピンホールカメラに対して観察される物理的な事実であり、カメラのピンホールを通る光線上のすべての点が同じ画像点に投影される。たとえば、上記のピンホールカメラモデルの図における赤い光線上のすべての点は、同じ画像座標に写像される。この性質は、ピンホールカメラモデルの式におけるスケールの不定性 s の原因でもある。

前述のとおり、同次座標を用いることで、\(R\) と \(t\) でパラメータ化される任意の基底変換を線形変換として表現できる。たとえば、座標系0から座標系1への基底変換は次のようになる。

\[P_1 = R P_0 + t \rightarrow P_{h_1} = \begin{bmatrix} R & t \\ 0 & 1 \end{bmatrix} P_{h_0}.\]

同次変換、物体フレーム／カメラフレーム
基底変換、すなわちあるフレームから別のフレームへの3D座標の計算は、次の表記を用いて簡単に行える。

\[ \mathbf{X}_c = \hspace{0.2em} {}^{c}\mathbf{T}_o \hspace{0.2em} \mathbf{X}_o \]

\[ \begin{bmatrix} X_c \\ Y_c \\ Z_c \\ 1 \end{bmatrix} = \begin{bmatrix} {}^{c}\mathbf{R}_o & {}^{c}\mathbf{t}_o \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_o \\ Y_o \\ Z_o \\ 1 \end{bmatrix} \]

物体フレームで表現された3D点（\( \mathbf{X}_o \)）に対して、同次変換行列 \( {}^{c}\mathbf{T}_o \) を用いると、カメラフレームにおける対応する座標（\( \mathbf{X}_c \)）を計算できる。この変換行列は、3×3の回転行列 \( {}^{c}\mathbf{R}_o \) と3×1の並進ベクトル \( {}^{c}\mathbf{t}_o \) から構成される。3×1の並進ベクトル \( {}^{c}\mathbf{t}_o \) はカメラフレームにおける物体フレームの位置であり、3×3の回転行列 \( {}^{c}\mathbf{R}_o \) はカメラフレームにおける物体フレームの向きである。

この簡潔な表記により、変換を連鎖させることが容易になる。たとえば、物体フレームで表現された点の3D座標をワールドフレームで計算するには、次のようにすればよい。

\[ \mathbf{X}_w = \hspace{0.2em} {}^{w}\mathbf{T}_c \hspace{0.2em} {}^{c}\mathbf{T}_o \hspace{0.2em} \mathbf{X}_o = {}^{w}\mathbf{T}_o \hspace{0.2em} \mathbf{X}_o \]

同様に、逆変換の計算は次のように行える。

\[ \mathbf{X}_o = \hspace{0.2em} {}^{o}\mathbf{T}_c \hspace{0.2em} \mathbf{X}_c = \left( {}^{c}\mathbf{T}_o \right)^{-1} \hspace{0.2em} \mathbf{X}_c \]

同次変換行列の逆行列は次のとおりである。

\[ {}^{o}\mathbf{T}_c = \left( {}^{c}\mathbf{T}_o \right)^{-1} = \begin{bmatrix} {}^{c}\mathbf{R}^{\top}_o & - \hspace{0.2em} {}^{c}\mathbf{R}^{\top}_o \hspace{0.2em} {}^{c}\mathbf{t}_o \\ 0_{1 \times 3} & 1 \end{bmatrix} \]

3×3の回転行列の逆行列は、その転置行列に直接等しいことに注意する。

Perspective projection, from object to camera frame

この図は全体の処理をまとめたものである。たとえば solvePnP 関数が返す物体の姿勢、あるいは基準マーカー検出から得られる姿勢は、この \( {}^{c}\mathbf{T}_o \) 変換である。

カメラ内部行列 \( \mathbf{K} \) を用いると、透視投影モデル（ピンホールカメラモデル）を仮定して、カメラフレームで表現された3D点を画像平面に投影できる。一般的な画像処理関数から抽出された画像座標は、(u,v) を左上原点とする座標フレームを仮定している。

覚え書き

• for an online video course on this topic, see for instance:
  • "3.3.1. Homogeneous Transformation Matrices", Modern Robotics, Kevin M. Lynch and Frank C. Park
• 3×3の回転行列は9個の値から構成されるが、表すのは3自由度の変換である
• some additional properties of the 3x3 rotation matrix are:
  • \( \mathrm{det} \left( \mathbf{R} \right) = 1 \)
  • \( \mathbf{R} \mathbf{R}^{\top} = \mathbf{R}^{\top} \mathbf{R} = \mathrm{I}_{3 \times 3} \)
  • 回転の補間は Slerp（球面線形補間） 法を用いて行える
• 異なる回転表現の間の素早い変換は、この オンラインツール を用いて行える

カメラレンズの仕様からの内部パラメータ
産業用カメラを扱う場合、カメラ内部行列、より正確には \( \left(f_x, f_y \right) \) は、カメラの仕様から導出または近似できる。

\[ f_x = \frac{f_{\text{mm}}}{\text{pixel_size_in_mm}} = \frac{f_{\text{mm}}}{\text{sensor_size_in_mm} / \text{nb_pixels}} \]

同様に、物理的な焦点距離は画角から導出できる。

\[ f_{\text{mm}} = \frac{\text{sensor_size_in_mm}}{2 \times \tan{\frac{\text{fov}}{2}}} \]

後者の変換は、レンダリングソフトウェアで物理的なカメラ装置を模倣する際に有用である。

覚え書き

• calibrationMatrixValues も参照のこと

追加の参考文献、注記

覚え書き

• このモジュールの多くの関数は、カメラ内部行列を入力パラメータとして受け取る。すべての関数がこのパラメータについて同じ構造を仮定しているが、関数によって名前が異なる場合がある。ただし、パラメータの説明には、上記に示した構造のカメラ内部行列が必要であることが明確に記されている。
• 水平方向に配置した3台のカメラのキャリブレーションサンプルは opencv_source_code/samples/cpp/3calibration.cpp にある
• 画像列に基づくキャリブレーションサンプルは opencv_source_code/samples/cpp/calibration.cpp にある
• 3D再構成を行うためのキャリブレーションサンプルは opencv_source_code/samples/cpp/build3dmodel.cpp にある
• ステレオキャリブレーションのキャリブレーション例は opencv_source_code/samples/cpp/stereo_calib.cpp にある
• ステレオマッチングのキャリブレーション例は opencv_source_code/samples/cpp/stereo_match.cpp にある
• （Python）カメラキャリブレーションのサンプルは opencv_source_code/samples/python/calibrate.py にある

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

型定義
typedef CirclesGridFinderParameters	cv::CirclesGridFinderParameters2

列挙型
enum	{   cv::LMEDS = 4 ,   cv::RANSAC = 8 ,   cv::RHO = 16 ,   cv::USAC_DEFAULT = 32 ,   cv::USAC_PARALLEL = 33 ,   cv::USAC_FM_8PTS = 34 ,   cv::USAC_FAST = 35 ,   cv::USAC_ACCURATE = 36 ,   cv::USAC_PROSAC = 37 ,   cv::USAC_MAGSAC = 38 }
	ロバスト推定アルゴリズムの種類 続き...
enum	{   cv::CALIB_CB_ADAPTIVE_THRESH = 1 ,   cv::CALIB_CB_NORMALIZE_IMAGE = 2 ,   cv::CALIB_CB_FILTER_QUADS = 4 ,   cv::CALIB_CB_FAST_CHECK = 8 ,   cv::CALIB_CB_EXHAUSTIVE = 16 ,   cv::CALIB_CB_ACCURACY = 32 ,   cv::CALIB_CB_LARGER = 64 ,   cv::CALIB_CB_MARKER = 128 ,   cv::CALIB_CB_PLAIN = 256 }
enum	{   cv::CALIB_CB_SYMMETRIC_GRID = 1 ,   cv::CALIB_CB_ASYMMETRIC_GRID = 2 ,   cv::CALIB_CB_CLUSTERING = 4 }
enum	{   cv::CALIB_NINTRINSIC = 18 ,   cv::CALIB_USE_INTRINSIC_GUESS = 0x00001 ,   cv::CALIB_FIX_ASPECT_RATIO = 0x00002 ,   cv::CALIB_FIX_PRINCIPAL_POINT = 0x00004 ,   cv::CALIB_ZERO_TANGENT_DIST = 0x00008 ,   cv::CALIB_FIX_FOCAL_LENGTH = 0x00010 ,   cv::CALIB_FIX_K1 = 0x00020 ,   cv::CALIB_FIX_K2 = 0x00040 ,   cv::CALIB_FIX_K3 = 0x00080 ,   cv::CALIB_FIX_K4 = 0x00800 ,   cv::CALIB_FIX_K5 = 0x01000 ,   cv::CALIB_FIX_K6 = 0x02000 ,   cv::CALIB_RATIONAL_MODEL = 0x04000 ,   cv::CALIB_THIN_PRISM_MODEL = 0x08000 ,   cv::CALIB_FIX_S1_S2_S3_S4 = 0x10000 ,   cv::CALIB_TILTED_MODEL = 0x40000 ,   cv::CALIB_FIX_TAUX_TAUY = 0x80000 ,   cv::CALIB_USE_QR = 0x100000 ,   cv::CALIB_FIX_TANGENT_DIST = 0x200000 ,   cv::CALIB_FIX_INTRINSIC = 0x00100 ,   cv::CALIB_SAME_FOCAL_LENGTH = 0x00200 ,   cv::CALIB_ZERO_DISPARITY = 0x00400 ,   cv::CALIB_USE_LU = (1 << 17) ,   cv::CALIB_USE_EXTRINSIC_GUESS = (1 << 22) }
enum	{   cv::FM_7POINT = 1 ,   cv::FM_8POINT = 2 ,   cv::FM_LMEDS = 4 ,   cv::FM_RANSAC = 8 }
	基礎行列を求めるアルゴリズム 続き...
enum	cv::HandEyeCalibrationMethod {   cv::CALIB_HAND_EYE_TSAI = 0 ,   cv::CALIB_HAND_EYE_PARK = 1 ,   cv::CALIB_HAND_EYE_HORAUD = 2 ,   cv::CALIB_HAND_EYE_ANDREFF = 3 ,   cv::CALIB_HAND_EYE_DANIILIDIS = 4 }
enum	cv::LocalOptimMethod {   cv::LOCAL_OPTIM_NULL =0 ,   cv::LOCAL_OPTIM_INNER_LO =1 ,   cv::LOCAL_OPTIM_INNER_AND_ITER_LO =2 ,   cv::LOCAL_OPTIM_GC =3 ,   cv::LOCAL_OPTIM_SIGMA =4 }
enum	cv::NeighborSearchMethod {   cv::NEIGH_FLANN_KNN =0 ,   cv::NEIGH_GRID =1 ,   cv::NEIGH_FLANN_RADIUS =2 }
enum	cv::PolishingMethod {   cv::NONE_POLISHER =0 ,   cv::LSQ_POLISHER =1 ,   cv::MAGSAC =2 ,   cv::COV_POLISHER =3 }
enum	cv::RobotWorldHandEyeCalibrationMethod {   cv::CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0 ,   cv::CALIB_ROBOT_WORLD_HAND_EYE_LI = 1 }
enum	cv::SamplingMethod {   cv::SAMPLING_UNIFORM =0 ,   cv::SAMPLING_PROGRESSIVE_NAPSAC =1 ,   cv::SAMPLING_NAPSAC =2 ,   cv::SAMPLING_PROSAC =3 }
enum	cv::ScoreMethod {   cv::SCORE_METHOD_RANSAC =0 ,   cv::SCORE_METHOD_MSAC =1 ,   cv::SCORE_METHOD_MAGSAC =2 ,   cv::SCORE_METHOD_LMEDS =3 }
enum	cv::SolvePnPMethod {   cv::SOLVEPNP_ITERATIVE = 0 ,   cv::SOLVEPNP_EPNP = 1 ,   cv::SOLVEPNP_P3P = 2 ,   cv::SOLVEPNP_DLS = 3 ,   cv::SOLVEPNP_UPNP = 4 ,   cv::SOLVEPNP_AP3P = 5 ,   cv::SOLVEPNP_IPPE = 6 ,   cv::SOLVEPNP_IPPE_SQUARE = 7 ,   cv::SOLVEPNP_SQPNP = 8 }
enum	cv::UndistortTypes {   cv::PROJ_SPHERICAL_ORTHO = 0 ,   cv::PROJ_SPHERICAL_EQRECT = 1 }
	cv::undistort モード 続き...

関数
double	cv::calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
double	cv::calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
	キャリブレーションパターンを複数の視点から撮影した画像から、カメラの内部パラメータと外部パラメータを求める。
double	cv::calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
double	cv::calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray stdDeviationsObjPoints, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
	キャリブレーションパターンを複数の視点から撮影した画像から、カメラの内部パラメータと外部パラメータを求める。
void	cv::calibrateHandEye (InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base, InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam, OutputArray R_cam2gripper, OutputArray t_cam2gripper, HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI)
	ハンドアイキャリブレーションを計算する: \(_{}^{g}\textrm{T}_c\)。
void	cv::calibrateRobotWorldHandEye (InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam, InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper, OutputArray R_base2world, OutputArray t_base2world, OutputArray R_gripper2cam, OutputArray t_gripper2cam, RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH)
	ロボットワールド/ハンドアイキャリブレーションを計算する: \(_{}^{w}\textrm{T}_b\) および \(_{}^{c}\textrm{T}_g\)。
void	cv::calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio)
	カメラの内部行列から有用なカメラ特性を計算する。
bool	cv::checkChessboard (InputArray img, Size size)
void	cv::composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray())
	2つの回転・並進変換を合成する。
void	cv::computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines)
	ステレオペアの一方の画像中の点について、もう一方の画像における対応するエピポーラ線を計算する。
void	cv::convertPointsFromHomogeneous (InputArray src, OutputArray dst)
	点を同次座標からユークリッド空間へ変換する。
void	cv::convertPointsHomogeneous (InputArray src, OutputArray dst)
	点を同次座標に対して相互に変換する。
void	cv::convertPointsToHomogeneous (InputArray src, OutputArray dst)
	点をユークリッド空間から同次座標空間へ変換する。
void	cv::correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
	対応する点の座標を精緻化する。
void	cv::decomposeEssentialMat (InputArray E, OutputArray R1, OutputArray R2, OutputArray t)
	基本行列を、取り得る回転と並進に分解する。
int	cv::decomposeHomographyMat (InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
	ホモグラフィ行列を、回転・並進・平面法線に分解する。
void	cv::decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray())
	射影行列を回転行列とカメラ内部行列に分解する。
void	cv::drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
	検出されたチェスボードのコーナーを描画する。
void	cv::drawFrameAxes (InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3)
	姿勢推定結果から、ワールド/物体座標系の座標軸を描画する。
cv::Mat	cv::estimateAffine2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
	2つの2D点群の間で最適なアフィン変換を計算する。
cv::Mat	cv::estimateAffine2D (InputArray pts1, InputArray pts2, OutputArray inliers, const UsacParams &params)
cv::Mat	cv::estimateAffine3D (InputArray src, InputArray dst, double *scale=nullptr, bool force_rotation=true)
	2つの3D点群の間で最適なアフィン変換を計算する。
int	cv::estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
	2つの3D点群の間で最適なアフィン変換を計算する。
cv::Mat	cv::estimateAffinePartial2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
	2つの2D点群の間で、4自由度の最適な制限付きアフィン変換を計算する。
Scalar	cv::estimateChessboardSharpness (InputArray image, Size patternSize, InputArray corners, float rise_distance=0.8F, bool vertical=false, OutputArray sharpness=noArray())
	検出されたチェスボードの鮮鋭度を推定する。
cv::Vec2d	cv::estimateTranslation2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=0)
	2つの2D点群の間の純粋な2D並進を計算する。
int	cv::estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
	2つの3D点群の間で最適な並進を計算する。
void	cv::filterHomographyDecompByVisibleRefpoints (InputArrayOfArrays rotations, InputArrayOfArrays normals, InputArray beforePoints, InputArray afterPoints, OutputArray possibleSolutions, InputArray pointsMask=noArray())
	追加情報に基づいてホモグラフィ分解の結果を絞り込む。
void	cv::filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
	視差マップ中の小さなノイズの塊（スペックル）を除去する。
bool	cv::find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size)
	チェスボードコーナーのサブピクセル精度の位置を求める
bool	cv::findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
	チェスボードの内部コーナーの位置を求める。
bool	cv::findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags, OutputArray meta)
	セクタベースのアプローチを用いてチェスボードの内部コーナーの位置を求める。
bool	cv::findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags=0)
bool	cv::findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters &parameters)
	円のグリッド中の中心を求める。
bool	cv::findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=SimpleBlobDetector::create())
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, double focal, Point2d pp, int method, double prob, double threshold, OutputArray mask)
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, double focal=1.0, Point2d pp=Point2d(0, 0), int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method, double prob, double threshold, OutputArray mask)
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
	2枚の画像中の対応点から基本行列を計算する。
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray cameraMatrix2, InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask, const UsacParams &params)
Mat	cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, int method=RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray())
	場合によっては異なる2台のカメラからの2枚の画像中の対応点から基本行列を計算する。
Mat	cv::findFundamentalMat (InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
	2枚の画像中の対応点から基礎行列を計算する。
Mat	cv::findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99, OutputArray mask=noArray())
Mat	cv::findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, const UsacParams &params)
Mat	cv::findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99)
Mat	cv::findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray(), const int maxIters=2000, const double confidence=0.995)
	2つの平面の間の透視変換を求める。
Mat	cv::findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, const UsacParams &params)
Mat	cv::findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3)
Mat	cv::getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
	デフォルトの新しいカメラ行列を返す。
Mat	cv::getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), Rect *validPixROI=0, bool centerPrincipalPoint=false)
	自由スケーリングパラメータに基づく新しいカメラ内部行列を返す。
Rect	cv::getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
	整列後の画像の有効なROI（stereoRectify によって返される）から有効な視差ROIを計算する
Mat	cv::initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0)
	3D-2D点対応から初期カメラ内部行列を求める。
void	cv::initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)
	射影および逆整列変換マップを計算する。本質的には、これはプロジェクタ・カメラ対におけるプロジェクタ（「逆カメラ」）のステレオ整列に対応するための initUndistortRectifyMap の逆変換である。
void	cv::initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
	歪み補正および矯正変換マップを計算する。
float	cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
	広角向けに remap 用のマップを初期化する
static float	cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha=0)
void	cv::matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
	乗算される各行列について、行列積の偏微分を計算する。
void	cv::projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0)
	3D点を画像平面へ射影する。
int	cv::recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, double distanceThresh, InputOutputArray mask=noArray(), OutputArray triangulatedPoints=noArray())
int	cv::recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray())
	推定された基本行列と2枚の画像中の対応点から、相対的なカメラ回転と並進を、カイラリティチェックを用いて復元する。チェックを通過したインライアの数を返す。
int	cv::recoverPose (InputArray E, InputArray points1, InputArray points2, OutputArray R, OutputArray t, double focal=1.0, Point2d pp=Point2d(0, 0), InputOutputArray mask=noArray())
int	cv::recoverPose (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, OutputArray E, OutputArray R, OutputArray t, int method=cv::RANSAC, double prob=0.999, double threshold=1.0, InputOutputArray mask=noArray())
	異なる2台のカメラからの2枚の画像中の対応点から、相対的なカメラ回転と並進を、カイラリティチェックを用いて復元する。チェックを通過したインライアの数を返す。
float	cv::rectify3Collinear (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, Rect *roi1, Rect *roi2, int flags)
	3眼カメラ（すべての眼が同一直線上にある）の矯正変換を計算する。
void	cv::reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
	視差画像を3D空間へ再投影する。
void	cv::Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray())
	回転行列を回転ベクトルへ、あるいはその逆へ変換する。
Vec3d	cv::RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
	3x3 行列の RQ 分解を計算する。
double	cv::sampsonDistance (InputArray pt1, InputArray pt2, InputArray F)
	2点間の Sampson 距離を計算する。
int	cv::solveP3P (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags)
	3 組の 3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。
bool	cv::solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=SOLVEPNP_ITERATIVE)
	3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める:
int	cv::solvePnPGeneric (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, bool useExtrinsicGuess=false, SolvePnPMethod flags=SOLVEPNP_ITERATIVE, InputArray rvec=noArray(), InputArray tvec=noArray(), OutputArray reprojectionError=noArray())
	3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。
bool	cv::solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, double confidence=0.99, OutputArray inliers=noArray(), int flags=SOLVEPNP_ITERATIVE)
	RANSAC 方式を用いて誤マッチを処理しながら、3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。
bool	cv::solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputOutputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, OutputArray inliers, const UsacParams &params=UsacParams())
void	cv::solvePnPRefineLM (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON))
	3D-2D 点対応から、初期解を出発点として姿勢（物体座標系で表された3D点をカメラ座標系へ変換する並進と回転）を精緻化する。
void	cv::solvePnPRefineVVS (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON), double VVSlambda=1)
	3D-2D 点対応から、初期解を出発点として姿勢（物体座標系で表された3D点をカメラ座標系へ変換する並進と回転）を精緻化する。
double	cv::stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
	これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは受け取る引数のみが異なる。
double	cv::stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
	ステレオカメラのセットアップをキャリブレーションする。この関数は、2台のカメラそれぞれの内部パラメータと、2台のカメラ間の外部パラメータを求める。
double	cv::stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
	これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは受け取る引数のみが異なる。
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=CALIB_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::triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D)
	この関数は、ステレオカメラによる観測値を用いて3次元点（同次座標）を再構成する。
void	cv::undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
	レンズ歪みを補正するために画像を変換する。
void	cv::undistortImagePoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, TermCriteria=TermCriteria(TermCriteria::MAX_ITER, 5, 0.01))
	歪み補正後の画像点の位置を計算する。
void	cv::undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray P, TermCriteria criteria)
void	cv::undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
	観測された点座標から理想的な点座標を計算する。
void	cv::validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
	左右チェックを用いて視差を検証する。行列 "cost" はステレオ対応アルゴリズムによって計算されている必要がある

型定義詳解

CirclesGridFinderParameters2

typedef CirclesGridFinderParameters cv::CirclesGridFinderParameters2

#include <opencv2/calib3d.hpp>

列挙型詳解

anonymous enum

anonymous enum

#include <opencv2/calib3d.hpp>

ロバスト推定アルゴリズムの種類

列挙値
LMEDS  Python: cv.LMEDS	最小メジアン二乗法アルゴリズム
RANSAC  Python: cv.RANSAC	RANSAC アルゴリズム。
RHO  Python: cv.RHO	RHO アルゴリズム。
USAC_DEFAULT  Python: cv.USAC_DEFAULT	USAC アルゴリズム、デフォルト設定。
USAC_PARALLEL  Python: cv.USAC_PARALLEL	USAC、並列版。
USAC_FM_8PTS  Python: cv.USAC_FM_8PTS	USAC、基礎行列8点法。
USAC_FAST  Python: cv.USAC_FAST	USAC、高速設定。
USAC_ACCURATE  Python: cv.USAC_ACCURATE	USAC、高精度設定。
USAC_PROSAC  Python: cv.USAC_PROSAC	USAC、ソート済みの点、PROSAC を実行。
USAC_MAGSAC  Python: cv.USAC_MAGSAC	USAC、MAGSAC++ を実行。

anonymous enum

anonymous enum

#include <opencv2/calib3d.hpp>

列挙値
CALIB_CB_ADAPTIVE_THRESH  Python: cv.CALIB_CB_ADAPTIVE_THRESH
CALIB_CB_NORMALIZE_IMAGE  Python: cv.CALIB_CB_NORMALIZE_IMAGE
CALIB_CB_FILTER_QUADS  Python: cv.CALIB_CB_FILTER_QUADS
CALIB_CB_FAST_CHECK  Python: cv.CALIB_CB_FAST_CHECK
CALIB_CB_EXHAUSTIVE  Python: cv.CALIB_CB_EXHAUSTIVE
CALIB_CB_ACCURACY  Python: cv.CALIB_CB_ACCURACY
CALIB_CB_LARGER  Python: cv.CALIB_CB_LARGER
CALIB_CB_MARKER  Python: cv.CALIB_CB_MARKER
CALIB_CB_PLAIN  Python: cv.CALIB_CB_PLAIN

anonymous enum

anonymous enum

#include <opencv2/calib3d.hpp>

列挙値
CALIB_CB_SYMMETRIC_GRID  Python: cv.CALIB_CB_SYMMETRIC_GRID
CALIB_CB_ASYMMETRIC_GRID  Python: cv.CALIB_CB_ASYMMETRIC_GRID
CALIB_CB_CLUSTERING  Python: cv.CALIB_CB_CLUSTERING

anonymous enum

anonymous enum

#include <opencv2/calib3d.hpp>

列挙値
CALIB_NINTRINSIC  Python: cv.CALIB_NINTRINSIC
CALIB_USE_INTRINSIC_GUESS  Python: cv.CALIB_USE_INTRINSIC_GUESS
CALIB_FIX_ASPECT_RATIO  Python: cv.CALIB_FIX_ASPECT_RATIO
CALIB_FIX_PRINCIPAL_POINT  Python: cv.CALIB_FIX_PRINCIPAL_POINT
CALIB_ZERO_TANGENT_DIST  Python: cv.CALIB_ZERO_TANGENT_DIST
CALIB_FIX_FOCAL_LENGTH  Python: cv.CALIB_FIX_FOCAL_LENGTH
CALIB_FIX_K1  Python: cv.CALIB_FIX_K1
CALIB_FIX_K2  Python: cv.CALIB_FIX_K2
CALIB_FIX_K3  Python: cv.CALIB_FIX_K3
CALIB_FIX_K4  Python: cv.CALIB_FIX_K4
CALIB_FIX_K5  Python: cv.CALIB_FIX_K5
CALIB_FIX_K6  Python: cv.CALIB_FIX_K6
CALIB_RATIONAL_MODEL  Python: cv.CALIB_RATIONAL_MODEL
CALIB_THIN_PRISM_MODEL  Python: cv.CALIB_THIN_PRISM_MODEL
CALIB_FIX_S1_S2_S3_S4  Python: cv.CALIB_FIX_S1_S2_S3_S4
CALIB_TILTED_MODEL  Python: cv.CALIB_TILTED_MODEL
CALIB_FIX_TAUX_TAUY  Python: cv.CALIB_FIX_TAUX_TAUY
CALIB_USE_QR  Python: cv.CALIB_USE_QR	解法に SVD 分解の代わりに QR を使用する。高速だが精度が劣る可能性がある
CALIB_FIX_TANGENT_DIST  Python: cv.CALIB_FIX_TANGENT_DIST
CALIB_FIX_INTRINSIC  Python: cv.CALIB_FIX_INTRINSIC
CALIB_SAME_FOCAL_LENGTH  Python: cv.CALIB_SAME_FOCAL_LENGTH
CALIB_ZERO_DISPARITY  Python: cv.CALIB_ZERO_DISPARITY
CALIB_USE_LU  Python: cv.CALIB_USE_LU	解法に SVD 分解の代わりに LU を使用する。はるかに高速だが精度が劣る可能性がある
CALIB_USE_EXTRINSIC_GUESS  Python: cv.CALIB_USE_EXTRINSIC_GUESS	stereoCalibrate 用

anonymous enum

anonymous enum

#include <opencv2/calib3d.hpp>

基礎行列を求めるアルゴリズム

列挙値
FM_7POINT  Python: cv.FM_7POINT	7点法
FM_8POINT  Python: cv.FM_8POINT	8点法
FM_LMEDS  Python: cv.FM_LMEDS	最小メジアン法。7点法が使用される。
FM_RANSAC  Python: cv.FM_RANSAC	RANSAC アルゴリズム。少なくとも15点が必要。7点法が使用される。

HandEyeCalibrationMethod

enum cv::HandEyeCalibrationMethod

#include <opencv2/calib3d.hpp>

列挙値
CALIB_HAND_EYE_TSAI  Python: cv.CALIB_HAND_EYE_TSAI	完全に自律的かつ効率的な3Dロボティクスのハンド/アイキャリブレーションのための新手法 [280]。
CALIB_HAND_EYE_PARK  Python: cv.CALIB_HAND_EYE_PARK	ロボットセンサキャリブレーション: ユークリッド群上で AX = XB を解く [219]。
CALIB_HAND_EYE_HORAUD  Python: cv.CALIB_HAND_EYE_HORAUD	ハンドアイキャリブレーション [130]。
CALIB_HAND_EYE_ANDREFF  Python: cv.CALIB_HAND_EYE_ANDREFF	オンラインハンドアイキャリブレーション [14]。
CALIB_HAND_EYE_DANIILIDIS  Python: cv.CALIB_HAND_EYE_DANIILIDIS	双対四元数を用いたハンドアイキャリブレーション [68]。

LocalOptimMethod

enum cv::LocalOptimMethod

#include <opencv2/calib3d.hpp>

列挙値
LOCAL_OPTIM_NULL  Python: cv.LOCAL_OPTIM_NULL
LOCAL_OPTIM_INNER_LO  Python: cv.LOCAL_OPTIM_INNER_LO
LOCAL_OPTIM_INNER_AND_ITER_LO  Python: cv.LOCAL_OPTIM_INNER_AND_ITER_LO
LOCAL_OPTIM_GC  Python: cv.LOCAL_OPTIM_GC
LOCAL_OPTIM_SIGMA  Python: cv.LOCAL_OPTIM_SIGMA

NeighborSearchMethod

enum cv::NeighborSearchMethod

#include <opencv2/calib3d.hpp>

列挙値
NEIGH_FLANN_KNN  Python: cv.NEIGH_FLANN_KNN
NEIGH_GRID  Python: cv.NEIGH_GRID
NEIGH_FLANN_RADIUS  Python: cv.NEIGH_FLANN_RADIUS

PolishingMethod

enum cv::PolishingMethod

#include <opencv2/calib3d.hpp>

列挙値
NONE_POLISHER  Python: cv.NONE_POLISHER
LSQ_POLISHER  Python: cv.LSQ_POLISHER
MAGSAC  Python: cv.MAGSAC
COV_POLISHER  Python: cv.COV_POLISHER

RobotWorldHandEyeCalibrationMethod

enum cv::RobotWorldHandEyeCalibrationMethod

#include <opencv2/calib3d.hpp>

列挙値
CALIB_ROBOT_WORLD_HAND_EYE_SHAH  Python: cv.CALIB_ROBOT_WORLD_HAND_EYE_SHAH	クロネッカー積を用いたロボットワールド/ハンドアイキャリブレーション問題の解法 [250]。
CALIB_ROBOT_WORLD_HAND_EYE_LI  Python: cv.CALIB_ROBOT_WORLD_HAND_EYE_LI	双対四元数とクロネッカー積を用いた同時ロボットワールドおよびハンドアイキャリブレーション [168]。

SamplingMethod

enum cv::SamplingMethod

#include <opencv2/calib3d.hpp>

列挙値
SAMPLING_UNIFORM  Python: cv.SAMPLING_UNIFORM
SAMPLING_PROGRESSIVE_NAPSAC  Python: cv.SAMPLING_PROGRESSIVE_NAPSAC
SAMPLING_NAPSAC  Python: cv.SAMPLING_NAPSAC
SAMPLING_PROSAC  Python: cv.SAMPLING_PROSAC

ScoreMethod

enum cv::ScoreMethod

#include <opencv2/calib3d.hpp>

列挙値
SCORE_METHOD_RANSAC  Python: cv.SCORE_METHOD_RANSAC
SCORE_METHOD_MSAC  Python: cv.SCORE_METHOD_MSAC
SCORE_METHOD_MAGSAC  Python: cv.SCORE_METHOD_MAGSAC
SCORE_METHOD_LMEDS  Python: cv.SCORE_METHOD_LMEDS

SolvePnPMethod

enum cv::SolvePnPMethod

#include <opencv2/calib3d.hpp>

列挙値
SOLVEPNP_ITERATIVE  Python: cv.SOLVEPNP_ITERATIVE	非線形 Levenberg-Marquardt 最小化スキームを用いた姿勢の精緻化 [184] [81] 非平面の "objectPoints" に対する初期解には少なくとも6点が必要で、DLT アルゴリズムを使用する。 平面の "objectPoints" に対する初期解には少なくとも4点が必要で、ホモグラフィ分解から得られる姿勢を使用する。
SOLVEPNP_EPNP  Python: cv.SOLVEPNP_EPNP	EPnP: 効率的な Perspective-n-Point カメラ姿勢推定 [163]。
SOLVEPNP_P3P  Python: cv.SOLVEPNP_P3P	P3P 問題の再検討 [73]。
SOLVEPNP_DLS  Python: cv.SOLVEPNP_DLS	実装が不完全。このフラグを使用すると EPnP にフォールバックする。 PnP のための直接最小二乗（DLS）法 [128]
SOLVEPNP_UPNP  Python: cv.SOLVEPNP_UPNP	実装が不完全。このフラグを使用すると EPnP にフォールバックする。 ロバストなカメラ姿勢と焦点距離推定のための網羅的線形化 [220]
SOLVEPNP_AP3P  Python: cv.SOLVEPNP_AP3P	Perspective-Three-Point 問題に対する効率的な代数的解法 [150]。
SOLVEPNP_IPPE  Python: cv.SOLVEPNP_IPPE	微小平面ベースの姿勢推定 [64] オブジェクト点は同一平面上になければならない。
SOLVEPNP_IPPE_SQUARE  Python: cv.SOLVEPNP_IPPE_SQUARE	微小平面ベースの姿勢推定 [64] これはマーカー姿勢推定に適した特殊なケースである。 4つの同一平面上のオブジェクト点を次の順序で定義しなければならない: 点 0: [-squareLength / 2, squareLength / 2, 0] 点 1: [ squareLength / 2, squareLength / 2, 0] 点 2: [ squareLength / 2, -squareLength / 2, 0] 点 3: [-squareLength / 2, -squareLength / 2, 0]
SOLVEPNP_SQPNP  Python: cv.SOLVEPNP_SQPNP	SQPnP: Perspective-n-Point 問題に対する一貫して高速かつ大域的に最適な解法 [274]。

UndistortTypes

enum cv::UndistortTypes

#include <opencv2/calib3d.hpp>

cv::undistort モード

列挙値
PROJ_SPHERICAL_ORTHO  Python: cv.PROJ_SPHERICAL_ORTHO
PROJ_SPHERICAL_EQRECT  Python: cv.PROJ_SPHERICAL_EQRECT

関数詳解

calibrateCamera() [1/2]

double cv::calibrateCamera	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints,
		Size	imageSize,
		InputOutputArray	cameraMatrix,
		InputOutputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		int	flags = 0,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) )

Python:
	cv.calibrateCamera(	objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs
	cv.calibrateCameraExtended(	objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

calibrateCamera() [2/2]

double cv::calibrateCamera	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints,
		Size	imageSize,
		InputOutputArray	cameraMatrix,
		InputOutputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		OutputArray	stdDeviationsIntrinsics,
		OutputArray	stdDeviationsExtrinsics,
		OutputArray	perViewErrors,
		int	flags = 0,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) )

Python:
	cv.calibrateCamera(	objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs
	cv.calibrateCameraExtended(	objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors

#include <opencv2/calib3d.hpp>

キャリブレーションパターンの複数のビューからカメラの内部パラメータと外部パラメータを求める。

引数

objectPoints	新しいインターフェースでは、これはキャリブレーションパターン座標空間におけるキャリブレーションパターン点のベクトルのベクトルである（例: std::vector<std::vector<cv::Vec3f>>）。外側のベクトルはパターンビューの数だけ要素を持つ。各ビューで同じキャリブレーションパターンが示され、それが完全に見えている場合、すべてのベクトルは同一になる。ただし、部分的に隠れたパターンや、ビューごとに異なるパターンを使用することも可能であり、その場合ベクトルは異なるものになる。点は3Dであるが、使用するキャリブレーションパターンが平面リグであれば、それらはすべてキャリブレーションパターンの XY 座標平面上にある（したがって Z 座標は 0 である）。古いインターフェースでは、異なるビューからのオブジェクト点のすべてのベクトルが連結される。
imagePoints	新しいインターフェースでは、これはキャリブレーションパターン点の投影のベクトルのベクトルである（例: std::vector<std::vector<cv::Vec2f>>）。imagePoints.size() と objectPoints.size() は等しく、各 i について imagePoints[i].size() と objectPoints[i].size() もそれぞれ等しくなければならない。古いインターフェースでは、異なるビューからのオブジェクト点のすべてのベクトルが連結される。
imageSize	カメラ内部行列の初期化にのみ使用される画像のサイズ。
cameraMatrix	入出力の 3x3 浮動小数点カメラ内部行列 \(\cameramatrix{A}\) 。CALIB_USE_INTRINSIC_GUESS および／または CALIB_FIX_ASPECT_RATIO、CALIB_FIX_PRINCIPAL_POINT、CALIB_FIX_FOCAL_LENGTH が指定されている場合、fx, fy, cx, cy の一部またはすべてを関数呼び出し前に初期化しておく必要がある。
distCoeffs	入出力の歪み係数ベクトル \(\distcoeffs\)。
rvecs	各パターンビューについて推定された回転ベクトル（Rodrigues ）の出力ベクトル（例: std::vector<cv::Mat>>）。すなわち、各 i 番目の回転ベクトルは、対応する i 番目の並進ベクトル（次の出力パラメータの説明を参照）とともに、キャリブレーションパターンをオブジェクト座標空間（オブジェクト点が指定される空間）からカメラ座標空間へと移す。より技術的には、i 番目の回転ベクトルと並進ベクトルの組は、オブジェクト座標空間からカメラ座標空間への基底変換を行う。その双対性により、この組はカメラ座標空間に対するキャリブレーションパターンの位置と等価である。
tvecs	各パターンビューについて推定された並進ベクトルの出力ベクトル。上記のパラメータの説明を参照。
stdDeviationsIntrinsics	内部パラメータについて推定された標準偏差の出力ベクトル。偏差値の順序: \((f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\) いずれかのパラメータが推定されない場合、その偏差は 0 になる。
stdDeviationsExtrinsics	外部パラメータについて推定された標準偏差の出力ベクトル。偏差値の順序: \((R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})\) ここで M はパターンビューの数である。\(R_i, T_i\) は連結された 1x3 ベクトルである。
perViewErrors	各パターンビューについて推定された RMS 再投影誤差の出力ベクトル。
flags	0、または以下の値の組み合わせを取りうる各種フラグ: CALIB_USE_INTRINSIC_GUESS cameraMatrix が、さらに最適化される fx, fy, cx, cy の有効な初期値を含む。そうでなければ、(cx, cy) は最初に画像中心に設定され（imageSize が使用される）、焦点距離は最小二乗法で計算される。なお、内部パラメータが既知であれば、外部パラメータの推定のためだけにこの関数を使う必要はない。代わりに solvePnP を使用すること。 CALIB_FIX_PRINCIPAL_POINT グローバル最適化の間、主点は変更されない。主点は中心、または CALIB_USE_INTRINSIC_GUESS も設定されている場合に指定された別の位置に留まる。 CALIB_FIX_ASPECT_RATIO 関数は fy のみを自由パラメータとみなす。比 fx/fy は入力 cameraMatrix と同じに保たれる。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、fx と fy の実際の入力値は無視され、それらの比のみが計算されて以降使用される。 CALIB_ZERO_TANGENT_DIST 接線方向の歪み係数 \((p_1, p_2)\) は 0 に設定され、0 のまま保たれる。 CALIB_FIX_FOCAL_LENGTH CALIB_USE_INTRINSIC_GUESS が設定されている場合、グローバル最適化の間、焦点距離は変更されない。 CALIB_FIX_K1,..., CALIB_FIX_K6 対応する半径方向の歪み係数は最適化の間変更されない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでなければ 0 に設定される。 CALIB_RATIONAL_MODEL 係数 k4, k5, k6 が有効になる。後方互換性を保つため、キャリブレーション関数に有理モデルを使用させて 8 個以上の係数を返させるには、この追加フラグを明示的に指定する必要がある。 CALIB_THIN_PRISM_MODEL 係数 s1, s2, s3, s4 が有効になる。後方互換性を保つため、キャリブレーション関数に薄プリズムモデルを使用させて 12 個以上の係数を返させるには、この追加フラグを明示的に指定する必要がある。 CALIB_FIX_S1_S2_S3_S4 薄プリズムの歪み係数は最適化の間変更されない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでなければ 0 に設定される。 CALIB_TILTED_MODEL 係数 tauX と tauY が有効になる。後方互換性を保つため、キャリブレーション関数に傾斜センサモデルを使用させて 14 個の係数を返させるには、この追加フラグを明示的に指定する必要がある。 CALIB_FIX_TAUX_TAUY 傾斜センサモデルの係数は最適化の間変更されない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでなければ 0 に設定される。
criteria	反復最適化アルゴリズムの終了条件。

戻り値

全体のRMS再投影誤差。

この関数は、各ビューに対してカメラの内部パラメータと外部パラメータを推定する。アルゴリズムは [324] と [39] に基づく。各ビューにおける3Dオブジェクト点の座標と、それに対応する2D投影を指定しなければならない。これは、既知のジオメトリと容易に検出可能な特徴点をもつオブジェクトを使うことで達成できる。そのようなオブジェクトはキャリブレーションリグまたはキャリブレーションパターンと呼ばれ、OpenCVはキャリブレーションリグとしてのチェスボードを組み込みでサポートしている (findChessboardCorners を参照)。現在、内部パラメータの初期化 (CALIB_USE_INTRINSIC_GUESS が設定されていない場合) は、平面キャリブレーションパターン (オブジェクト点のZ座標がすべてゼロでなければならない) に対してのみ実装されている。初期 cameraMatrix が与えられていれば、3Dキャリブレーションリグも使用できる。

アルゴリズムは以下のステップを実行する:

• 初期内部パラメータを計算する (このオプションは平面キャリブレーションパターンに対してのみ利用可能)、または入力パラメータから読み取る。CALIB_FIX_K? のいくつかが指定されていない限り、歪み係数は初期値としてすべてゼロに設定される。
• 内部パラメータがすでに既知であるかのように初期カメラ姿勢を推定する。これは solvePnP を使って行われる。
• 大域的なLevenberg-Marquardt最適化アルゴリズムを実行して再投影誤差、すなわち観測された特徴点 imagePoints と投影された (現在のカメラパラメータと姿勢の推定値を用いた) オブジェクト点 objectPoints との二乗距離の総和を最小化する。詳細は projectPoints を参照。

覚え書き

非正方 (すなわち非N×N) のグリッドと findChessboardCorners をキャリブレーションに使用していて、calibrateCamera が不正な値 (歪み係数がゼロ、\(c_x\) と \(c_y\) が画像中心から非常に離れている、かつ/または \(f_x\) と \(f_y\) の間に大きな差 (10:1以上の比率) がある) を返す場合、おそらく findChessboardCorners で patternSize=cvSize(cols,rows) を使う代わりに patternSize=cvSize(rows,cols) を使っている。

サポートされていないパラメータの組み合わせが与えられた場合、またはシステムが拘束不足である場合、この関数は例外をスローすることがある。

参照

calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

calibrateCameraRO() [1/2]

double cv::calibrateCameraRO	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints,
		Size	imageSize,
		int	iFixedPoint,
		InputOutputArray	cameraMatrix,
		InputOutputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		OutputArray	newObjPoints,
		int	flags = 0,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) )

Python:
	cv.calibrateCameraRO(	objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, flags[, criteria]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints
	cv.calibrateCameraROExtended(	objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, stdDeviationsObjPoints[, perViewErrors[, flags[, criteria]]]]]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints, stdDeviationsIntrinsics, stdDeviationsExtrinsics, stdDeviationsObjPoints, perViewErrors

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

calibrateCameraRO() [2/2]

double cv::calibrateCameraRO	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints,
		Size	imageSize,
		int	iFixedPoint,
		InputOutputArray	cameraMatrix,
		InputOutputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		OutputArray	newObjPoints,
		OutputArray	stdDeviationsIntrinsics,
		OutputArray	stdDeviationsExtrinsics,
		OutputArray	stdDeviationsObjPoints,
		OutputArray	perViewErrors,
		int	flags = 0,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) )

Python:
	cv.calibrateCameraRO(	objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, flags[, criteria]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints
	cv.calibrateCameraROExtended(	objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, stdDeviationsObjPoints[, perViewErrors[, flags[, criteria]]]]]]]]]	) ->	retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints, stdDeviationsIntrinsics, stdDeviationsExtrinsics, stdDeviationsObjPoints, perViewErrors

#include <opencv2/calib3d.hpp>

キャリブレーションパターンの複数のビューからカメラの内部パラメータと外部パラメータを求める。

この関数は calibrateCamera の拡張であり、[261] で提案されたオブジェクトリリース法を用いる。不正確で、未計測の、おおよそ平面のターゲット (キャリブレーションプレート) を用いる多くの一般的なケースにおいて、この方法は推定されるカメラパラメータの精度を劇的に向上させることができる。この関数はオブジェクトリリース法と標準法の両方をサポートする。方法の選択にはパラメータ iFixedPoint を使用する。内部実装では、calibrateCamera はこの関数のラッパーである。

引数

objectPoints	キャリブレーションパターン座標空間におけるキャリブレーションパターン点のベクトルのベクトル。詳細は calibrateCamera を参照。オブジェクトリリース法を使用する場合、各ビューで同一のキャリブレーションボードを使用し、それが完全に見えていなければならず、すべての objectPoints[i] が同一で、すべての点が概ね平面に近い必要がある。キャリブレーションターゲットは剛体である必要があり、少なくとも（キャリブレーションターゲットではなく）カメラを動かして画像を取得する場合は静止していなければならない。
imagePoints	キャリブレーションパターン点の投影のベクトルのベクトル。詳細は calibrateCamera を参照。
imageSize	内部カメラ行列の初期化にのみ使用される画像のサイズ。
iFixedPoint	固定する、objectPoints[0] 内の3Dオブジェクト点のインデックス。これはキャリブレーション法の選択を切り替えるスイッチとしても機能する。オブジェクトリリース法を使用する場合は [1, objectPoints[0].size()-2] の範囲でパラメータを渡し、そうでなければこの範囲外の値を渡すと標準キャリブレーション法が選択される。オブジェクトリリース法を利用する際は、通常、キャリブレーションボードグリッドの右上隅の点を固定することが推奨される。[261] によれば、他の2点も固定される。この実装では、objectPoints[0].front と objectPoints[0].back.z が使用される。オブジェクトリリース法では、これら3つの固定点の座標が十分に正確である場合にのみ、正確な rvecs、tvecs、newObjPoints が得られる。
cameraMatrix	出力の 3x3 浮動小数点カメラ行列。詳細は calibrateCamera を参照。
distCoeffs	出力の歪み係数ベクトル。詳細は calibrateCamera を参照。
rvecs	各パターンビューについて推定された回転ベクトルの出力ベクトル。詳細は calibrateCamera を参照。
tvecs	各パターンビューについて推定された並進ベクトルの出力ベクトル。
newObjPoints	更新されたキャリブレーションパターン点の出力ベクトル。座標は3つの固定点に基づいてスケーリングされる場合がある。返される座標は、上記の3つの固定点が正確である場合にのみ正確である。不要な場合は noArray() を渡せばよい。このパラメータは標準キャリブレーション法では無視される。
stdDeviationsIntrinsics	内部パラメータについて推定された標準偏差の出力ベクトル。詳細は calibrateCamera を参照。
stdDeviationsExtrinsics	外部パラメータについて推定された標準偏差の出力ベクトル。詳細は calibrateCamera を参照。
stdDeviationsObjPoints	キャリブレーションパターン点の精緻化された座標について推定された標準偏差の出力ベクトル。objectPoints[0] ベクトルと同じサイズおよび順序を持つ。このパラメータは標準キャリブレーション法では無視される。
perViewErrors	各パターンビューについて推定された RMS 再投影誤差の出力ベクトル。
flags	0、またはいくつかの定義済み値の組み合わせを取りうる各種フラグ。詳細は calibrateCamera を参照。オブジェクトリリース法を使用する場合、キャリブレーション時間がかなり長くなることがある。より高速なキャリブレーションには CALIB_USE_QR または CALIB_USE_LU を使用できるが、精度が低下し、まれに安定性が低下する場合がある。
criteria	反復最適化アルゴリズムの終了条件。

戻り値

全体のRMS再投影誤差。

この関数は、各ビューに対してカメラの内部パラメータと外部パラメータを推定する。アルゴリズムは [324]、[39]、[261] に基づく。その他の詳細な説明については calibrateCamera を参照。

参照

calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

calibrateHandEye()

void cv::calibrateHandEye	(	InputArrayOfArrays	R_gripper2base,
		InputArrayOfArrays	t_gripper2base,
		InputArrayOfArrays	R_target2cam,
		InputArrayOfArrays	t_target2cam,
		OutputArray	R_cam2gripper,
		OutputArray	t_cam2gripper,
		HandEyeCalibrationMethod	method = CALIB_HAND_EYE_TSAI )

Python:
	cv.calibrateHandEye(	R_gripper2base, t_gripper2base, R_target2cam, t_target2cam[, R_cam2gripper[, t_cam2gripper[, method]]]	) ->	R_cam2gripper, t_cam2gripper

#include <opencv2/calib3d.hpp>

ハンドアイキャリブレーションを計算する: \(_{}^{g}\textrm{T}_c\)。

引数

[in]	R_gripper2base	グリッパフレームで表現された点をロボットベースフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{b}\textrm{T}_g\)）。これは、グリッパフレームからロボットベースフレームへのすべての変換について、回転、すなわち (3x3) 回転行列または (3x1) 回転ベクトルを含むベクトル（vector<Mat>）である。
[in]	t_gripper2base	グリッパフレームで表現された点をロボットベースフレームへ変換する同次行列から抽出された並進部分（ \(_{}^{b}\textrm{T}_g\)）。これは、グリッパフレームからロボットベースフレームへのすべての変換についての (3x1) 並進ベクトルを含むベクトル（vector<Mat>）である。
[in]	R_target2cam	ターゲットフレームで表現された点をカメラフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{c}\textrm{T}_t\)）。これは、キャリブレーションターゲットフレームからカメラフレームへのすべての変換について、回転、すなわち (3x3) 回転行列または (3x1) 回転ベクトルを含むベクトル（vector<Mat>）である。
[in]	t_target2cam	ターゲットフレームで表現された点をカメラフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{c}\textrm{T}_t\)）。これは、キャリブレーションターゲットフレームからカメラフレームへのすべての変換についての (3x1) 並進ベクトルを含むベクトル（vector<Mat>）である。
[out]	R_cam2gripper	カメラフレームで表現された点をグリッパフレームへ変換する同次行列から抽出された、推定された (3x3) 回転部分（ \(_{}^{g}\textrm{T}_c\)）。
[out]	t_cam2gripper	カメラフレームで表現された点をグリッパフレームへ変換する同次行列から抽出された、推定された (3x1) 並進部分（ \(_{}^{g}\textrm{T}_c\)）。
[in]	method	実装されているハンドアイキャリブレーション法のいずれか。cv::HandEyeCalibrationMethod を参照。

この関数は、さまざまな手法を用いてハンドアイキャリブレーションを実行する。一つのアプローチは、回転を推定してから並進を推定するもの (分離解) であり、以下の手法が実装されている:

• R. Tsai, R. Lenz 完全自律かつ効率的な3Dロボティクス向けハンド/アイキャリブレーションのための新技術 [280]
• F. Park, B. Martin ロボットセンサキャリブレーション: ユークリッド群上での AX = XB の求解 [219]
• R. Horaud, F. Dornaika ハンドアイキャリブレーション [130]

もう一つのアプローチは、回転と並進を同時に推定するもの (同時解) であり、以下の手法が実装されている:

• N. Andreff, R. Horaud, B. Espiau オンラインハンドアイキャリブレーション [14]
• K. Daniilidis 双対四元数を用いたハンドアイキャリブレーション [68]

以下の図は、ロボットのグリッパ (「ハンド」) に取り付けられたカメラ (「アイ」) の間の変換を推定する必要があるハンドアイキャリブレーション問題を示している。この構成は eye-in-hand と呼ばれる。

eye-to-hand 構成は、ロボットのエンドエフェクタに取り付けられたキャリブレーションパターンを観測する静止カメラから成る。カメラからロボットベースフレームへの変換は、適切な変換を関数に入力することで推定できる。下記を参照。

キャリブレーション手順は以下のとおりである:

• 静止したキャリブレーションパターンを用いて、ターゲットフレームとカメラフレームの間の変換を推定する
• 複数の姿勢を取得するためにロボットのグリッパを動かす
• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics

  \[ \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \]

• for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences

  \[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_t\\ Y_t\\ Z_t\\ 1 \end{bmatrix} \]

ハンドアイキャリブレーション手順は以下の同次変換を返す

\[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \]

この問題は \(\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\) 方程式の求解としても知られている:

• for an eye-in-hand configuration

  \[ \begin{align*} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &= \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \]

• for an eye-to-hand configuration

  \[ \begin{align*} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &= \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \]

覚え書き

追加情報はこのウェブサイトで見つけられる。

ハンドアイ変換を決定するには、平行でない回転軸をもつ最低2つの運動が必要である。したがって最低3つの異なる姿勢が必要だが、はるかに多くの姿勢を使うことが強く推奨される。

calibrateRobotWorldHandEye()

void cv::calibrateRobotWorldHandEye	(	InputArrayOfArrays	R_world2cam,
		InputArrayOfArrays	t_world2cam,
		InputArrayOfArrays	R_base2gripper,
		InputArrayOfArrays	t_base2gripper,
		OutputArray	R_base2world,
		OutputArray	t_base2world,
		OutputArray	R_gripper2cam,
		OutputArray	t_gripper2cam,
		RobotWorldHandEyeCalibrationMethod	method = CALIB_ROBOT_WORLD_HAND_EYE_SHAH )

Python:
	cv.calibrateRobotWorldHandEye(	R_world2cam, t_world2cam, R_base2gripper, t_base2gripper[, R_base2world[, t_base2world[, R_gripper2cam[, t_gripper2cam[, method]]]]]	) ->	R_base2world, t_base2world, R_gripper2cam, t_gripper2cam

#include <opencv2/calib3d.hpp>

ロボット・ワールド/ハンドアイキャリブレーションを計算する: \(_{}^{w}\textrm{T}_b\) と \(_{}^{c}\textrm{T}_g\)。

引数

[in]	R_world2cam	ワールドフレームで表現された点をカメラフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{c}\textrm{T}_w\)）。これは、ワールドフレームからカメラフレームへのすべての変換について、回転、すなわち (3x3) 回転行列または (3x1) 回転ベクトルを含むベクトル（vector<Mat>）である。
[in]	t_world2cam	ワールドフレームで表現された点をカメラフレームへ変換する同次行列から抽出された並進部分（ \(_{}^{c}\textrm{T}_w\)）。これは、ワールドフレームからカメラフレームへのすべての変換についての (3x1) 並進ベクトルを含むベクトル（vector<Mat>）である。
[in]	R_base2gripper	ロボットベースフレームで表現された点をグリッパフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{g}\textrm{T}_b\)）。これは、ロボットベースフレームからグリッパフレームへのすべての変換について、回転、すなわち (3x3) 回転行列または (3x1) 回転ベクトルを含むベクトル（vector<Mat>）である。
[in]	t_base2gripper	ロボットベースフレームで表現された点をグリッパフレームへ変換する同次行列から抽出された回転部分（ \(_{}^{g}\textrm{T}_b\)）。これは、ロボットベースフレームからグリッパフレームへのすべての変換についての (3x1) 並進ベクトルを含むベクトル（vector<Mat>）である。
[out]	R_base2world	ロボットベースフレームで表現された点をワールドフレームへ変換する同次行列から抽出された、推定された (3x3) 回転部分（ \(_{}^{w}\textrm{T}_b\)）。
[out]	t_base2world	ロボットベースフレームで表現された点をワールドフレームへ変換する同次行列から抽出された、推定された (3x1) 並進部分（ \(_{}^{w}\textrm{T}_b\)）。
[out]	R_gripper2cam	グリッパフレームで表現された点をカメラフレームへ変換する同次行列から抽出された、推定された (3x3) 回転部分（ \(_{}^{c}\textrm{T}_g\)）。
[out]	t_gripper2cam	グリッパフレームで表現された点をカメラフレームへ変換する同次行列から抽出された、推定された (3x1) 並進部分（ \(_{}^{c}\textrm{T}_g\)）。
[in]	method	実装されているロボットワールド/ハンドアイキャリブレーション法のいずれか。cv::RobotWorldHandEyeCalibrationMethod を参照。

この関数はさまざまな手法を用いてロボット・ワールド/ハンドアイキャリブレーションを実行する。一つのアプローチは、回転を推定してから並進を推定するもの（分離型の解法）である：

• M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product [250]

もう一つのアプローチは、回転と並進を同時に推定するもの（同時型の解法）であり、次の手法が実装されている：

• A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product [168]

次の図は、ロボットとワールド座標系の間、およびロボットエンドエフェクタに取り付けられたロボットグリッパ（「ハンド」）とカメラ（「アイ」）の間の変換を推定する必要がある、ロボット・ワールド/ハンドアイキャリブレーション問題を表している。

キャリブレーション手順は以下のとおりである:

• 静止したキャリブレーションパターンを用いて、ターゲットフレームとカメラフレームの間の変換を推定する
• 複数の姿勢を取得するためにロボットのグリッパを動かす
• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics

  \[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \]

• for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences

  \[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \]

ロボット・ワールド/ハンドアイキャリブレーションの手続きは、次の同次変換を返す

\[ \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \]

\[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \]

この問題は、次のように \(\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\) 方程式を解く問題としても知られている：

• \(\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\)
• \(\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\)
• \(\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\)
• \(\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\)

覚え書き

少なくとも3つの計測が必要である（入力ベクトルのサイズは3以上でなければならない）。

calibrationMatrixValues()

void cv::calibrationMatrixValues	(	InputArray	cameraMatrix,
		Size	imageSize,
		double	apertureWidth,
		double	apertureHeight,
		double &	fovx,
		double &	fovy,
		double &	focalLength,
		Point2d &	principalPoint,
		double &	aspectRatio )

Python:
	cv.calibrationMatrixValues(	cameraMatrix, imageSize, apertureWidth, apertureHeight	) ->	fovx, fovy, focalLength, principalPoint, aspectRatio

#include <opencv2/calib3d.hpp>

カメラ内部行列から有用なカメラ特性を計算する。

引数

cameraMatrix	calibrateCamera または stereoCalibrate によって推定できる入力カメラ内部行列。
imageSize	入力画像のサイズ（ピクセル単位）。
apertureWidth	センサの物理的な幅（mm 単位）。
apertureHeight	センサの物理的な高さ（mm 単位）。
fovx	センサの水平軸に沿った視野角の出力（度単位）。
fovy	センサの垂直軸に沿った視野角の出力（度単位）。
focalLength	レンズの焦点距離（mm 単位）。
principalPoint	主点（mm 単位）。
aspectRatio	\(f_y/f_x\)

この関数は、あらかじめ推定されたカメラ行列からさまざまな有用なカメラ特性を計算する。

覚え書き

単位 'mm' は、チェスボードのピッチに選んだ任意の計測単位を表すものであることに留意せよ（したがって任意の値を取り得る）。

checkChessboard()

bool cv::checkChessboard	(	InputArray	img,
		Size	size )

Python:
	cv.checkChessboard(	img, size	) ->	retval

#include <opencv2/calib3d.hpp>

composeRT()

void cv::composeRT	(	InputArray	rvec1,
		InputArray	tvec1,
		InputArray	rvec2,
		InputArray	tvec2,
		OutputArray	rvec3,
		OutputArray	tvec3,
		OutputArray	dr3dr1 = noArray(),
		OutputArray	dr3dt1 = noArray(),
		OutputArray	dr3dr2 = noArray(),
		OutputArray	dr3dt2 = noArray(),
		OutputArray	dt3dr1 = noArray(),
		OutputArray	dt3dt1 = noArray(),
		OutputArray	dt3dr2 = noArray(),
		OutputArray	dt3dt2 = noArray() )

Python:
	cv.composeRT(	rvec1, tvec1, rvec2, tvec2[, rvec3[, tvec3[, dr3dr1[, dr3dt1[, dr3dr2[, dr3dt2[, dt3dr1[, dt3dt1[, dt3dr2[, dt3dt2]]]]]]]]]]	) ->	rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2

#include <opencv2/calib3d.hpp>

2つの回転・並進変換を合成する。

引数

rvec1	1番目の回転ベクトル。
tvec1	1番目の並進ベクトル。
rvec2	2番目の回転ベクトル。
tvec2	2番目の並進ベクトル。
rvec3	重ね合わせの出力回転ベクトル。
tvec3	重ね合わせの出力並進ベクトル。
dr3dr1	rvec1 に関する rvec3 の微分の出力（省略可能）
dr3dt1	tvec1 に関する rvec3 の微分の出力（省略可能）
dr3dr2	rvec2 に関する rvec3 の微分の出力（省略可能）
dr3dt2	tvec2 に関する rvec3 の微分の出力（省略可能）
dt3dr1	rvec1 に関する tvec3 の微分の出力（省略可能）
dt3dt1	tvec1 に関する tvec3 の微分の出力（省略可能）
dt3dr2	rvec2 に関する tvec3 の微分の出力（省略可能）
dt3dt2	tvec2 に関する tvec3 の微分の出力（省略可能）

これらの関数は次を計算する：

\[\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\]

ここで \(\mathrm{rodrigues}\) は回転ベクトルから回転行列への変換を表し、\(\mathrm{rodrigues}^{-1}\) はその逆変換を表す。詳細は Rodrigues を参照。

また、これらの関数は入力ベクトルに関する出力ベクトルの微分を計算できる（matMulDeriv を参照）。これらの関数は stereoCalibrate の内部で使用されているが、行列の乗算を含む関数を最適化するためにLevenberg-Marquardt法やその他の勾配ベースのソルバを使用する独自のコードでも利用できる。

computeCorrespondEpilines()

void cv::computeCorrespondEpilines	(	InputArray	points,
		int	whichImage,
		InputArray	F,
		OutputArray	lines )

Python:
	cv.computeCorrespondEpilines(	points, whichImage, F[, lines]	) ->	lines

#include <opencv2/calib3d.hpp>

ステレオペアの一方の画像中の点に対して、もう一方の画像中の対応するエピポーラ線を計算する。

引数

points	入力点。型 CV_32FC2 の \(N \times 1\) もしくは \(1 \times N\) 行列、または vector<Point2f> 。
whichImage	点を含む画像のインデックス（1 または 2）。
F	findFundamentalMat または stereoRectify を用いて推定できる基礎行列。
lines	もう一方の画像中の点に対応するエピポーラ線の出力ベクトル。各直線 \(ax + by + c=0\) は3つの数値 \((a, b, c)\) で表される。

ステレオペアの2枚の画像の一方の各点について、この関数はもう一方の画像中の対応するエピポーラ線の方程式を求める。

基礎行列の定義（findFundamentalMat を参照）より、第1画像中の点 \(p^{(1)}_i\) に対する第2画像中の線 \(l^{(2)}_i\) は（whichImage=1 の場合）次のように計算される：

\[l^{(2)}_i = F p^{(1)}_i\]

逆に、whichImage=2 の場合、\(l^{(1)}_i\) は \(p^{(2)}_i\) から次のように計算される：

\[l^{(1)}_i = F^T p^{(2)}_i\]

線の係数はスケール倍まで定まる。それらは \(a_i^2+b_i^2=1\) となるように正規化される。

convertPointsFromHomogeneous()

void cv::convertPointsFromHomogeneous	(	InputArray	src,
		OutputArray	dst )

Python:
	cv.convertPointsFromHomogeneous(	src[, dst]	) ->	dst

#include <opencv2/calib3d.hpp>

点を同次空間からユークリッド空間に変換する。

引数

src	N次元点の入力ベクトル。
dst	N-1次元点の出力ベクトル。

この関数は、透視投影を用いて点を同次空間からユークリッド空間に変換する。すなわち、各点 (x1, x2, ... x(n-1), xn) は (x1/xn, x2/xn, ..., x(n-1)/xn) に変換される。xn=0 の場合、出力点の座標は (0,0,0,...) となる。

convertPointsHomogeneous()

void cv::convertPointsHomogeneous	(	InputArray	src,
		OutputArray	dst )

#include <opencv2/calib3d.hpp>

点を同次座標との間で変換する。

引数

src	2次元、3次元、または4次元の点の入力配列またはベクトル。
dst	2次元、3次元、または4次元の点の出力ベクトル。

この関数は、convertPointsToHomogeneous または convertPointsFromHomogeneous のいずれかを呼び出すことで、2Dまたは3Dの点を同次座標との間で変換する。

覚え書き

この関数は廃止された。代わりに前述の2つの関数のいずれかを使用すること。

convertPointsToHomogeneous()

void cv::convertPointsToHomogeneous	(	InputArray	src,
		OutputArray	dst )

Python:
	cv.convertPointsToHomogeneous(	src[, dst]	) ->	dst

#include <opencv2/calib3d.hpp>

点をユークリッド空間から同次空間に変換する。

引数

src	N次元点の入力ベクトル。
dst	N+1次元点の出力ベクトル。

この関数は、点の座標タプルに1を付加することで、点をユークリッド空間から同次空間に変換する。すなわち、各点 (x1, x2, ..., xn) は (x1, x2, ..., xn, 1) に変換される。

correctMatches()

void cv::correctMatches	(	InputArray	F,
		InputArray	points1,
		InputArray	points2,
		OutputArray	newPoints1,
		OutputArray	newPoints2 )

Python:
	cv.correctMatches(	F, points1, points2[, newPoints1[, newPoints2]]	) ->	newPoints1, newPoints2

#include <opencv2/calib3d.hpp>

対応する点の座標を精緻化する。

引数

F	3x3 の基礎行列。
points1	1番目の点群を含む 1xN 配列。
points2	2番目の点群を含む 1xN 配列。
newPoints1	最適化された points1。
newPoints2	最適化された points2。

この関数は最適三角測量法（Optimal Triangulation Method）を実装している（詳細は Multiple View Geometry [120] を参照）。与えられた各点対応 points1[i] <-> points2[i] と基礎行列 F に対して、エピポーラ拘束 \(newPoints2^T \cdot F \cdot newPoints1 = 0\) を満たしつつ、幾何学的誤差 \(d(points1[i], newPoints1[i])^2 + d(points2[i],newPoints2[i])^2\)（ここで \(d(a,b)\) は点 \(a\) と \(b\) の間の幾何学的距離）を最小化する補正された対応 newPoints1[i] <-> newPoints2[i] を計算する。

decomposeEssentialMat()

void cv::decomposeEssentialMat	(	InputArray	E,
		OutputArray	R1,
		OutputArray	R2,
		OutputArray	t )

Python:
	cv.decomposeEssentialMat(	E[, R1[, R2[, t]]]	) ->	R1, R2, t

#include <opencv2/calib3d.hpp>

基本行列を可能な回転と並進に分解する。

引数

E	入力の基本行列。
R1	考えられる回転行列の1つ。
R2	考えられるもう1つの回転行列。
t	考えられる並進の1つ。

この関数は、SVD分解を用いて基本行列 E を分解する [120]。一般に、E の分解には4つの可能な姿勢が存在する。それらは \([R_1, t]\)、\([R_1, -t]\)、\([R_2, t]\)、\([R_2, -t]\) である。

E が第1画像中の画像点 \(p_1\) と第2画像中の \(p_2\) の間のエピポーラ拘束 \([p_2; 1]^T A^{-T} E A^{-1} [p_1; 1] = 0\) を与える場合、タプル \([R_1, t]\)、\([R_1, -t]\)、\([R_2, t]\)、\([R_2, -t]\) のいずれかが第1カメラの座標系から第2カメラの座標系への基底変換となる。ただし、E を分解することで得られるのは並進の方向のみである。このため、並進 t は単位長さで返される。

decomposeHomographyMat()

int cv::decomposeHomographyMat	(	InputArray	H,
		InputArray	K,
		OutputArrayOfArrays	rotations,
		OutputArrayOfArrays	translations,
		OutputArrayOfArrays	normals )

Python:
	cv.decomposeHomographyMat(	H, K[, rotations[, translations[, normals]]]	) ->	retval, rotations, translations, normals

#include <opencv2/calib3d.hpp>

ホモグラフィ行列を回転、並進、および平面法線に分解する。

引数

H	2枚の画像間の入力ホモグラフィ行列。
K	入力のカメラ内部行列。
rotations	回転行列の配列。
translations	並進行列の配列。
normals	平面法線行列の配列。

この関数は、平面オブジェクトの2つのビュー間の相対的なカメラ運動を抽出し、回転、並進、平面法線からなる最大4つの数学的な解のタプルを返す。ホモグラフィ行列 H の分解の詳細は [186] に記述されている。

平面によって誘導されるホモグラフィ H が次の拘束を与える場合

\[s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\]

ソース画像点 \(p_i\) と対象画像点 \(p'_i\) について、タプル rotations[k] と translations[k] はソースカメラの座標系から対象カメラの座標系への基底変換である。ただし、H を分解することで得られるのは、シーンの（一般に未知の）奥行きで正規化された並進、すなわちその方向だけであり、長さは正規化されている。

点の対応が利用可能であれば、正の奥行き拘束、すなわちすべての点がカメラの前方になければならないという拘束を適用することで、少なくとも2つの解をさらに無効化できる。

decomposeProjectionMatrix()

void cv::decomposeProjectionMatrix	(	InputArray	projMatrix,
		OutputArray	cameraMatrix,
		OutputArray	rotMatrix,
		OutputArray	transVect,
		OutputArray	rotMatrixX = noArray(),
		OutputArray	rotMatrixY = noArray(),
		OutputArray	rotMatrixZ = noArray(),
		OutputArray	eulerAngles = noArray() )

Python:
	cv.decomposeProjectionMatrix(	projMatrix[, cameraMatrix[, rotMatrix[, transVect[, rotMatrixX[, rotMatrixY[, rotMatrixZ[, eulerAngles]]]]]]]	) ->	cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles

#include <opencv2/calib3d.hpp>

射影行列を回転行列とカメラ内部行列に分解する。

引数

projMatrix	3x4 の入力射影行列 P。
cameraMatrix	出力の 3x3 カメラ内部行列 \(\cameramatrix{A}\)。
rotMatrix	出力の 3x3 外部回転行列 R。
transVect	出力の 4x1 並進ベクトル T。
rotMatrixX	x軸まわりの 3x3 回転行列（省略可能）。
rotMatrixY	y軸まわりの 3x3 回転行列（省略可能）。
rotMatrixZ	z軸まわりの 3x3 回転行列（省略可能）。
eulerAngles	回転の3つのオイラー角（度単位）を含む3要素ベクトル（省略可能）。

この関数は、射影行列をキャリブレーション行列、回転行列、およびカメラの位置に分解する。

オプションで、各軸に対応する3つの回転行列と、OpenGLで使用できる3つのオイラー角を返す。なお、3つの主軸まわりの回転には、同じオブジェクトの向きを生み出す系列が常に複数存在することに注意せよ。例えば [254] を参照。返される3つの回転行列と対応する3つのオイラー角は、可能な解の一つにすぎない。

この関数は RQDecomp3x3 に基づいている。

drawChessboardCorners()

void cv::drawChessboardCorners	(	InputOutputArray	image,
		Size	patternSize,
		InputArray	corners,
		bool	patternWasFound )

Python:
	cv.drawChessboardCorners(	image, patternSize, corners, patternWasFound	) ->	image

#include <opencv2/calib3d.hpp>

検出したチェスボードのコーナーを描画する。

引数

image	出力画像。8ビットのカラー画像でなければならない。
patternSize	チェスボードの行・列ごとの内側コーナーの数（patternSize = cv::Size(points_per_row,points_per_column)）。
corners	検出されたコーナーの配列。findChessboardCorners の出力。
patternWasFound	ボード全体が検出されたかどうかを示すパラメータ。findChessboardCorners の戻り値をここに渡すこと。

この関数は、ボードが見つからなかった場合は検出された個々のチェスボードのコーナーを赤い円として描画し、ボードが見つかった場合は線でつながれた色付きのコーナーとして描画する。

drawFrameAxes()

void cv::drawFrameAxes	(	InputOutputArray	image,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	rvec,
		InputArray	tvec,
		float	length,
		int	thickness = 3 )

Python:
	cv.drawFrameAxes(	image, cameraMatrix, distCoeffs, rvec, tvec, length[, thickness]	) ->	image

#include <opencv2/calib3d.hpp>

姿勢推定からワールド/オブジェクト座標系の軸を描画する。

参照

solvePnP

引数

image	入出力画像。1または3チャンネルでなければならない。チャンネル数は変更されない。
cameraMatrix	カメラの内部パラメータの 3x3 浮動小数点入力行列。\(\cameramatrix{A}\)
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが空の場合、歪み係数はゼロと仮定される。
rvec	回転ベクトル（Rodrigues を参照）。tvec とともに、モデル座標系からカメラ座標系へ点を変換する。
tvec	並進ベクトル。
length	描画する軸の長さ。tvec と同じ単位（通常はメートル）。
thickness	描画する軸の線の太さ。

この関数は、カメラフレームに対するワールド/オブジェクト座標系の軸を描画する。OX は赤、OY は緑、OZ は青で描画される。

estimateAffine2D() [1/2]

cv::Mat cv::estimateAffine2D	(	InputArray	from,
		InputArray	to,
		OutputArray	inliers = noArray(),
		int	method = RANSAC,
		double	ransacReprojThreshold = 3,
		size_t	maxIters = 2000,
		double	confidence = 0.99,
		size_t	refineIters = 10 )

Python:
	cv.estimateAffine2D(	from_, to[, inliers[, method[, ransacReprojThreshold[, maxIters[, confidence[, refineIters]]]]]]	) ->	retval, inliers
	cv.estimateAffine2D(	pts1, pts2, params[, inliers]	) ->	retval, inliers

#include <opencv2/calib3d.hpp>

2つの2D点集合間の最適なアフィン変換を計算する。

次を計算する

\[ \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \]

引数

from	\((X,Y)\) を含む1番目の入力2次元点群。
to	\((x,y)\) を含む2番目の入力2次元点群。
inliers	どの点がインライアであるかを示す出力ベクトル（1=インライア、0=アウトライア）。
method	変換の計算に用いるロバスト手法。次の手法が利用できる: RANSAC - RANSACベースのロバスト手法 LMEDS - 最小メジアン（Least-Median）ロバスト手法。RANSAC がデフォルトの手法である。
ransacReprojThreshold	点をインライアとみなすための、RANSAC アルゴリズムにおける最大再投影誤差。RANSAC にのみ適用される。
maxIters	ロバスト手法の最大反復回数。
confidence	推定される変換の信頼度。0から1の値で、通常は 0.95 から 0.99 の間であれば十分である。1 に近すぎる値は推定を大幅に遅くする可能性がある。0.8〜0.9 より低い値は誤った変換の推定につながることがある。
refineIters	リファインアルゴリズム（Levenberg-Marquardt）の最大反復回数。0 を渡すとリファインが無効になり、出力行列はロバスト手法の出力となる。

戻り値

Output 2D affine transformation matrix \(2 \times 3\) or empty matrix if transformation could not be estimated. The returned matrix has the following form:

\[ \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \]

この関数は、選択したロバストなアルゴリズムを用いて、2つの2D点集合間の最適な2Dアフィン変換を推定する。

計算された変換は、その後（インライアのみを用いて）Levenberg-Marquardt法でさらに精緻化され、再投影誤差をいっそう低減する。

覚え書き

RANSAC法は事実上どのようなアウトライア比率にも対応できるが、インライアとアウトライアを区別するためのしきい値を必要とする。LMeDS法はしきい値を必要としないが、インライアが50%を超える場合にのみ正しく機能する。

参照

estimateAffinePartial2D, getAffineTransform

estimateAffine2D() [2/2]

cv::Mat cv::estimateAffine2D	(	InputArray	pts1,
		InputArray	pts2,
		OutputArray	inliers,
		const UsacParams &	params )

Python:
	cv.estimateAffine2D(	from_, to[, inliers[, method[, ransacReprojThreshold[, maxIters[, confidence[, refineIters]]]]]]	) ->	retval, inliers
	cv.estimateAffine2D(	pts1, pts2, params[, inliers]	) ->	retval, inliers

#include <opencv2/calib3d.hpp>

estimateAffine3D() [1/2]

cv::Mat cv::estimateAffine3D	(	InputArray	src,
		InputArray	dst,
		double *	scale = nullptr,
		bool	force_rotation = true )

Python:
	cv.estimateAffine3D(	src, dst[, out[, inliers[, ransacThreshold[, confidence]]]]	) ->	retval, out, inliers
	cv.estimateAffine3D(	src, dst[, force_rotation]	) ->	retval, scale

#include <opencv2/calib3d.hpp>

2つの3D点集合間の最適なアフィン変換を計算する。

\(R,s,t\) を計算し、\(\sum{i} dst_i - c \cdot R \cdot src_i \) を最小化する。ここで \(R\) は 3x3 の回転行列、\(t\) は 3x1 の並進ベクトル、\(s\) はスカラのサイズ値である。これは Umeyama によるアルゴリズムの実装である [284]。推定されるアフィン変換は同次スケールを持ち、これは7自由度を持つアフィン変換のサブクラスである。対となる点集合はそれぞれ少なくとも3点を含む必要がある。

引数

src	1番目の入力3次元点群。
dst	2番目の入力3次元点群。
scale	null を渡すと、スケールパラメータ c は 1.0 と仮定される。そうでなければ、指し示す変数に最適なスケールが設定される。
force_rotation	true の場合、返される回転は決して鏡映にならない。たとえば右手系と左手系の座標系の間の変換を最適化する場合など、これが望ましくないことがある。

戻り値

3D affine transformation matrix \(3 \times 4\) of the form

\[T = \begin{bmatrix} R & t\\ \end{bmatrix} \]

estimateAffine3D() [2/2]

int cv::estimateAffine3D	(	InputArray	src,
		InputArray	dst,
		OutputArray	out,
		OutputArray	inliers,
		double	ransacThreshold = 3,
		double	confidence = 0.99 )

Python:
	cv.estimateAffine3D(	src, dst[, out[, inliers[, ransacThreshold[, confidence]]]]	) ->	retval, out, inliers
	cv.estimateAffine3D(	src, dst[, force_rotation]	) ->	retval, scale

#include <opencv2/calib3d.hpp>

2つの3D点集合間の最適なアフィン変換を計算する。

次を計算する

\[ \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12} & a_{13}\\ a_{21} & a_{22} & a_{23}\\ a_{31} & a_{32} & a_{33}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \]

引数

src	\((X,Y,Z)\) を含む1番目の入力3次元点群。
dst	\((x,y,z)\) を含む2番目の入力3次元点群。
out	次の形式の出力3次元アフィン変換行列 \(3 \times 4\) \[ \begin{bmatrix} a_{11} & a_{12} & a_{13} & b_1\\ a_{21} & a_{22} & a_{23} & b_2\\ a_{31} & a_{32} & a_{33} & b_3\\ \end{bmatrix} \]
inliers	どの点がインライアであるかを示す出力ベクトル（1=インライア、0=アウトライア）。
ransacThreshold	点をインライアとみなすための、RANSAC アルゴリズムにおける最大再投影誤差。
confidence	推定される変換の信頼度。0から1の値で、通常は 0.95 から 0.99 の間であれば十分である。1 に近すぎる値は推定を大幅に遅くする可能性がある。0.8〜0.9 より低い値は誤った変換の推定につながることがある。

この関数は、RANSACアルゴリズムを用いて、2つの3D点集合間の最適な3Dアフィン変換を推定する。

estimateAffinePartial2D()

cv::Mat cv::estimateAffinePartial2D	(	InputArray	from,
		InputArray	to,
		OutputArray	inliers = noArray(),
		int	method = RANSAC,
		double	ransacReprojThreshold = 3,
		size_t	maxIters = 2000,
		double	confidence = 0.99,
		size_t	refineIters = 10 )

Python:
	cv.estimateAffinePartial2D(	from_, to[, inliers[, method[, ransacReprojThreshold[, maxIters[, confidence[, refineIters]]]]]]	) ->	retval, inliers

#include <opencv2/calib3d.hpp>

2つの2D点集合間で4自由度を持つ最適な限定アフィン変換を計算する。

引数

from	1番目の入力2次元点群。
to	2番目の入力2次元点群。
inliers	どの点がインライアであるかを示す出力ベクトル。
method	変換の計算に用いるロバスト手法。次の手法が利用できる: RANSAC - RANSACベースのロバスト手法 LMEDS - 最小メジアン（Least-Median）ロバスト手法。RANSAC がデフォルトの手法である。
ransacReprojThreshold	点をインライアとみなすための、RANSAC アルゴリズムにおける最大再投影誤差。RANSAC にのみ適用される。
maxIters	ロバスト手法の最大反復回数。
confidence	推定される変換の信頼度。0から1の値で、通常は 0.95 から 0.99 の間であれば十分である。1 に近すぎる値は推定を大幅に遅くする可能性がある。0.8〜0.9 より低い値は誤った変換の推定につながることがある。
refineIters	リファインアルゴリズム（Levenberg-Marquardt）の最大反復回数。0 を渡すとリファインが無効になり、出力行列はロバスト手法の出力となる。

戻り値

出力される2Dアフィン変換（4自由度）行列 \(2 \times 3\)、または変換を推定できなかった場合は空の行列。

この関数は、並進、回転、一様スケーリングの組み合わせに限定された4自由度を持つ最適な2Dアフィン変換を推定する。ロバストな推定には選択したアルゴリズムを使用する。

計算された変換は、その後（インライアのみを用いて）Levenberg-Marquardt法でさらに精緻化され、再投影誤差をいっそう低減する。

推定される変換行列は次のとおりである：

\[ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \]

ここで \( \theta \) は回転角、\( s \) はスケーリング係数、\( t_x, t_y \) はそれぞれ \( x, y \) 軸方向の並進である。

覚え書き

RANSAC法は事実上どのようなアウトライア比率にも対応できるが、インライアとアウトライアを区別するためのしきい値を必要とする。LMeDS法はしきい値を必要としないが、インライアが50%を超える場合にのみ正しく機能する。

参照

estimateAffine2D, getAffineTransform

estimateChessboardSharpness()

Scalar cv::estimateChessboardSharpness	(	InputArray	image,
		Size	patternSize,
		InputArray	corners,
		float	rise_distance = 0.8F,
		bool	vertical = false,
		OutputArray	sharpness = noArray() )

Python:
	cv.estimateChessboardSharpness(	image, patternSize, corners[, rise_distance[, vertical[, sharpness]]]	) ->	retval, sharpness

#include <opencv2/calib3d.hpp>

検出したチェスボードの鮮明度を推定する。

画像の鮮明度は、明るさと同様に、正確なカメラキャリブレーションにとって重要な引数である。問題のあるキャリブレーション画像を除外するためにこれらの引数にアクセスできるように、このメソッドは黒から白のチェスボードセル中心へとたどることでエッジプロファイルを計算する。これに基づき、黒から白へ遷移するのに必要なピクセル数を計算する。この遷移領域の幅は、チェスボードがどれだけ鮮明に撮像されているかを示す良い指標であり、約3.0ピクセル以下であるべきである。

引数

image	チェスボードのコーナー検出に使用するグレースケール画像
patternSize	検出されたチェスボードパターンのサイズ
corners	findChessboardCornersSB によって検出されたコーナー
rise_distance	立ち上がり距離。0.8 は最終的な信号強度の 10% 〜 90% を意味する
vertical	デフォルトでは水平線に対するエッジ応答が計算される
sharpness	計算されたエッジ応答の鮮鋭度（sharpness）値を格納する出力配列（説明を参照、省略可能）

オプションの鮮明度配列は CV_32FC1 型で、計算された各プロファイルについて、次の5つのエントリを持つ行を1つ持つ：0 = 画像中の対象エッジの x 座標、1 = 画像中の対象エッジの y 座標、2 = 遷移領域の幅（鮮明度）、3 = 黒セルの信号強度（最小明度）、4 = 白セルの信号強度（最大明度）。

戻り値

Scalar(average sharpness, average min brightness, average max brightness,0)

estimateTranslation2D()

cv::Vec2d cv::estimateTranslation2D	(	InputArray	from,
		InputArray	to,
		OutputArray	inliers = noArray(),
		int	method = RANSAC,
		double	ransacReprojThreshold = 3,
		size_t	maxIters = 2000,
		double	confidence = 0.99,
		size_t	refineIters = 0 )

Python:
	cv.estimateTranslation2D(	from_, to[, inliers[, method[, ransacReprojThreshold[, maxIters[, confidence[, refineIters]]]]]]	) ->	retval, inliers

#include <opencv2/calib3d.hpp>

2つの2D点群の間の純粋な2D平行移動を計算する。

次を計算する

\[ \begin{bmatrix} x\\ y \end{bmatrix} = \begin{bmatrix} 1 & 0\\ 0 & 1 \end{bmatrix} \begin{bmatrix} X\\ Y \end{bmatrix} + \begin{bmatrix} t_x\\ t_y \end{bmatrix}. \]

引数

from	\((X,Y)\) を含む1番目の入力2次元点群。
to	\((x,y)\) を含む2番目の入力2次元点群。
inliers	どの点がインライアであるかを示す出力ベクトル（1=インライア、0=アウトライア）。
method	変換の計算に用いるロバスト手法。次の手法が利用できる: RANSAC - RANSACベースのロバスト手法 LMEDS - 最小メジアン（Least-Median）ロバスト手法。RANSAC がデフォルトの手法である。
ransacReprojThreshold	点をインライアとみなすための、RANSAC アルゴリズムにおける最大再投影誤差。RANSAC にのみ適用される。
maxIters	ロバスト手法の最大反復回数。
confidence	推定される変換の信頼度。0から1の値で、通常は 0.95 から 0.99 の間であれば十分である。1 に近すぎる値は推定を大幅に遅くする可能性がある。0.8〜0.9 より低い値は誤った変換の推定につながることがある。
refineIters	詳細化アルゴリズムの最大反復回数。純粋な並進の場合はインライアに対する最小二乗解が閉形式で求まるため、0 を渡すこと（追加の詳細化を行わない）が推奨される。

戻り値

cv::Vec2d 形式の2D平行移動ベクトル \([t_x, t_y]^T\)。平行移動を推定できなかった場合、両成分はNaNに設定され、inliers が指定されている場合はマスクがゼロで埋められる。

Converting to a 2x3 transformation matrix:

\[ \begin{bmatrix} 1 & 0 & t_x\\ 0 & 1 & t_y \end{bmatrix} \]

cv::Vec2d t = cv::estimateTranslation2D(from, to, inliers);
cv::Mat T = (cv::Mat_<double>(2,3) << 1,0,t[0], 0,1,t[1]);

この関数は、選択したロバストアルゴリズムを用いて2つの2D点群の間の純粋な2D平行移動を推定する。インライアは再投影誤差のしきい値によって決定される。

覚え書き

RANSAC法はほぼ任意の割合の外れ値を扱えるが、インライアと外れ値を区別するためのしきい値を必要とする。LMeDS法はしきい値を必要としないが、インライアが50%を超える場合にのみ正しく動作する。

参照

estimateAffine2D, estimateAffinePartial2D, getAffineTransform

estimateTranslation3D()

int cv::estimateTranslation3D	(	InputArray	src,
		InputArray	dst,
		OutputArray	out,
		OutputArray	inliers,
		double	ransacThreshold = 3,
		double	confidence = 0.99 )

Python:
	cv.estimateTranslation3D(	src, dst[, out[, inliers[, ransacThreshold[, confidence]]]]	) ->	retval, out, inliers

#include <opencv2/calib3d.hpp>

2つの3D点群の間の最適な平行移動を計算する。

次を計算する

\[ \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \]

引数

src	\((X,Y,Z)\) を含む1番目の入力3次元点群。
dst	\((x,y,z)\) を含む2番目の入力3次元点群。
out	次の形式の出力 3D 並進ベクトル \(3 \times 1\) \[ \begin{bmatrix} b_1 \\ b_2 \\ b_3 \\ \end{bmatrix} \]
inliers	どの点がインライアであるかを示す出力ベクトル（1=インライア、0=アウトライア）。
ransacThreshold	点をインライアとみなすための、RANSAC アルゴリズムにおける最大再投影誤差。
confidence	推定される変換の信頼度。0から1の値で、通常は 0.95 から 0.99 の間であれば十分である。1 に近すぎる値は推定を大幅に遅くする可能性がある。0.8〜0.9 より低い値は誤った変換の推定につながることがある。

この関数は、RANSACアルゴリズムを用いて2つの3D点群の間の最適な3D平行移動を推定する。

filterHomographyDecompByVisibleRefpoints()

void cv::filterHomographyDecompByVisibleRefpoints	(	InputArrayOfArrays	rotations,
		InputArrayOfArrays	normals,
		InputArray	beforePoints,
		InputArray	afterPoints,
		OutputArray	possibleSolutions,
		InputArray	pointsMask = noArray() )

Python:
	cv.filterHomographyDecompByVisibleRefpoints(	rotations, normals, beforePoints, afterPoints[, possibleSolutions[, pointsMask]]	) ->	possibleSolutions

#include <opencv2/calib3d.hpp>

追加情報に基づいてホモグラフィ分解の結果を絞り込む。

引数

rotations	回転行列のベクトル。
normals	平面の法線行列のベクトル。
beforePoints	ホモグラフィを適用する前の（補正された）可視の参照点のベクトル
afterPoints	ホモグラフィを適用した後の（補正された）可視の参照点のベクトル
possibleSolutions	フィルタリング後の有効な解集合を表す int インデックスのベクトル
pointsMask	findHomography 関数が返すインライアのマスクを表す、省略可能な 8u 型の Mat/Vector

この関数は、[186] で説明されているように、追加情報に基づいて decomposeHomographyMat の出力を絞り込むことを目的としている。手法の概要は次のとおりである。decomposeHomographyMat 関数は、2つの一意な解とそれらの「逆向きの解」を合わせて計4つの解を返す。ホモグラフィ変換を適用する前と後にカメラフレーム内で見える点の集合にアクセスできれば、すべての可視参照点がカメラの前方にあることと整合するホモグラフィを検証することで、どれが真の潜在的な解でどれが逆向きの解であるかを判定できる。入力は変更されず、絞り込まれた解の集合は既存の集合へのインデックスとして返される。

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/calib3d.hpp>

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

引数

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

find4QuadCornerSubpix()

bool cv::find4QuadCornerSubpix	(	InputArray	img,
		InputOutputArray	corners,
		Size	region_size )

Python:
	cv.find4QuadCornerSubpix(	img, corners, region_size	) ->	retval, corners

#include <opencv2/calib3d.hpp>

チェスボードのコーナーのサブピクセル精度の位置を求める

findChessboardCorners()

bool cv::findChessboardCorners	(	InputArray	image,
		Size	patternSize,
		OutputArray	corners,
		int	flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE )

Python:
	cv.findChessboardCorners(	image, patternSize[, corners[, flags]]	) ->	retval, corners

#include <opencv2/calib3d.hpp>

チェスボードの内側のコーナーの位置を求める。

引数

image	入力のチェスボード画像。8 ビットのグレースケールまたはカラー画像でなければならない。
patternSize	チェスボードの行・列ごとの内側コーナー数（ patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ）。
corners	検出されたコーナーの出力配列。
flags	0、または以下の値の組み合わせを指定できる各種の操作フラグ: CALIB_CB_ADAPTIVE_THRESH 固定のしきい値レベル（画像の平均輝度から計算）ではなく、適応的しきい値処理を用いて画像を白黒に変換する。 CALIB_CB_NORMALIZE_IMAGE 固定または適応的しきい値処理を適用する前に、equalizeHist で画像のガンマを正規化する。 CALIB_CB_FILTER_QUADS 追加の基準（輪郭の面積、周囲長、正方形らしい形状など）を用いて、輪郭抽出段階で誤って抽出された四角形を除去する。 CALIB_CB_FAST_CHECK 画像に対してチェスボードのコーナーを探す高速チェックを実行し、見つからなければ呼び出しを途中で打ち切る。これにより、チェスボードが観測されない縮退した状況で呼び出しを大幅に高速化できる。 CALIB_CB_PLAIN 他のすべてのフラグは無視される。入力画像はそのまま使われる。チェッカーボードを見つけやすくするための画像処理は行われない。これにより関数の実行が高速化されるが、画像が適切な方法で事前に二値化されていない場合はチェッカーボードを認識できないことがある。

この関数は、入力画像がチェスボードパターンの像であるかどうかを判定し、内側のチェスボードコーナーの位置を特定しようとする。すべてのコーナーが見つかり、それらが一定の順序（行ごと、各行で左から右へ）に配置された場合、関数は非ゼロの値を返す。それ以外の場合、つまり関数がすべてのコーナーを見つけられないか並べ替えに失敗した場合は、0を返す。たとえば、通常のチェスボードは8×8のマスと7×7の内側のコーナー、すなわち黒いマス同士が接する点を持つ。検出された座標は近似値であり、その位置をより正確に求めるために、関数は cornerSubPix を呼び出す。返された座標が十分に正確でない場合は、異なる引数で cornerSubPix 関数を使用してもよい。

チェスボードのコーナーを検出して描画する使用例: :

Size patternsize(8,6); //interior number of corners
Mat gray = ....; //source image
vector<Point2f> corners; //this will be filled by the detected corners
 
//CALIB_CB_FAST_CHECK saves a lot of time on images
//that do not contain any chessboard corners
bool patternfound = findChessboardCorners(gray, patternsize, corners,
 CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
        + CALIB_CB_FAST_CHECK);
 
if(patternfound)
 cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
 TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
 
drawChessboardCorners(img, patternsize, Mat(corners), patternfound);

覚え書き

様々な環境で検出をよりロバストにするために、関数はボードの周囲に余白（正方形の太さの境界のような、広いほどよい）を必要とする。さもなければ、境界がなく背景が暗い場合、外側の黒いマスを適切にセグメント化できず、マスのグループ化と並べ替えのアルゴリズムが失敗する。

目的のチェッカーボードパターンを作成するには、generate_pattern.py Pythonスクリプト（キャリブレーションパターンの作成）を使用する。

findChessboardCornersSB() [1/2]

bool cv::findChessboardCornersSB	(	InputArray	image,
		Size	patternSize,
		OutputArray	corners,
		int	flags,
		OutputArray	meta )

Python:
	cv.findChessboardCornersSB(	image, patternSize[, corners[, flags]]	) ->	retval, corners
	cv.findChessboardCornersSBWithMeta(	image, patternSize, flags[, corners[, meta]]	) ->	retval, corners, meta

#include <opencv2/calib3d.hpp>

セクタベースのアプローチを用いてチェスボードの内側のコーナーの位置を求める。

引数

image	入力のチェスボード画像。8 ビットのグレースケールまたはカラー画像でなければならない。
patternSize	チェスボードの行・列ごとの内側コーナー数（ patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ）。
corners	検出されたコーナーの出力配列。
flags	0、または以下の値の組み合わせを指定できる各種の操作フラグ: CALIB_CB_NORMALIZE_IMAGE 検出の前に equalizeHist で画像のガンマを正規化する。 CALIB_CB_EXHAUSTIVE 検出率を向上させるために網羅的探索を実行する。 CALIB_CB_ACCURACY エイリアシング効果によるサブピクセル精度を向上させるために入力画像をアップサンプリングする。 CALIB_CB_LARGER 検出されるパターンが patternSize より大きいことを許容する（説明を参照）。 CALIB_CB_MARKER 検出されるパターンはマーカーを持たなければならない（説明を参照）。正確なカメラキャリブレーションが必要な場合に使用すべきである。
meta	検出されたコーナーの省略可能な出力配列（CV_8UC1 で size = cv::Size(columns,rows)）。各エントリはパターンの 1 つのコーナーを表し、以下のいずれかの値を取り得る: 0 = メタデータが付与されていない 1 = 黒セルの左上コーナー 2 = 白セルの左上コーナー 3 = 白いマーカードットを持つ黒セルの左上コーナー 4 = 黒いマーカードットを持つ白セルの左上コーナー（マーカーがある場合はパターンの原点、それ以外の場合は最初のコーナー）

この関数は findChessboardCorners に類似しているが、ボックスフィルタで近似した局所的なラドン変換を用いており、あらゆる種類のノイズに対してよりロバストで、大きな画像ではより高速であり、内側のチェスボードコーナーのサブピクセル位置を直接返すことができる。この手法は論文 [78] 「Accurate Detection and Localization of Checkerboard Corners for Calibration」に基づいており、返されるサブピクセル位置がcornerSubPixで返されるものよりも正確であり、要求の厳しいアプリケーション向けの高精度なカメラキャリブレーションを可能にすることを示している。

フラグ CALIB_CB_LARGER または CALIB_CB_MARKER が指定された場合、結果は省略可能なメタ配列から復元できる。どちらのフラグも、カメラの視野を超えるキャリブレーションパターンを使用する際に役立つ。これらの大きすぎるパターンでは、画像の境界にできるだけ近いコーナーを利用できるため、より正確なキャリブレーションが可能になる。すべての画像で一貫した座標系を得るために、省略可能なマーカー（下の画像を参照）を使用して、黒い円が位置する場所にボードの原点を移動できる。

覚え書き

この関数は、様々な環境での検出を向上させるために、ボード全体の周囲にチェッカーボードのマス目の1つとほぼ同じ幅の白い境界を必要とする。さらに、局所的なラドン変換のため、ボードの外側に位置するマス目のコーナーには丸いコーナーを使用すると有利である。次の図は、検出に最適化されたチェッカーボードの例を示している。ただし、他の任意のチェッカーボードも同様に使用できる。

対応するチェッカーボードパターンを作成するには、generate_pattern.py Pythonスクリプト（キャリブレーションパターンの作成）を使用する:

findChessboardCornersSB() [2/2]

bool cv::findChessboardCornersSB ( InputArray image, Size patternSize, OutputArray corners, int flags = 0 )

inline

Python:
	cv.findChessboardCornersSB(	image, patternSize[, corners[, flags]]	) ->	retval, corners
	cv.findChessboardCornersSBWithMeta(	image, patternSize, flags[, corners[, meta]]	) ->	retval, corners, meta

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

この関数の呼び出しグラフ:

findCirclesGrid() [1/2]

bool cv::findCirclesGrid	(	InputArray	image,
		Size	patternSize,
		OutputArray	centers,
		int	flags,
		const Ptr< FeatureDetector > &	blobDetector,
		const CirclesGridFinderParameters &	parameters )

Python:
	cv.findCirclesGrid(	image, patternSize, flags, blobDetector, parameters[, centers]	) ->	retval, centers
	cv.findCirclesGrid(	image, patternSize[, centers[, flags[, blobDetector]]]	) ->	retval, centers

#include <opencv2/calib3d.hpp>

円のグリッドの中心を求める。

引数

image	入力の円グリッド画像。8 ビットのグレースケールまたはカラー画像でなければならない。
patternSize	行・列ごとの円の数（ patternSize = Size(points_per_row, points_per_colum) ）。
centers	検出された中心点の出力配列。
flags	以下のいずれかの値を指定できる各種の操作フラグ: CALIB_CB_SYMMETRIC_GRID 対称な円のパターンを使用する。 CALIB_CB_ASYMMETRIC_GRID 非対称な円のパターンを使用する。 CALIB_CB_CLUSTERING グリッド検出に特別なアルゴリズムを使用する。透視歪みに対してよりロバストだが、背景の雑然さに対してははるかに敏感である。
blobDetector	明るい背景上の暗い円のようなブロブを見つける特徴検出器。blobDetector が NULL の場合、image は候補点の Point2f 配列を表す。
parameters	グリッドパターン内の円を見つけるための構造体。

この関数は、入力画像が円のグリッドを含むかどうかを判定しようとする。含む場合、関数は円の中心を特定する。すべての中心が見つかり、それらが一定の順序（行ごと、各行で左から右へ）に配置された場合、関数は非ゼロの値を返す。それ以外の場合、つまり関数がすべてのコーナーを見つけられないか並べ替えに失敗した場合は、0を返す。

円の中心を検出して描画する使用例: :

Size patternsize(7,7); //number of centers
Mat gray = ...; //source image
vector<Point2f> centers; //this will be filled by the detected centers
 
bool patternfound = findCirclesGrid(gray, patternsize, centers);
 
drawChessboardCorners(img, patternsize, Mat(centers), patternfound);

覚え書き

様々な環境で検出をよりロバストにするために、関数はボードの周囲に余白（正方形の太さの境界のような、広いほどよい）を必要とする。

findCirclesGrid() [2/2]

bool cv::findCirclesGrid	(	InputArray	image,
		Size	patternSize,
		OutputArray	centers,
		int	flags = CALIB_CB_SYMMETRIC_GRID,
		const Ptr< FeatureDetector > &	blobDetector = SimpleBlobDetector::create() )

Python:
	cv.findCirclesGrid(	image, patternSize, flags, blobDetector, parameters[, centers]	) ->	retval, centers
	cv.findCirclesGrid(	image, patternSize[, centers[, flags[, blobDetector]]]	) ->	retval, centers

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

findEssentialMat() [1/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		double	focal,
		Point2d	pp,
		int	method,
		double	prob,
		double	threshold,
		OutputArray	mask )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

findEssentialMat() [2/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		double	focal = 1.0,
		Point2d	pp = Point2d(0, 0),
		int	method = RANSAC,
		double	prob = 0.999,
		double	threshold = 1.0,
		int	maxIters = 1000,
		OutputArray	mask = noArray() )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

points1	1 枚目の画像からの N 個（N >= 5）の 2D 点の配列。点の座標は浮動小数点（単精度または倍精度）でなければならない。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
focal	カメラの焦点距離。この関数は、points1 と points2 が同じ焦点距離および主点を持つカメラからの特徴点であると仮定することに注意。
pp	カメラの主点。
method	基礎行列を計算するための手法。 RANSAC RANSAC アルゴリズム。 LMEDS LMedS アルゴリズム。
threshold	RANSAC で使用される引数。点からエピポーラ線までの最大距離（ピクセル単位）であり、これを超える点はアウトライアとみなされ、最終的な基礎行列の計算には使用されない。点の位置特定の精度、画像の解像度、画像のノイズに応じて、1〜3 程度の値に設定できる。
prob	RANSAC または LMedS 手法でのみ使用される引数。推定された行列が正しいという望ましい信頼水準（確率）を指定する。
mask	N 要素の出力配列で、各要素はアウトライアに対しては 0 に、それ以外の点に対しては 1 に設定される。この配列は RANSAC および LMedS 手法でのみ計算される。
maxIters	ロバスト手法の最大反復回数。

この関数は、焦点距離と主点からカメラ内部行列を計算する点で上記の関数と異なる:

\[A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\]

findEssentialMat() [3/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix,
		int	method,
		double	prob,
		double	threshold,
		OutputArray	mask )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

findEssentialMat() [4/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix,
		int	method = RANSAC,
		double	prob = 0.999,
		double	threshold = 1.0,
		int	maxIters = 1000,
		OutputArray	mask = noArray() )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

2つの画像内の対応する点から基本行列（essential matrix）を計算する。

引数

points1	1 枚目の画像からの N 個（N >= 5）の 2D 点の配列。点の座標は浮動小数点（単精度または倍精度）でなければならない。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
cameraMatrix	カメラの内部行列 \(\cameramatrix{A}\) 。この関数は、points1 と points2 が同じカメラ内部行列を持つカメラからの特徴点であると仮定することに注意。この仮定が用途に当てはまらない場合は、別の関数オーバーロードを使用するか、両方のカメラに対して P = cv::NoArray() を指定した undistortPoints を用いて画像点を正規化画像座標に変換する。正規化画像座標は単位カメラ内部行列に対して有効である。これらの座標を渡す場合は、この引数には単位行列を渡す。
method	基本行列を計算するための手法。 RANSAC RANSAC アルゴリズム。 LMEDS LMedS アルゴリズム。
prob	RANSAC または LMedS 手法でのみ使用される引数。推定された行列が正しいという望ましい信頼水準（確率）を指定する。
threshold	RANSAC で使用される引数。点からエピポーラ線までの最大距離（ピクセル単位）であり、これを超える点はアウトライアとみなされ、最終的な基礎行列の計算には使用されない。点の位置特定の精度、画像の解像度、画像のノイズに応じて、1〜3 程度の値に設定できる。
mask	N 要素の出力配列で、各要素はアウトライアに対しては 0 に、それ以外の点に対しては 1 に設定される。この配列は RANSAC および LMedS 手法でのみ計算される。
maxIters	ロバスト手法の最大反復回数。

この関数は、[214] の5点アルゴリズムソルバに基づいて基本行列（essential matrix）を推定する。[258] も関連している。エピポーラ幾何は次の式で表される:

\[[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\]

ここで \(E\) は基本行列（essential matrix）、\(p_1\) と \(p_2\) はそれぞれ1番目と2番目の画像内の対応する点である。この関数の結果はさらに decomposeEssentialMat または recoverPose に渡して、カメラ間の相対的な姿勢を復元できる。

findEssentialMat() [5/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix1,
		InputArray	cameraMatrix2,
		InputArray	dist_coeff1,
		InputArray	dist_coeff2,
		OutputArray	mask,
		const UsacParams &	params )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

findEssentialMat() [6/6]

Mat cv::findEssentialMat	(	InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix1,
		InputArray	distCoeffs1,
		InputArray	cameraMatrix2,
		InputArray	distCoeffs2,
		int	method = RANSAC,
		double	prob = 0.999,
		double	threshold = 1.0,
		OutputArray	mask = noArray() )

Python:
	cv.findEssentialMat(	points1, points2, cameraMatrix[, method[, prob[, threshold[, maxIters[, mask]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2[, focal[, pp[, method[, prob[, threshold[, maxIters[, mask]]]]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, method[, prob[, threshold[, mask]]]]	) ->	retval, mask
	cv.findEssentialMat(	points1, points2, cameraMatrix1, cameraMatrix2, dist_coeff1, dist_coeff2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

潜在的に異なる2つのカメラからの2つの画像内の対応する点から基本行列（essential matrix）を計算する。

引数

points1	1 枚目の画像からの N 個（N >= 5）の 2D 点の配列。点の座標は浮動小数点（単精度または倍精度）でなければならない。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
cameraMatrix1	1 つ目のカメラのカメラ行列 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
cameraMatrix2	2 つ目のカメラのカメラ行列 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs1	1 つ目のカメラの歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
distCoeffs2	2 つ目のカメラの歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
method	基本行列を計算するための手法。 RANSAC RANSAC アルゴリズム。 LMEDS LMedS アルゴリズム。
prob	RANSAC または LMedS 手法でのみ使用される引数。推定された行列が正しいという望ましい信頼水準（確率）を指定する。
threshold	RANSAC で使用される引数。点からエピポーラ線までの最大距離（ピクセル単位）であり、これを超える点はアウトライアとみなされ、最終的な基礎行列の計算には使用されない。点の位置特定の精度、画像の解像度、画像のノイズに応じて、1〜3 程度の値に設定できる。
mask	N 要素の出力配列で、各要素はアウトライアに対しては 0 に、それ以外の点に対しては 1 に設定される。この配列は RANSAC および LMedS 手法でのみ計算される。

この関数は、[214] の5点アルゴリズムソルバに基づいて基本行列（essential matrix）を推定する。[258] も関連している。エピポーラ幾何は次の式で表される:

\[[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\]

ここで \(E\) は基本行列（essential matrix）、\(p_1\) と \(p_2\) はそれぞれ1番目と2番目の画像内の対応する点である。この関数の結果はさらに decomposeEssentialMat または recoverPose に渡して、カメラ間の相対的な姿勢を復元できる。

findFundamentalMat() [1/4]

Mat cv::findFundamentalMat	(	InputArray	points1,
		InputArray	points2,
		int	method,
		double	ransacReprojThreshold,
		double	confidence,
		int	maxIters,
		OutputArray	mask = noArray() )

Python:
	cv.findFundamentalMat(	points1, points2, method, ransacReprojThreshold, confidence, maxIters[, mask]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2[, method[, ransacReprojThreshold[, confidence[, mask]]]]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

2つの画像内の対応する点から基礎行列（fundamental matrix）を計算する。

引数

	points1	1 枚目の画像からの N 個の点の配列。点の座標は浮動小数点（単精度または倍精度）でなければならない。
	points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
	method	基礎行列を計算するための手法。 FM_7POINT 7 点アルゴリズム。 \(N = 7\) FM_8POINT 8 点アルゴリズム。 \(N \ge 8\) FM_RANSAC RANSAC アルゴリズム。 \(N \ge 8\) FM_LMEDS LMedS アルゴリズム。 \(N \ge 8\)
	ransacReprojThreshold	RANSAC でのみ使用される引数。点からエピポーラ線までの最大距離（ピクセル単位）であり、これを超える点はアウトライアとみなされ、最終的な基礎行列の計算には使用されない。点の位置特定の精度、画像の解像度、画像のノイズに応じて、1〜3 程度の値に設定できる。
	confidence	RANSAC および LMedS 手法でのみ使用される引数。推定された行列が正しいという望ましい信頼水準（確率）を指定する。
[out]	mask	省略可能な出力マスク
	maxIters	ロバスト手法の最大反復回数。

エピポーラ幾何は次の式で表される:

\[[p_2; 1]^T F [p_1; 1] = 0\]

ここで \(F\) は基礎行列（fundamental matrix）、\(p_1\) と \(p_2\) はそれぞれ1番目と2番目の画像内の対応する点である。

この関数は、上記の4つの手法のいずれかを用いて基礎行列（fundamental matrix）を計算し、求めた基礎行列を返す。通常は1つの行列だけが見つかる。ただし7点アルゴリズムの場合、関数は最大3つの解（3つの行列を順に格納する \(9 \times 3\) 行列）を返すことがある。

計算された基礎行列（fundamental matrix）はさらに、指定した点に対応するエピポーラ線を求める computeCorrespondEpilines に渡せる。また、整流変換を計算するために stereoRectifyUncalibrated に渡すこともできる。:

// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
    points1[i] = ...;
    points2[i] = ...;
}
 
Mat fundamental_matrix =
 findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);

findFundamentalMat() [2/4]

Mat cv::findFundamentalMat	(	InputArray	points1,
		InputArray	points2,
		int	method = FM_RANSAC,
		double	ransacReprojThreshold = 3.,
		double	confidence = 0.99,
		OutputArray	mask = noArray() )

Python:
	cv.findFundamentalMat(	points1, points2, method, ransacReprojThreshold, confidence, maxIters[, mask]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2[, method[, ransacReprojThreshold[, confidence[, mask]]]]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

findFundamentalMat() [3/4]

Mat cv::findFundamentalMat	(	InputArray	points1,
		InputArray	points2,
		OutputArray	mask,
		const UsacParams &	params )

Python:
	cv.findFundamentalMat(	points1, points2, method, ransacReprojThreshold, confidence, maxIters[, mask]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2[, method[, ransacReprojThreshold[, confidence[, mask]]]]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

findFundamentalMat() [4/4]

Mat cv::findFundamentalMat	(	InputArray	points1,
		InputArray	points2,
		OutputArray	mask,
		int	method = FM_RANSAC,
		double	ransacReprojThreshold = 3.,
		double	confidence = 0.99 )

Python:
	cv.findFundamentalMat(	points1, points2, method, ransacReprojThreshold, confidence, maxIters[, mask]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2[, method[, ransacReprojThreshold[, confidence[, mask]]]]	) ->	retval, mask
	cv.findFundamentalMat(	points1, points2, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

findHomography() [1/3]

Mat cv::findHomography	(	InputArray	srcPoints,
		InputArray	dstPoints,
		int	method = 0,
		double	ransacReprojThreshold = 3,
		OutputArray	mask = noArray(),
		const int	maxIters = 2000,
		const double	confidence = 0.995 )

Python:
	cv.findHomography(	srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask[, maxIters[, confidence]]]]]	) ->	retval, mask
	cv.findHomography(	srcPoints, dstPoints, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

2つの平面の間の透視変換を求める。

引数

srcPoints	元の平面における点の座標。型 CV_32FC2 の行列または vector<Point2f> 。
dstPoints	対象平面における点の座標。型 CV_32FC2 の行列または vector<Point2f> 。
method	ホモグラフィ行列を計算するために使用される手法。以下の手法が利用できる: 0 - すべての点を用いる通常の手法、すなわち最小二乗法 RANSAC - RANSAC ベースのロバストな手法 LMEDS - 最小メジアンのロバストな手法 RHO - PROSAC ベースのロバストな手法
ransacReprojThreshold	点のペアをインライアとして扱うために許容される最大の再投影誤差（RANSAC および RHO 手法でのみ使用される）。すなわち、次の場合 \[\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\] 点 \(i\) はアウトライアとみなされる。srcPoints と dstPoints がピクセル単位で測定されている場合、通常この引数は 1〜10 程度の範囲に設定するのが妥当である。
mask	ロバストな手法（RANSAC または LMeDS）によって設定される省略可能な出力マスク。入力マスクの値は無視されることに注意。
maxIters	RANSAC の最大反復回数。
confidence	信頼水準。0 から 1 の間。

この関数は、ソース平面と宛先平面の間の透視変換 \(H\) を求めて返す:

\[s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\]

そのため、逆投影誤差

\[\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\]

が最小化される。引数methodがデフォルト値の0に設定されている場合、関数はすべての点ペアを使用し、単純な最小二乗法によって初期ホモグラフィ推定値を計算する。

ただし、すべての点ペア（\(srcPoints_i\)、\(dstPoints_i\)）が剛体的な透視変換に適合しない場合（つまり外れ値が存在する場合）、この初期推定値は不十分なものになる。この場合、3つのロバストな手法のいずれかを使用できる。RANSAC、LMeDS、RHOの各手法は、対応する点ペアの様々なランダムな部分集合（それぞれ4ペア、共線のペアは除外される）を多数試し、その部分集合と単純な最小二乗アルゴリズムを用いてホモグラフィ行列を推定し、計算したホモグラフィの品質・良さ（RANSACではインライアの数、LMeDSでは最小メジアン再投影誤差）を計算する。次に、最良の部分集合を用いてホモグラフィ行列の初期推定値とインライア・外れ値のマスクを生成する。

手法がロバストかどうかにかかわらず、計算されたホモグラフィ行列はさらにLevenberg-Marquardt法を用いて（ロバストな手法の場合はインライアのみを使用して）改良され、再投影誤差をさらに低減する。

RANSACおよびRHO法はほぼ任意の割合の外れ値を扱えるが、インライアと外れ値を区別するためのしきい値を必要とする。LMeDS法はしきい値を必要としないが、インライアが50%を超える場合にのみ正しく動作する。最後に、外れ値がなくノイズがかなり小さい場合は、デフォルトの手法（method=0）を使用する。

この関数は、内部行列と外部行列の初期値を求めるために使用される。ホモグラフィ行列はスケールを除いて決定される。\(h_{33}\) が非ゼロの場合、行列は \(h_{33}=1\) となるように正規化される。

覚え書き

\(H\) 行列が推定できない場合は、空の行列が返される。

参照

getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

findHomography() [2/3]

Mat cv::findHomography	(	InputArray	srcPoints,
		InputArray	dstPoints,
		OutputArray	mask,
		const UsacParams &	params )

Python:
	cv.findHomography(	srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask[, maxIters[, confidence]]]]]	) ->	retval, mask
	cv.findHomography(	srcPoints, dstPoints, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

findHomography() [3/3]

Mat cv::findHomography	(	InputArray	srcPoints,
		InputArray	dstPoints,
		OutputArray	mask,
		int	method = 0,
		double	ransacReprojThreshold = 3 )

Python:
	cv.findHomography(	srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask[, maxIters[, confidence]]]]]	) ->	retval, mask
	cv.findHomography(	srcPoints, dstPoints, params[, mask]	) ->	retval, mask

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

getDefaultNewCameraMatrix()

Mat cv::getDefaultNewCameraMatrix	(	InputArray	cameraMatrix,
		Size	imgsize = Size(),
		bool	centerPrincipalPoint = false )

Python:
	cv.getDefaultNewCameraMatrix(	cameraMatrix[, imgsize[, centerPrincipalPoint]]	) ->	retval

#include <opencv2/calib3d.hpp>

デフォルトの新しいカメラ行列を返す。

この関数は、入力cameraMatrixの正確なコピー（centerPrinicipalPoint=falseの場合）か、変更されたもの（centerPrincipalPoint=trueの場合）のいずれかのカメラ行列を返す。

後者の場合、新しいカメラ行列は次のようになる:

\[\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5 \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5 \\ 0 && 0 && 1 \end{bmatrix} ,\]

ここで \(f_x\) と \(f_y\) はそれぞれ cameraMatrix の \((0,0)\) 要素と \((1,1)\) 要素である。

デフォルトでは、OpenCV の歪み補正関数（initUndistortRectifyMap, undistort を参照）は主点を移動しない。しかしステレオを扱う場合、両方のビューの主点を同じ y 座標へ移動することが重要であり（これはほとんどのステレオ対応付けアルゴリズムで必要とされる）、同じ x 座標へ移動してもよい。そこで、各ビューについて主点が中心に位置するように新しいカメラ行列を構成できる。

引数

cameraMatrix	入力カメラ行列。
imgsize	カメラビュー画像のサイズ（ピクセル単位）。
centerPrincipalPoint	新しいカメラ行列における主点の位置。この引数は、この位置を画像中心にすべきかどうかを示す。

getOptimalNewCameraMatrix()

Mat cv::getOptimalNewCameraMatrix	(	InputArray	cameraMatrix,
		InputArray	distCoeffs,
		Size	imageSize,
		double	alpha,
		Size	newImgSize = Size(),
		Rect *	validPixROI = 0,
		bool	centerPrincipalPoint = false )

Python:
	cv.getOptimalNewCameraMatrix(	cameraMatrix, distCoeffs, imageSize, alpha[, newImgSize[, centerPrincipalPoint]]	) ->	retval, validPixROI

#include <opencv2/calib3d.hpp>

自由スケーリングパラメータに基づく新しいカメラ内部行列を返す。

引数

cameraMatrix	入力カメラ内部行列。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
imageSize	元の画像サイズ。
alpha	0（歪み補正後の画像内のすべてのピクセルが有効な場合）から 1（元画像のすべてのピクセルが歪み補正後の画像に保持される場合）までの自由スケーリング引数。詳細は stereoRectify を参照。
newImgSize	平行化後の画像サイズ。デフォルトでは imageSize に設定される。
validPixROI	歪み補正後の画像内ですべて良好なピクセル領域を囲む省略可能な出力矩形。stereoRectify の roi1, roi2 の説明を参照。
centerPrincipalPoint	新しいカメラ内部行列において主点を画像中心にすべきかどうかを示す省略可能なフラグ。デフォルトでは、主点は元画像の一部（alpha によって決定される）を補正後の画像に最も良く合わせるように選択される。

戻り値

new_camera_matrix 出力される新しいカメラ内部行列。

この関数は、自由スケーリングパラメータに基づいて最適な新しいカメラ内部行列を計算して返す。このパラメータを変化させることで、意味のあるピクセルのみを得る（alpha=0）、コーナーに有用な情報がある場合に元の画像のすべてのピクセルを保持する（alpha=1）、あるいはその中間を得ることができる。alpha>0 の場合、歪み補正された結果には、取得した歪み画像の外側にある「仮想的な」ピクセルに対応する黒いピクセルが含まれる可能性がある。元のカメラ内部行列、歪み係数、計算された新しいカメラ内部行列、および newImageSize を initUndistortRectifyMap に渡して、remap 用のマップを生成する。

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/calib3d.hpp>

平行化された画像の有効 ROI（stereoRectify によって返される）から、有効な視差 ROI を計算する。

initCameraMatrix2D()

Mat cv::initCameraMatrix2D	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints,
		Size	imageSize,
		double	aspectRatio = 1.0 )

Python:
	cv.initCameraMatrix2D(	objectPoints, imagePoints, imageSize[, aspectRatio]	) ->	retval

#include <opencv2/calib3d.hpp>

3D-2D 点対応から初期カメラ内部行列を求める。

引数

objectPoints	キャリブレーションパターン座標空間におけるキャリブレーションパターン点のベクトルのベクトル。旧インターフェースでは、ビューごとのすべてのベクトルが連結される。詳細は calibrateCamera を参照。
imagePoints	キャリブレーションパターン点の投影のベクトルのベクトル。旧インターフェースでは、ビューごとのすべてのベクトルが連結される。
imageSize	主点の初期化に使用される画像サイズ（ピクセル単位）。
aspectRatio	0 または負の場合、\(f_x\) と \(f_y\) は独立に推定される。それ以外の場合は \(f_x = f_y \cdot \texttt{aspectRatio}\) となる。

この関数は、カメラキャリブレーション処理のための初期カメラ内部行列を推定して返す。現在のところ、この関数は平面キャリブレーションパターン、すなわち各物体点の z 座標が 0 であるパターンのみをサポートする。

initInverseRectificationMap()

void cv::initInverseRectificationMap	(	InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	R,
		InputArray	newCameraMatrix,
		const Size &	size,
		int	m1type,
		OutputArray	map1,
		OutputArray	map2 )

Python:
	cv.initInverseRectificationMap(	cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type[, map1[, map2]]	) ->	map1, map2

#include <opencv2/calib3d.hpp>

射影および逆平行化変換マップを計算する。本質的には、これはプロジェクタ・カメラペアにおけるプロジェクタ（「逆カメラ」）のステレオ平行化に対応するための、initUndistortRectifyMap の逆変換である。

この関数は、射影と逆平行化を結合した変換を計算し、その結果を remap 用のマップの形で表現する。射影された画像は元画像の歪んだ版のように見え、いったんプロジェクタによって投影されると、視覚的に元画像と一致するはずである。単眼カメラの場合、newCameraMatrix は通常 cameraMatrix と等しいが、スケーリングをより細かく制御するために getOptimalNewCameraMatrix で計算することもできる。プロジェクタ・カメラペアの場合、newCameraMatrix は通常、stereoRectify によって計算される P1 または P2 に設定される。

プロジェクタは R に従って座標空間内で異なる向きに配置される。プロジェクタ・カメラペアの場合、これは（カメラに対する initUndistortRectifyMap と同様に）プロジェクタを位置合わせし、ステレオ平行化されたペアを作成するのに役立つ。これにより、両画像のエピポーラ線が水平になり、同じ y 座標を持つようになる（水平に整列したプロジェクタ・カメラペアの場合）。

この関数は、remap で使用される逆写像アルゴリズムのためのマップを構築する。すなわち、出力（射影および逆平行化）画像の各ピクセル \((u, v)\) について、入力画像（すなわち元のデジタル画像）における対応座標を計算する。次の処理が適用される。

\[ \begin{array}{l} \text{newCameraMatrix}\\ x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\ \\\text{Undistortion} \\\scriptsize{\textit{though equation shown is for radial undistortion, function implements cv::undistortPoints()}}\\ r^2 \leftarrow x^2 + y^2 \\ \theta \leftarrow \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}\\ x' \leftarrow \frac{x}{\theta} \\ y' \leftarrow \frac{y}{\theta} \\ \\\text{Rectification}\\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x'' \leftarrow X/W \\ y'' \leftarrow Y/W \\ \\\text{cameraMatrix}\\ map_x(u,v) \leftarrow x'' f_x + c_x \\ map_y(u,v) \leftarrow y'' f_y + c_y \end{array} \]

ここで \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) は歪み係数ベクトル distCoeffs である。

ステレオ平行化されたプロジェクタ・カメラペアの場合、この関数はプロジェクタに対して呼び出され、一方でカメラヘッドに対しては initUndistortRectifyMap が呼び出される。これは stereoRectify の後に行われ、それ自体は stereoCalibrate の後に呼び出される。プロジェクタ・カメラペアがキャリブレーションされていない場合でも、stereoRectifyUncalibrated を用いて基礎行列から平行化変換を直接計算することは可能である。プロジェクタとカメラについて、この関数は 3D 空間における回転行列 R ではなく、ピクセル領域における平行化変換としてのホモグラフィ H を計算する。R は H から次のように計算できる。

\[\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\]

ここで cameraMatrix は任意に選択できる。

引数

cameraMatrix	入力カメラ行列 \(A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs	歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
R	オブジェクト空間における省略可能な平行化変換（3x3 行列）。stereoRectify で計算した R1 または R2 をここに渡せる。行列が空の場合、恒等変換と仮定される。
newCameraMatrix	新しいカメラ行列 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\)。
size	歪んだ画像のサイズ。
m1type	1 つ目の出力マップの型。CV_32FC1, CV_32FC2, または CV_16SC2 を指定できる。convertMaps を参照
map1	remap 用の 1 つ目の出力マップ。
map2	remap 用の 2 つ目の出力マップ。

initUndistortRectifyMap()

void cv::initUndistortRectifyMap	(	InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	R,
		InputArray	newCameraMatrix,
		Size	size,
		int	m1type,
		OutputArray	map1,
		OutputArray	map2 )

Python:
	cv.initUndistortRectifyMap(	cameraMatrix, distCoeffs, R, newCameraMatrix, size, m1type[, map1[, map2]]	) ->	map1, map2

#include <opencv2/calib3d.hpp>

歪み補正および平行化変換マップを計算する。

この関数は、歪み補正と平行化を結合した変換を計算し、その結果を remap 用のマップの形で表現する。歪み補正された画像は、カメラ行列 =newCameraMatrix を用い歪みがゼロのカメラで撮影したかのように、元画像のように見える。単眼カメラの場合、newCameraMatrix は通常 cameraMatrix と等しいが、スケーリングをより細かく制御するために getOptimalNewCameraMatrix で計算することもできる。ステレオカメラの場合、newCameraMatrix は通常、stereoRectify によって計算される P1 または P2 に設定される。

また、この新しいカメラは R に従って座標空間内で異なる向きに配置される。これは例えば、ステレオカメラの 2 つのヘッドを位置合わせし、両画像のエピポーラ線が水平になり同じ y 座標を持つようにするのに役立つ（水平に整列したステレオカメラの場合）。

この関数は、実際には remap で使用される逆写像アルゴリズムのためのマップを構築する。すなわち、出力（補正および平行化）画像の各ピクセル \((u, v)\) について、入力画像（すなわちカメラからの元画像）における対応座標を計算する。次の処理が適用される。

\[ \begin{array}{l} x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\ {[X\,Y\,W]} ^T \leftarrow R^{-1}*[x \, y \, 1]^T \\ x' \leftarrow X/W \\ y' \leftarrow Y/W \\ r^2 \leftarrow x'^2 + y'^2 \\ x'' \leftarrow x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2p_1 x' y' + p_2(r^2 + 2 x'^2) + s_1 r^2 + s_2 r^4\\ y'' \leftarrow y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\ s\vecthree{x'''}{y'''}{1} = \vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}((\tau_x, \tau_y)} {0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)} {0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\\ map_x(u,v) \leftarrow x''' f_x + c_x \\ map_y(u,v) \leftarrow y''' f_y + c_y \end{array} \]

ここで \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) は歪み係数である。

ステレオカメラの場合、この関数は各カメラヘッドに対して一度ずつ、計 2 回呼び出され、stereoRectify の後に実行される。stereoRectify はさらに stereoCalibrate の後に呼び出される。ただしステレオカメラがキャリブレーションされていない場合でも、stereoRectifyUncalibrated を用いて基礎行列から平行化変換を直接計算することは可能である。各カメラについて、この関数は 3D 空間における回転行列 R ではなく、ピクセル領域における平行化変換としてのホモグラフィ H を計算する。R は H から次のように計算できる。

\[\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\]

ここで cameraMatrix は任意に選択できる。

引数

cameraMatrix	入力カメラ行列 \(A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs	歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
R	オブジェクト空間における省略可能な平行化変換（3x3 行列）。stereoRectify で計算した R1 または R2 をここに渡せる。行列が空の場合、恒等変換と仮定される。initUndistortRectifyMap では R は単位行列と仮定される。
newCameraMatrix	新しいカメラ行列 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\)。
size	歪み補正後の画像サイズ。
m1type	1 つ目の出力マップの型。CV_32FC1, CV_32FC2, または CV_16SC2 を指定できる。convertMaps を参照
map1	1つ目の出力マップ。
map2	2つ目の出力マップ。

initWideAngleProjMap() [1/2]

float cv::initWideAngleProjMap	(	InputArray	cameraMatrix,
		InputArray	distCoeffs,
		Size	imageSize,
		int	destImageWidth,
		int	m1type,
		OutputArray	map1,
		OutputArray	map2,
		enum UndistortTypes	projType = PROJ_SPHERICAL_EQRECT,
		double	alpha = 0 )

#include <opencv2/calib3d.hpp>

広角用に remap 用のマップを初期化する。

initWideAngleProjMap() [2/2]

static float cv::initWideAngleProjMap ( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha = 0 )

inlinestatic

#include <opencv2/calib3d.hpp>

この関数の呼び出しグラフ:

matMulDeriv()

void cv::matMulDeriv	(	InputArray	A,
		InputArray	B,
		OutputArray	dABdA,
		OutputArray	dABdB )

Python:
	cv.matMulDeriv(	A, B[, dABdA[, dABdB]]	) ->	dABdA, dABdB

#include <opencv2/calib3d.hpp>

乗算される各行列について、行列積の偏微分を計算する。

引数

A	1 つ目の乗算される行列。
B	2 つ目の乗算される行列。
dABdA	サイズ \(\texttt{A.rows*B.cols} \times {A.rows*A.cols}\) の 1 つ目の出力導関数行列 d(A*B)/dA 。
dABdB	サイズ \(\texttt{A.rows*B.cols} \times {B.rows*B.cols}\) の 2 つ目の出力導関数行列 d(A*B)/dB 。

この関数は、2 つの入力行列それぞれの要素に関して、行列積 \(A*B\) の要素の偏微分を計算する。この関数は stereoCalibrate においてヤコビ行列を計算するために使用されるが、他の類似した最適化関数でも使用できる。

projectPoints()

void cv::projectPoints	(	InputArray	objectPoints,
		InputArray	rvec,
		InputArray	tvec,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArray	imagePoints,
		OutputArray	jacobian = noArray(),
		double	aspectRatio = 0 )

Python:
	cv.projectPoints(	objectPoints, rvec, tvec, cameraMatrix, distCoeffs[, imagePoints[, jacobian[, aspectRatio]]]	) ->	imagePoints, jacobian

#include <opencv2/calib3d.hpp>

3D 点を画像平面に射影する。

引数

objectPoints	ワールド座標系を基準として表されたオブジェクト点の配列。3xN/Nx3 の 1 チャンネルまたは 1xN/Nx1 の 3 チャンネル（または vector<Point3f> ）で、N はビュー内の点の数。
rvec	tvec とともに、ワールド座標系からカメラ座標系への基底変換を行う回転ベクトル（Rodrigues）。詳細は calibrateCamera を参照。
tvec	並進ベクトル。上記の引数の説明を参照。
cameraMatrix	カメラの内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\) 。ベクトルが空の場合、歪み係数は 0 と仮定される。
imagePoints	画像点の出力配列。1xN/Nx1 の2チャンネル、または vector<Point2f> 。
jacobian	省略可能な出力で、画像点を回転ベクトル・並進ベクトル・焦点距離・主点座標・歪み係数の各成分で微分した 2Nx(10+<numDistCoeffs>) のヤコビ行列。旧インターフェースでは、ヤコビ行列の各成分が異なる出力パラメータを通して返される。
aspectRatio	省略可能な「固定アスペクト比」パラメータ。このパラメータが0でない場合、関数はアスペクト比 ( \(f_x / f_y\)) が固定であると仮定し、それに応じてヤコビ行列を調整する。

この関数は、カメラの内部および外部パラメータが与えられたとき、3D 点の画像平面への 2D 射影を計算する。オプションとして、特定のパラメータ（内部および／または外部）に関する画像点座標の偏微分行列であるヤコビアンを計算する。ヤコビアンは calibrateCamera, solvePnP, および stereoCalibrate における大域的最適化中に使用される。この関数自体は、現在の内部および外部パラメータが与えられたときに再投影誤差を計算するためにも使用できる。

覚え書き

rvec = tvec = \([0, 0, 0]\) と設定する、cameraMatrix を 3x3 単位行列に設定する、あるいはゼロの歪み係数を渡すことで、この関数のさまざまな有用な部分的ケースを得ることができる。これは、点の疎な集合に対して歪み座標を計算したり、理想的な歪みゼロの設定で透視変換を適用したり（さらに微分を計算したり）できることを意味する。

recoverPose() [1/4]

int cv::recoverPose	(	InputArray	E,
		InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix,
		OutputArray	R,
		OutputArray	t,
		double	distanceThresh,
		InputOutputArray	mask = noArray(),
		OutputArray	triangulatedPoints = noArray() )

Python:
	cv.recoverPose(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, E[, R[, t[, method[, prob[, threshold[, mask]]]]]]]	) ->	retval, E, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix[, R[, t[, mask]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2[, R[, t[, focal[, pp[, mask]]]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix, distanceThresh[, R[, t[, mask[, triangulatedPoints]]]]	) ->	retval, R, t, mask, triangulatedPoints

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

E	入力の基本行列。
points1	1枚目の画像に含まれるN個の2D点の配列。点の座標は浮動小数点(単精度または倍精度)である必要がある。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
cameraMatrix	カメラ内部行列 \(\cameramatrix{A}\) 。この関数は、points1 と points2 が同一のカメラ内部行列を持つカメラから得られた特徴点であることを前提とする点に注意する。
R	出力の回転行列。並進ベクトルと組み合わせることで、この行列は1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行うタプルを構成する。一般に、このタプルに t を用いることはできない点に注意する。下記のパラメータ説明を参照。
t	出力の並進ベクトル。このベクトルは decomposeEssentialMat によって得られるため、スケールを除いてのみ既知である。すなわち t は並進ベクトルの方向を表し、単位長さを持つ。
distanceThresh	遠方の点(すなわち無限遠点)を除外するために用いるしきい値距離。
mask	points1 と points2 のインライアに対する入出力マスク。空でない場合、与えられた基本行列 E に対する points1 と points2 のインライアを示す。これらのインライアのみが姿勢復元に用いられる。出力マスクには、キラリティチェックを通過したインライアのみが残る。
triangulatedPoints	三角測量によって再構成された3D点。

この関数は前述の関数と異なり、カイラリティチェックに使用される三角測量された 3D 点を出力する。

recoverPose() [2/4]

int cv::recoverPose	(	InputArray	E,
		InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix,
		OutputArray	R,
		OutputArray	t,
		InputOutputArray	mask = noArray() )

Python:
	cv.recoverPose(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, E[, R[, t[, method[, prob[, threshold[, mask]]]]]]]	) ->	retval, E, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix[, R[, t[, mask]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2[, R[, t[, focal[, pp[, mask]]]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix, distanceThresh[, R[, t[, mask[, triangulatedPoints]]]]	) ->	retval, R, t, mask, triangulatedPoints

#include <opencv2/calib3d.hpp>

推定された基本行列と 2 枚の画像内の対応点から、カイラリティチェックを用いてカメラの相対回転と並進を復元する。チェックを通過したインライアの数を返す。

引数

E	入力の基本行列。
points1	1枚目の画像に含まれるN個の2D点の配列。点の座標は浮動小数点(単精度または倍精度)である必要がある。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
cameraMatrix	カメラ内部行列 \(\cameramatrix{A}\) 。この関数は、points1 と points2 が同一のカメラ内部行列を持つカメラから得られた特徴点であることを前提とする点に注意する。
R	出力の回転行列。並進ベクトルと組み合わせることで、この行列は1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行うタプルを構成する。一般に、このタプルに t を用いることはできない点に注意する。下記で説明するパラメータを参照。
t	出力の並進ベクトル。このベクトルは decomposeEssentialMat によって得られるため、スケールを除いてのみ既知である。すなわち t は並進ベクトルの方向を表し、単位長さを持つ。
mask	points1 と points2 のインライアに対する入出力マスク。空でない場合、与えられた基本行列 E に対する points1 と points2 のインライアを示す。これらのインライアのみが姿勢復元に用いられる。出力マスクには、キラリティチェックを通過したインライアのみが残る。

この関数は decomposeEssentialMat を用いて基本行列を分解し、その後カイラリティチェックを行うことで可能な姿勢仮説を検証する。カイラリティチェックとは、三角測量された 3D 点が正の深度を持つべきだということを意味する。詳細は [214] に記載されている。

この関数は、findEssentialMat の出力である E と mask を処理するために使用できる。このシナリオでは、points1 と points2 は findEssentialMat への同じ入力である。

// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
    points1[i] = ...;
    points2[i] = ...;
}
 
// cametra matrix with both focal lengths = 1, and principal point = (0, 0)
Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
 
Mat E, R, t, mask;
 
E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask);
recoverPose(E, points1, points2, cameraMatrix, R, t, mask);

recoverPose() [3/4]

int cv::recoverPose	(	InputArray	E,
		InputArray	points1,
		InputArray	points2,
		OutputArray	R,
		OutputArray	t,
		double	focal = 1.0,
		Point2d	pp = Point2d(0, 0),
		InputOutputArray	mask = noArray() )

Python:
	cv.recoverPose(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, E[, R[, t[, method[, prob[, threshold[, mask]]]]]]]	) ->	retval, E, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix[, R[, t[, mask]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2[, R[, t[, focal[, pp[, mask]]]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix, distanceThresh[, R[, t[, mask[, triangulatedPoints]]]]	) ->	retval, R, t, mask, triangulatedPoints

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

E	入力の基本行列。
points1	1枚目の画像に含まれるN個の2D点の配列。点の座標は浮動小数点(単精度または倍精度)である必要がある。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
R	出力の回転行列。並進ベクトルと組み合わせることで、この行列は1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行うタプルを構成する。一般に、このタプルに t を用いることはできない点に注意する。下記のパラメータ説明を参照。
t	出力の並進ベクトル。このベクトルは decomposeEssentialMat によって得られるため、スケールを除いてのみ既知である。すなわち t は並進ベクトルの方向を表し、単位長さを持つ。
focal	カメラの焦点距離。この関数は、points1 と points2 が同一の焦点距離と主点を持つカメラから得られた特徴点であることを前提とする点に注意する。
pp	カメラの主点。
mask	points1 と points2 のインライアに対する入出力マスク。空でない場合、与えられた基本行列 E に対する points1 と points2 のインライアを示す。これらのインライアのみが姿勢復元に用いられる。出力マスクには、キラリティチェックを通過したインライアのみが残る。

この関数は、焦点距離と主点からカメラ内部行列を計算する点で上記の関数と異なる:

\[A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\]

recoverPose() [4/4]

int cv::recoverPose	(	InputArray	points1,
		InputArray	points2,
		InputArray	cameraMatrix1,
		InputArray	distCoeffs1,
		InputArray	cameraMatrix2,
		InputArray	distCoeffs2,
		OutputArray	E,
		OutputArray	R,
		OutputArray	t,
		int	method = cv::RANSAC,
		double	prob = 0.999,
		double	threshold = 1.0,
		InputOutputArray	mask = noArray() )

Python:
	cv.recoverPose(	points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2[, E[, R[, t[, method[, prob[, threshold[, mask]]]]]]]	) ->	retval, E, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix[, R[, t[, mask]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2[, R[, t[, focal[, pp[, mask]]]]]	) ->	retval, R, t, mask
	cv.recoverPose(	E, points1, points2, cameraMatrix, distanceThresh[, R[, t[, mask[, triangulatedPoints]]]]	) ->	retval, R, t, mask, triangulatedPoints

#include <opencv2/calib3d.hpp>

2 台の異なるカメラによる 2 枚の画像内の対応点から、カイラリティチェックを用いてカメラの相対回転と並進を復元する。チェックを通過したインライアの数を返す。

引数

points1	1枚目の画像に含まれるN個の2D点の配列。点の座標は浮動小数点(単精度または倍精度)である必要がある。
points2	points1 と同じサイズおよび形式の、2 枚目の画像の点の配列。
cameraMatrix1	1台目のカメラの入出力カメラ行列。calibrateCamera と同様。さらに、ステレオの場合は追加のフラグを使用できる。下記を参照。
distCoeffs1	歪み係数の入出力ベクトル。calibrateCamera と同様。
cameraMatrix2	1台目のカメラの入出力カメラ行列。calibrateCamera と同様。さらに、ステレオの場合は追加のフラグを使用できる。下記を参照。
distCoeffs2	歪み係数の入出力ベクトル。calibrateCamera と同様。
E	出力の基本行列。
R	出力の回転行列。並進ベクトルと組み合わせることで、この行列は1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行うタプルを構成する。一般に、このタプルに t を用いることはできない点に注意する。下記で説明するパラメータを参照。
t	出力の並進ベクトル。このベクトルは decomposeEssentialMat によって得られるため、スケールを除いてのみ既知である。すなわち t は並進ベクトルの方向を表し、単位長さを持つ。
method	基本行列を計算するための手法。 RANSAC RANSAC アルゴリズム。 LMEDS LMedS アルゴリズム。
prob	RANSAC または LMedS 手法でのみ使用される引数。推定された行列が正しいという望ましい信頼水準（確率）を指定する。
threshold	RANSAC で使用される引数。点からエピポーラ線までの最大距離（ピクセル単位）であり、これを超える点はアウトライアとみなされ、最終的な基礎行列の計算には使用されない。点の位置特定の精度、画像の解像度、画像のノイズに応じて、1〜3 程度の値に設定できる。
mask	points1 と points2 のインライアに対する入出力マスク。空でない場合、与えられた基本行列 E に対する points1 と points2 のインライアを示す。これらのインライアのみが姿勢復元に用いられる。出力マスクには、キラリティチェックを通過したインライアのみが残る。

この関数は decomposeEssentialMat を用いて基本行列を分解し、その後カイラリティチェックを行うことで可能な姿勢仮説を検証する。カイラリティチェックとは、三角測量された 3D 点が正の深度を持つべきだということを意味する。詳細は [214] に記載されている。

この関数は、findEssentialMat の出力である E と mask を処理するために使用できる。このシナリオでは、points1 と points2 は findEssentialMat への同じ入力である。

// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
    points1[i] = ...;
    points2[i] = ...;
}
 
// Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 
// Output: Essential matrix, relative rotation and relative translation.
Mat E, R, t, mask;
 
recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);

rectify3Collinear()

float cv::rectify3Collinear	(	InputArray	cameraMatrix1,
		InputArray	distCoeffs1,
		InputArray	cameraMatrix2,
		InputArray	distCoeffs2,
		InputArray	cameraMatrix3,
		InputArray	distCoeffs3,
		InputArrayOfArrays	imgpt1,
		InputArrayOfArrays	imgpt3,
		Size	imageSize,
		InputArray	R12,
		InputArray	T12,
		InputArray	R13,
		InputArray	T13,
		OutputArray	R1,
		OutputArray	R2,
		OutputArray	R3,
		OutputArray	P1,
		OutputArray	P2,
		OutputArray	P3,
		OutputArray	Q,
		double	alpha,
		Size	newImgSize,
		Rect *	roi1,
		Rect *	roi2,
		int	flags )

Python:
	cv.rectify3Collinear(	cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, cameraMatrix3, distCoeffs3, imgpt1, imgpt3, imageSize, R12, T12, R13, T13, alpha, newImgSize, flags[, R1[, R2[, R3[, P1[, P2[, P3[, Q]]]]]]]	) ->	retval, R1, R2, R3, P1, P2, P3, Q, roi1, roi2

#include <opencv2/calib3d.hpp>

すべてのヘッドが同一直線上にある 3 ヘッドカメラに対する平行化変換を計算する。

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/calib3d.hpp>

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

引数

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

Rodrigues()

void cv::Rodrigues	(	InputArray	src,
		OutputArray	dst,
		OutputArray	jacobian = noArray() )

Python:
	cv.Rodrigues(	src[, dst[, jacobian]]	) ->	dst, jacobian

#include <opencv2/calib3d.hpp>

回転行列を回転ベクトルに、またはその逆に変換する。

引数

src	入力の回転ベクトル (3x1 または 1x3) もしくは回転行列 (3x3)。
dst	出力の回転行列 (3x3) もしくは回転ベクトル (3x1 または 1x3)。それぞれ入力に対応する。
jacobian	省略可能な出力ヤコビ行列 (3x9 または 9x3)。出力配列の成分を入力配列の成分で偏微分した行列である。

\[\begin{array}{l} \theta \leftarrow norm(r) \\ r \leftarrow r/ \theta \\ R = \cos(\theta) I + (1- \cos{\theta} ) r r^T + \sin(\theta) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}\]

逆変換も同様に簡単に行える。なぜなら

\[\sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}\]

回転ベクトルは、回転行列の便利で最もコンパクトな表現である（どの回転行列も自由度はわずか 3 だからである）。この表現は、calibrateCamera, stereoCalibrate, または solvePnP のような大域的 3D 幾何最適化手続きで使用される。

覚え書き

More information about the computation of the derivative of a 3D rotation matrix with respect to its exponential coordinate can be found in:

• A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi [100]

Useful information on SE(3) and Lie Groups can be found in:

• A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco [31]
• Lie Groups for 2D and 3D Transformation, Ethan Eade [82]
• A micro Lie theory for state estimation in robotics, Joan Solà, Jérémie Deray, Dinesh Atchuthan [255]

RQDecomp3x3()

Vec3d cv::RQDecomp3x3	(	InputArray	src,
		OutputArray	mtxR,
		OutputArray	mtxQ,
		OutputArray	Qx = noArray(),
		OutputArray	Qy = noArray(),
		OutputArray	Qz = noArray() )

Python:
	cv.RQDecomp3x3(	src[, mtxR[, mtxQ[, Qx[, Qy[, Qz]]]]]	) ->	retval, mtxR, mtxQ, Qx, Qy, Qz

#include <opencv2/calib3d.hpp>

3x3 行列の RQ 分解を計算する。

引数

src	3x3 の入力行列。
mtxR	出力の 3x3 上三角行列。
mtxQ	出力の 3x3 直交行列。
Qx	省略可能な出力で、x軸まわりの 3x3 回転行列。
Qy	省略可能な出力で、y軸まわりの 3x3 回転行列。
Qz	省略可能な出力で、z軸まわりの 3x3 回転行列。

この関数は、与えられた回転を用いて RQ 分解を計算する。この関数は decomposeProjectionMatrix において、射影行列の左 3x3 部分行列をカメラ行列と回転行列に分解するために使用される。

オプションとして、各軸に 1 つずつ計 3 つの回転行列と、OpenGL で使用できる 3 つのオイラー角（度単位、戻り値として）を返す。なお、物体の同じ姿勢をもたらす 3 つの主軸まわりの回転シーケンスは常に複数存在することに注意する。例えば [254] を参照。返される 3 つの回転行列と対応する 3 つのオイラー角は、可能な解の 1 つにすぎない。

sampsonDistance()

double cv::sampsonDistance	(	InputArray	pt1,
		InputArray	pt2,
		InputArray	F )

Python:
	cv.sampsonDistance(	pt1, pt2, F	) ->	retval

#include <opencv2/calib3d.hpp>

2 点間のサンプソン距離を計算する。

関数 cv::sampsonDistance は、幾何誤差の 1 次近似を次のように計算して返す。

\[ sd( \texttt{pt1} , \texttt{pt2} )= \frac{(\texttt{pt2}^t \cdot \texttt{F} \cdot \texttt{pt1})^2} {((\texttt{F} \cdot \texttt{pt1})(0))^2 + ((\texttt{F} \cdot \texttt{pt1})(1))^2 + ((\texttt{F}^t \cdot \texttt{pt2})(0))^2 + ((\texttt{F}^t \cdot \texttt{pt2})(1))^2} \]

基礎行列は findFundamentalMat 関数を用いて計算できる。詳細は [120] の 11.4.3 を参照。

引数

pt1	1番目の同次2D点。
pt2	2番目の同次2D点。
F	基礎行列。

戻り値

計算されたサンプソン距離。

solveP3P()

int cv::solveP3P	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		int	flags )

Python:
	cv.solveP3P(	objectPoints, imagePoints, cameraMatrix, distCoeffs, flags[, rvecs[, tvecs]]	) ->	retval, rvecs, tvecs

#include <opencv2/calib3d.hpp>

3 組の 3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。

Perspective projection, from object to camera frame

参照

Perspective-n-Point (PnP) による姿勢推定

引数

objectPoints	物体座標空間における物体点の配列。3x3 1チャンネル、または 1x3/3x1 3チャンネル。vector<Point3f> をここに渡すこともできる。
imagePoints	対応する画像点の配列。3x2 1チャンネル、または 1x3/3x1 2チャンネル。vector<Point2f> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvecs	出力の回転ベクトル(Rodrigues を参照)。tvecs と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。P3P問題は最大4個の解を持つ。
tvecs	出力の並進ベクトル。
flags	P3P問題を解くための手法: SOLVEPNP_P3P Ding, Y., Yang, J., Larsson, V., Olsson, C., & Åstrom, K. の論文 "Revisiting the P3P Problem" ([73]) に基づく手法。 SOLVEPNP_AP3P T. Ke と S. Roumeliotis の論文 "An Efficient Algebraic Solution to the Perspective-Three-Point Problem" ([150]) に基づく手法。

この関数は、3 つの物体点、それらに対応する画像投影、ならびにカメラ内部行列と歪み係数が与えられたとき、物体姿勢を推定する。

覚え書き

解は再投影誤差の小さい順(低い順から高い順)にソートされる。

solvePnP()

bool cv::solvePnP	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArray	rvec,
		OutputArray	tvec,
		bool	useExtrinsicGuess = false,
		int	flags = SOLVEPNP_ITERATIVE )

Python:
	cv.solvePnP(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, flags]]]]	) ->	retval, rvec, tvec

#include <opencv2/calib3d.hpp>

3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。

Perspective projection, from object to camera frame

参照

Perspective-n-Point (PnP) による姿勢推定

この関数は、物体座標系で表された 3D 点をカメラ座標系へ変換する回転ベクトルと並進ベクトルを、さまざまな手法を用いて返す。

• P3P 手法（SOLVEPNP_P3P, SOLVEPNP_AP3P）: 一意の解を返すには 4 つの入力点が必要である。
• SOLVEPNP_IPPE 入力点は >= 4 でなければならず、物体点は同一平面上になければならない。
• SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation. Number of input points must be 4. Object points must be defined in the following order:
  • 点 0: [-squareLength / 2, squareLength / 2, 0]
  • 点 1: [ squareLength / 2, squareLength / 2, 0]
  • 点 2: [ squareLength / 2, -squareLength / 2, 0]
  • 点 3: [-squareLength / 2, -squareLength / 2, 0]
• それ以外のすべてのフラグでは、入力点の数は >= 4 でなければならず、オブジェクト点は任意の配置でよい。

引数

objectPoints	物体座標空間における物体点の配列。Nx3 1チャンネル、または 1xN/Nx1 3チャンネル(Nは点の個数)。vector<Point3d> をここに渡すこともできる。
imagePoints	対応する画像点の配列。Nx2 1チャンネル、または 1xN/Nx1 2チャンネル(Nは点の個数)。vector<Point2d> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvec	出力の回転ベクトル(Rodrigues を参照)。tvec と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。
tvec	出力の並進ベクトル。
useExtrinsicGuess	SOLVEPNP_ITERATIVE で用いられるパラメータ。true (1) の場合、関数は与えられた rvec と tvec の値を回転ベクトルと並進ベクトルの初期近似値として使用し、さらにそれらを最適化する。
flags	PnP問題を解くための手法。calib3d_solvePnP_flags を参照。

Perspective-n-Point に関する詳しい情報は Perspective-n-Point (PnP) による姿勢推定 に記載されている。

覚え書き

• 平面拡張現実に solvePnP を使用する方法の例は opencv_source_code/samples/python/plane_ar.py にある。
• If you are using Python:
  • Numpy 配列のスライスは入力として機能しない。solvePnP は連続した配列を必要とするためである（modules/calib3d/src/solvepnp.cpp バージョン 2.4.9 の 55 行目付近で cv::Mat::checkVector() を用いたアサーションで強制される）。
  • P3P アルゴリズムは、2 チャンネル情報を必要とする undistortPoints を呼び出す（modules/calib3d/src/solvepnp.cpp バージョン 2.4.9 の 75 行目付近）ため、画像点が形状 (N,1,2) の配列であることを必要とする。
  • したがって、D.shape = (N,M) であるデータ D = np.array(...) が与えられたとき、その一部を例えば imagePoints として使用するには、新しい配列にコピーする必要が実質的にある: imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
• SOLVEPNP_DLS と SOLVEPNP_UPNP の手法は使用できない。現在の実装は不安定で、まったく誤った結果を返すことがあるためである。これら 2 つのフラグのいずれかを渡した場合、代わりに SOLVEPNP_EPNP 手法が使用される。
• 一般的な場合、点の最小数は 4 である。SOLVEPNP_P3P および SOLVEPNP_AP3P 手法の場合、正確に 4 点を使用する必要がある（最初の 3 点は P3P 問題のすべての解を推定するために使用され、最後の 1 点は再投影誤差を最小化する最良の解を保持するために使用される）。
• SOLVEPNP_ITERATIVE 手法かつ useExtrinsicGuess=true の場合、点の最小数は 3 である（3 点で姿勢を計算するには十分だが、最大 4 つの解が存在する）。収束させるには、初期解が大域解に近い必要がある。何らかの解が見つかった場合、関数は true を返す。解の品質評価はユーザーのコードが担う。
• SOLVEPNP_IPPE では、入力点は >= 4 でなければならず、物体点は同一平面上になければならない。
• With SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation. Number of input points must be 4. Object points must be defined in the following order:
  • 点 0: [-squareLength / 2, squareLength / 2, 0]
  • 点 1: [ squareLength / 2, squareLength / 2, 0]
  • 点 2: [ squareLength / 2, -squareLength / 2, 0]
  • 点 3: [-squareLength / 2, -squareLength / 2, 0]
• SOLVEPNP_SQPNP では、入力点は >= 3 でなければならない。

solvePnPGeneric()

int cv::solvePnPGeneric	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		bool	useExtrinsicGuess = false,
		SolvePnPMethod	flags = SOLVEPNP_ITERATIVE,
		InputArray	rvec = noArray(),
		InputArray	tvec = noArray(),
		OutputArray	reprojectionError = noArray() )

Python:
	cv.solvePnPGeneric(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvecs[, tvecs[, useExtrinsicGuess[, flags[, rvec[, tvec[, reprojectionError]]]]]]]	) ->	retval, rvecs, tvecs, reprojectionError

#include <opencv2/calib3d.hpp>

3D-2D 点対応から物体姿勢 \( {}^{c}\mathbf{T}_o \) を求める。

Perspective projection, from object to camera frame

参照

Perspective-n-Point (PnP) による姿勢推定

この関数は、入力点の数と選択した手法に応じて、可能なすべての解のリスト（解は <回転ベクトル, 並進ベクトル> の組）を返す。

• P3P 手法（SOLVEPNP_P3P, SOLVEPNP_AP3P）: 3 または 4 つの入力点。3 つの入力点の場合、返される解の数は 0 から 4 の間になりうる。
• SOLVEPNP_IPPE 入力点は4個以上で、オブジェクト点は同一平面上になければならない。2つの解を返す。
• SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation. Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
  • 点 0: [-squareLength / 2, squareLength / 2, 0]
  • 点 1: [ squareLength / 2, squareLength / 2, 0]
  • 点 2: [ squareLength / 2, -squareLength / 2, 0]
  • 点 3: [-squareLength / 2, -squareLength / 2, 0]
• その他すべてのフラグでは、入力点の数は4個以上でなければならず、オブジェクト点は任意の配置でよい。返される解は1つだけである。

引数

objectPoints	物体座標空間における物体点の配列。Nx3 1チャンネル、または 1xN/Nx1 3チャンネル(Nは点の個数)。vector<Point3d> をここに渡すこともできる。
imagePoints	対応する画像点の配列。Nx2 1チャンネル、または 1xN/Nx1 2チャンネル(Nは点の個数)。vector<Point2d> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvecs	出力の回転ベクトル(Rodrigues を参照)のベクトル。tvecs と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。
tvecs	出力の並進ベクトルのベクトル。
useExtrinsicGuess	SOLVEPNP_ITERATIVE で用いられるパラメータ。true (1) の場合、関数は与えられた rvec と tvec の値を回転ベクトルと並進ベクトルの初期近似値として使用し、さらにそれらを最適化する。
flags	PnP問題を解くための手法。calib3d_solvePnP_flags を参照。
rvec	反復的なPnP精緻化アルゴリズムを初期化するために使用する回転ベクトル。フラグが SOLVEPNP_ITERATIVE で useExtrinsicGuess が true に設定されている場合に用いられる。
tvec	反復的なPnP精緻化アルゴリズムを初期化するために使用する並進ベクトル。フラグが SOLVEPNP_ITERATIVE で useExtrinsicGuess が true に設定されている場合に用いられる。
reprojectionError	省略可能な再投影誤差のベクトル。入力画像点と、推定姿勢で投影した3D物体点との間のRMS誤差( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \))である。

詳細は Perspective-n-Point (PnP) による姿勢推定 で説明されている。

覚え書き

• 平面拡張現実に solvePnP を使用する方法の例は opencv_source_code/samples/python/plane_ar.py にある。
• If you are using Python:
  • Numpy 配列のスライスは入力として機能しない。solvePnP は連続した配列を必要とするためである（modules/calib3d/src/solvepnp.cpp バージョン 2.4.9 の 55 行目付近で cv::Mat::checkVector() を用いたアサーションで強制される）。
  • P3P アルゴリズムは、2 チャンネル情報を必要とする undistortPoints を呼び出す（modules/calib3d/src/solvepnp.cpp バージョン 2.4.9 の 75 行目付近）ため、画像点が形状 (N,1,2) の配列であることを必要とする。
  • したがって、D.shape = (N,M) であるデータ D = np.array(...) が与えられたとき、その一部を例えば imagePoints として使用するには、新しい配列にコピーする必要が実質的にある: imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
• SOLVEPNP_DLS と SOLVEPNP_UPNP の手法は使用できない。現在の実装は不安定で、まったく誤った結果を返すことがあるためである。これら 2 つのフラグのいずれかを渡した場合、代わりに SOLVEPNP_EPNP 手法が使用される。
• 一般的な場合、点の最小数は 4 である。SOLVEPNP_P3P および SOLVEPNP_AP3P 手法の場合、正確に 4 点を使用する必要がある（最初の 3 点は P3P 問題のすべての解を推定するために使用され、最後の 1 点は再投影誤差を最小化する最良の解を保持するために使用される）。
• SOLVEPNP_ITERATIVE 法で useExtrinsicGuess=true の場合、点の最小数は3である(3点で姿勢を計算できるが、最大4つの解が存在しうる)。収束させるには初期解が大域解に近いことが望ましい。
• SOLVEPNP_IPPE では、入力点は >= 4 でなければならず、物体点は同一平面上になければならない。
• With SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation. Number of input points must be 4. Object points must be defined in the following order:
  • 点 0: [-squareLength / 2, squareLength / 2, 0]
  • 点 1: [ squareLength / 2, squareLength / 2, 0]
  • 点 2: [ squareLength / 2, -squareLength / 2, 0]
  • 点 3: [-squareLength / 2, -squareLength / 2, 0]
• SOLVEPNP_SQPNP では、入力点は >= 3 でなければならない。

solvePnPRansac() [1/2]

bool cv::solvePnPRansac	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArray	rvec,
		OutputArray	tvec,
		bool	useExtrinsicGuess = false,
		int	iterationsCount = 100,
		float	reprojectionError = 8.0,
		double	confidence = 0.99,
		OutputArray	inliers = noArray(),
		int	flags = SOLVEPNP_ITERATIVE )

Python:
	cv.solvePnPRansac(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, iterationsCount[, reprojectionError[, confidence[, inliers[, flags]]]]]]]]	) ->	retval, rvec, tvec, inliers
	cv.solvePnPRansac(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, inliers[, params]]]]	) ->	retval, cameraMatrix, rvec, tvec, inliers

#include <opencv2/calib3d.hpp>

不正なマッチに対処するためRANSACスキームを用いて、3D-2D点対応からオブジェクト姿勢 \( {}^{c}\mathbf{T}_o \) を求める。

Perspective projection, from object to camera frame

参照

Perspective-n-Point (PnP) による姿勢推定

引数

objectPoints	物体座標空間における物体点の配列。Nx3 1チャンネル、または 1xN/Nx1 3チャンネル(Nは点の個数)。vector<Point3d> をここに渡すこともできる。
imagePoints	対応する画像点の配列。Nx2 1チャンネル、または 1xN/Nx1 2チャンネル(Nは点の個数)。vector<Point2d> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvec	出力の回転ベクトル(Rodrigues を参照)。tvec と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。
tvec	出力の並進ベクトル。
useExtrinsicGuess	SOLVEPNP_ITERATIVE で用いられるパラメータ。true (1) の場合、関数は与えられた rvec と tvec の値を回転ベクトルと並進ベクトルの初期近似値として使用し、さらにそれらを最適化する。
iterationsCount	反復回数。
reprojectionError	RANSAC手続きで用いられるインライアのしきい値。このパラメータ値は、観測された点投影と計算された点投影の間で、インライアとみなすための最大許容距離である。
confidence	アルゴリズムが有用な結果を生成する確率。
inliers	objectPoints と imagePoints 内のインライアのインデックスを含む出力ベクトル。
flags	PnP問題を解くための手法(solvePnP を参照)。

この関数は、与えられたオブジェクト点の集合、それに対応する画像投影、ならびにカメラ内部行列と歪み係数からオブジェクト姿勢を推定する。この関数は再投影誤差、すなわち観測された投影 imagePoints と(projectPoints を用いて)投影された objectPoints との二乗距離の総和を最小化するような姿勢を求める。RANSACの利用により、この関数は外れ値に対して頑健になる。

覚え書き

• オブジェクト検出にsolvePnPRansacを使用する方法の例は テクスチャ付き物体のリアルタイム姿勢推定 にある。
• The default method used to estimate the camera pose for the Minimal Sample Sets step is SOLVEPNP_EPNP. Exceptions are:
  • SOLVEPNP_P3P または SOLVEPNP_AP3P を選択した場合、これらの手法が使用される。
  • 入力点の数が4に等しい場合、SOLVEPNP_P3P が使用される。
• すべてのインライアを用いてカメラ姿勢を推定する手法は、flags パラメータが SOLVEPNP_P3P または SOLVEPNP_AP3P に等しい場合を除き、flags パラメータによって定義される。この場合、代わりに SOLVEPNP_EPNP 法が使用される。

solvePnPRansac() [2/2]

bool cv::solvePnPRansac	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputOutputArray	cameraMatrix,
		InputArray	distCoeffs,
		OutputArray	rvec,
		OutputArray	tvec,
		OutputArray	inliers,
		const UsacParams &	params = UsacParams() )

Python:
	cv.solvePnPRansac(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, iterationsCount[, reprojectionError[, confidence[, inliers[, flags]]]]]]]]	) ->	retval, rvec, tvec, inliers
	cv.solvePnPRansac(	objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, inliers[, params]]]]	) ->	retval, cameraMatrix, rvec, tvec, inliers

#include <opencv2/calib3d.hpp>

solvePnPRefineLM()

void cv::solvePnPRefineLM	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputOutputArray	rvec,
		InputOutputArray	tvec,
		TermCriteria	criteria = TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON) )

Python:
	cv.solvePnPRefineLM(	objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec[, criteria]	) ->	rvec, tvec

#include <opencv2/calib3d.hpp>

3D-2D点対応から、初期解を起点として姿勢(オブジェクト座標系で表現された3D点をカメラ座標系へ変換する並進と回転)を精緻化する。

参照

Perspective-n-Point (PnP) による姿勢推定

引数

objectPoints	物体座標空間における物体点の配列。Nx3 1チャンネル、または 1xN/Nx1 3チャンネル(Nは点の個数)。vector<Point3d> をここに渡すこともできる。
imagePoints	対応する画像点の配列。Nx2 1チャンネル、または 1xN/Nx1 2チャンネル(Nは点の個数)。vector<Point2d> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvec	入出力の回転ベクトル(Rodrigues を参照)。tvec と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。入力値は初期解として使用される。
tvec	入出力の並進ベクトル。入力値は初期解として使用される。
criteria	Levenberg-Marquardt反復アルゴリズムを停止する条件。

この関数は、少なくとも3つのオブジェクト点、それに対応する画像投影、回転・並進ベクトルの初期解、ならびにカメラ内部行列と歪み係数を与えて、オブジェクト姿勢を精緻化する。この関数は、Levenberg-Marquardt法による反復最小化 [184] [81] の手順に従って、回転・並進ベクトルに関する投影誤差を最小化する。

solvePnPRefineVVS()

void cv::solvePnPRefineVVS	(	InputArray	objectPoints,
		InputArray	imagePoints,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputOutputArray	rvec,
		InputOutputArray	tvec,
		TermCriteria	criteria = TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON),
		double	VVSlambda = 1 )

Python:
	cv.solvePnPRefineVVS(	objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec[, criteria[, VVSlambda]]	) ->	rvec, tvec

#include <opencv2/calib3d.hpp>

3D-2D点対応から、初期解を起点として姿勢(オブジェクト座標系で表現された3D点をカメラ座標系へ変換する並進と回転)を精緻化する。

参照

Perspective-n-Point (PnP) による姿勢推定

引数

objectPoints	物体座標空間における物体点の配列。Nx3 1チャンネル、または 1xN/Nx1 3チャンネル(Nは点の個数)。vector<Point3d> をここに渡すこともできる。
imagePoints	対応する画像点の配列。Nx2 1チャンネル、または 1xN/Nx1 2チャンネル(Nは点の個数)。vector<Point2d> をここに渡すこともできる。
cameraMatrix	入力のカメラ内部行列 \(\cameramatrix{A}\) 。
distCoeffs	歪み係数の入力ベクトル \(\distcoeffs\)。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
rvec	入出力の回転ベクトル(Rodrigues を参照)。tvec と組み合わせることで、モデル座標系からカメラ座標系へ点を移す。入力値は初期解として使用される。
tvec	入出力の並進ベクトル。入力値は初期解として使用される。
criteria	Levenberg-Marquardt反復アルゴリズムを停止する条件。
VVSlambda	仮想視覚サーボ制御則のゲイン。減衰Gauss-Newton定式化における \(\alpha\) ゲインに相当する。

この関数は、少なくとも3つのオブジェクト点、それに対応する画像投影、回転・並進ベクトルの初期解、ならびにカメラ内部行列と歪み係数を与えて、オブジェクト姿勢を精緻化する。この関数は、仮想ビジュアルサーボイング(VVS) [54] [188] スキームを用いて、回転・並進ベクトルに関する投影誤差を最小化する。

stereoCalibrate() [1/3]

double cv::stereoCalibrate	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints1,
		InputArrayOfArrays	imagePoints2,
		InputOutputArray	cameraMatrix1,
		InputOutputArray	distCoeffs1,
		InputOutputArray	cameraMatrix2,
		InputOutputArray	distCoeffs2,
		Size	imageSize,
		InputOutputArray	R,
		InputOutputArray	T,
		OutputArray	E,
		OutputArray	F,
		OutputArray	perViewErrors,
		int	flags = CALIB_FIX_INTRINSIC,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) )

Python:
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize[, R[, T[, E[, F[, flags[, criteria]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, perViewErrors[, flags[, criteria]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, perViewErrors
	cv.stereoCalibrateExtended(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, rvecs[, tvecs[, perViewErrors[, flags[, criteria]]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, rvecs, tvecs, perViewErrors

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

stereoCalibrate() [2/3]

double cv::stereoCalibrate	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints1,
		InputArrayOfArrays	imagePoints2,
		InputOutputArray	cameraMatrix1,
		InputOutputArray	distCoeffs1,
		InputOutputArray	cameraMatrix2,
		InputOutputArray	distCoeffs2,
		Size	imageSize,
		InputOutputArray	R,
		InputOutputArray	T,
		OutputArray	E,
		OutputArray	F,
		OutputArrayOfArrays	rvecs,
		OutputArrayOfArrays	tvecs,
		OutputArray	perViewErrors,
		int	flags = CALIB_FIX_INTRINSIC,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) )

Python:
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize[, R[, T[, E[, F[, flags[, criteria]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, perViewErrors[, flags[, criteria]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, perViewErrors
	cv.stereoCalibrateExtended(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, rvecs[, tvecs[, perViewErrors[, flags[, criteria]]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, rvecs, tvecs, perViewErrors

#include <opencv2/calib3d.hpp>

ステレオカメラの構成をキャリブレーションする。この関数は、2台のカメラそれぞれの内部パラメータと、2台のカメラ間の外部パラメータを求める。

引数

objectPoints	キャリブレーションパターン点のベクトルのベクトル。calibrateCamera と同じ構造。各パターンビューについて、両カメラが同じ物体点を見ている必要がある。したがって、objectPoints.size()、imagePoints1.size()、imagePoints2.size() が等しく、かつ各 i について objectPoints[i].size()、imagePoints1[i].size()、imagePoints2[i].size() が等しい必要がある。
imagePoints1	1台目のカメラで観測された、キャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
imagePoints2	2台目のカメラで観測された、キャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
cameraMatrix1	1台目のカメラの入出力カメラ内部行列。calibrateCamera と同様。さらに、ステレオの場合は追加のフラグを使用できる。下記を参照。
distCoeffs1	歪み係数の入出力ベクトル。calibrateCamera と同様。
cameraMatrix2	2台目のカメラの入出力カメラ内部行列。cameraMatrix1 の説明を参照。
distCoeffs2	2台目のカメラの入出力レンズ歪み係数。distCoeffs1 の説明を参照。
imageSize	カメラ内部行列の初期化のみに使用される画像のサイズ。
R	出力の回転行列。並進ベクトル T と組み合わせることで、この行列は1台目のカメラ座標系で与えられた点を2台目のカメラ座標系の点に変換する。より技術的に言えば、R と T のタプルは1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行う。その双対性により、このタプルは2台目のカメラ座標系に対する1台目のカメラの位置と等価である。
T	出力の並進ベクトル。上記の説明を参照。
E	出力の基本行列。
F	出力の基礎行列。
rvecs	ステレオペアの1台目のカメラの座標系で、各パターンビューについて推定された回転ベクトル(Rodrigues)の出力ベクトル(例: std::vector<cv::Mat>)。より詳しくは、i番目の回転ベクトルは、対応するi番目の並進ベクトル(次の出力パラメータの説明を参照)と組み合わせることで、キャリブレーションパターンを物体座標空間(物体点が指定される空間)からステレオペアの1台目のカメラのカメラ座標空間へ移す。より技術的に言えば、i番目の回転ベクトルと並進ベクトルのタプルは、物体座標空間からステレオペアの1台目のカメラのカメラ座標空間への基底変換を行う。
tvecs	各パターンビューについて推定された並進ベクトルの出力ベクトル。前の出力パラメータ ( rvecs ) の説明を参照。
perViewErrors	各パターンビューについて推定された RMS 再投影誤差の出力ベクトル。
flags	ゼロ、または以下の値の組み合わせをとりうる各種フラグ: CALIB_FIX_INTRINSIC cameraMatrix? と distCoeffs? を固定し、R、T、E、F 行列のみを推定する。 CALIB_USE_INTRINSIC_GUESS 指定したフラグに従って一部または全部の内部パラメータを最適化する。初期値はユーザーが与える。 CALIB_USE_EXTRINSIC_GUESS R と T が有効な初期値を含み、それをさらに最適化する。そうでない場合、R と T はパターンビューの中央値(各次元ごとに別々)に初期化される。 CALIB_FIX_PRINCIPAL_POINT 最適化中に主点を固定する。 CALIB_FIX_FOCAL_LENGTH \(f^{(j)}_x\) と \(f^{(j)}_y\) を固定する。 CALIB_FIX_ASPECT_RATIO \(f^{(j)}_y\) を最適化し、比 \(f^{(j)}_x/f^{(j)}_y\) を固定する。 CALIB_SAME_FOCAL_LENGTH \(f^{(0)}_x=f^{(1)}_x\) と \(f^{(0)}_y=f^{(1)}_y\) を強制する。 CALIB_ZERO_TANGENT_DIST 各カメラの接線歪み係数をゼロに設定し、そこで固定する。 CALIB_FIX_K1,..., CALIB_FIX_K6 最適化中に対応する放射歪み係数を変更しない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでない場合は0に設定される。 CALIB_RATIONAL_MODEL 係数 k4、k5、k6 を有効にする。後方互換性を保つため、キャリブレーション関数に有理モデルを使用させ8個の係数を返させるには、この追加フラグを明示的に指定する必要がある。フラグが設定されない場合、関数は5個の歪み係数のみを計算して返す。 CALIB_THIN_PRISM_MODEL 係数 s1、s2、s3、s4 が有効になる。後方互換性を保つため、キャリブレーション関数に薄プリズムモデルを使用させ12個の係数を返させるには、この追加フラグを明示的に指定する必要がある。フラグが設定されない場合、関数は5個の歪み係数のみを計算して返す。 CALIB_FIX_S1_S2_S3_S4 最適化中に薄プリズム歪み係数を変更しない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでない場合は0に設定される。 CALIB_TILTED_MODEL 係数 tauX と tauY が有効になる。後方互換性を保つため、キャリブレーション関数に傾斜センサーモデルを使用させ14個の係数を返させるには、この追加フラグを明示的に指定する必要がある。フラグが設定されない場合、関数は5個の歪み係数のみを計算して返す。 CALIB_FIX_TAUX_TAUY 最適化中に傾斜センサーモデルの係数を変更しない。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列の係数が使用される。そうでない場合は0に設定される。
criteria	反復最適化アルゴリズムの終了条件。

この関数は、ステレオペアをなす2台のカメラ間の変換を推定する。あるオブジェクトの第1カメラに対する姿勢と第2カメラに対する姿勢、それぞれ ( \(R_1\), \(T_1\) ) と ( \(R_2\), \(T_2\)) を、2台のカメラ間の相対位置と姿勢が固定されたステレオカメラについて計算すると、これらの姿勢は確実に互いに関係する。これは、2台のカメラの相対位置と姿勢 ( \(R\), \(T\)) が既知であれば、( \(R_1\), \(T_1\)) が与えられたときに ( \(R_2\), \(T_2\)) を計算できることを意味する。これがこの関数の行うことである。次を満たす ( \(R\), \(T\)) を計算する:

\[R_2=R R_1\]

\[T_2=R T_1 + T.\]

したがって、第1カメラの座標系における点の座標表現が与えられたとき、その3D点の第2カメラの座標系における座標表現を計算できる:

\[\begin{bmatrix} X_2 \\ Y_2 \\ Z_2 \\ 1 \end{bmatrix} = \begin{bmatrix} R & T \\ 0 & 1 \end{bmatrix} \begin{bmatrix} X_1 \\ Y_1 \\ Z_1 \\ 1 \end{bmatrix}.\]

オプションで、基本行列(essential matrix) E を計算する:

\[E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R\]

ここで \(T_i\) は並進ベクトル \(T\) の成分である : \(T=[T_0, T_1, T_2]^T\) 。また、この関数は基礎行列(fundamental matrix) F も計算できる:

\[F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}\]

ステレオに関連する情報に加えて、この関数は2台のカメラそれぞれの完全なキャリブレーションも実行できる。ただし、パラメータ空間の高次元性と入力データのノイズにより、関数が正しい解から発散することがある。各カメラの内部パラメータを個別に高精度で推定できる場合(例えば calibrateCamera を使用)、そうすることを推奨し、その後、計算した内部パラメータとともに CALIB_FIX_INTRINSIC フラグを関数に渡すとよい。そうでない場合、すべてのパラメータを一度に推定するなら、いくつかのパラメータを制限するのが理にかなっており、例えば CALIB_SAME_FOCAL_LENGTH と CALIB_ZERO_TANGENT_DIST フラグを渡すとよい。これは通常、妥当な仮定である。

calibrateCamera と同様に、この関数は両カメラの利用可能なすべてのビュー内のすべての点について、総再投影誤差を最小化する。関数は再投影誤差の最終値を返す。

stereoCalibrate() [3/3]

double cv::stereoCalibrate	(	InputArrayOfArrays	objectPoints,
		InputArrayOfArrays	imagePoints1,
		InputArrayOfArrays	imagePoints2,
		InputOutputArray	cameraMatrix1,
		InputOutputArray	distCoeffs1,
		InputOutputArray	cameraMatrix2,
		InputOutputArray	distCoeffs2,
		Size	imageSize,
		OutputArray	R,
		OutputArray	T,
		OutputArray	E,
		OutputArray	F,
		int	flags = CALIB_FIX_INTRINSIC,
		TermCriteria	criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) )

Python:
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize[, R[, T[, E[, F[, flags[, criteria]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
	cv.stereoCalibrate(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, perViewErrors[, flags[, criteria]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, perViewErrors
	cv.stereoCalibrateExtended(	objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T[, E[, F[, rvecs[, tvecs[, perViewErrors[, flags[, criteria]]]]]]]	) ->	retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F, rvecs, tvecs, perViewErrors

#include <opencv2/calib3d.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 = CALIB_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/calib3d.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	ゼロ、または CALIB_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\) はカメラ間の水平方向のずれであり、CALIB_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\) はカメラ間の垂直方向のずれであり、CALIB_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/calib3d.hpp>

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

引数

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

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

覚え書き

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

triangulatePoints()

void cv::triangulatePoints	(	InputArray	projMatr1,
		InputArray	projMatr2,
		InputArray	projPoints1,
		InputArray	projPoints2,
		OutputArray	points4D )

Python:
	cv.triangulatePoints(	projMatr1, projMatr2, projPoints1, projPoints2[, points4D]	) ->	points4D

#include <opencv2/calib3d.hpp>

この関数は、ステレオカメラによる観測を用いて3次元点を(同次座標で)再構成する。

引数

projMatr1	1台目のカメラの3x4射影行列。すなわち、この行列はワールド座標系で与えられた3D点を1枚目の画像へ射影する。
projMatr2	2台目のカメラの3x4射影行列。すなわち、この行列はワールド座標系で与えられた3D点を2枚目の画像へ射影する。
projPoints1	1枚目の画像内の特徴点の2xN配列。C++版の場合、特徴点のベクトル、またはサイズ 1xN もしくは Nx1 の2チャンネル行列でもよい。
projPoints2	2枚目の画像内の対応する点の2xN配列。C++版の場合、特徴点のベクトル、またはサイズ 1xN もしくは Nx1 の2チャンネル行列でもよい。
points4D	同次座標で再構成された点の4xN配列。これらの点はワールド座標系で返される。

覚え書き

この関数が動作するには、すべての入力データがfloat型でなければならないことに注意する。

stereoRectify からの投影行列を使用する場合、返される点は第1カメラの平行化された座標系で表現される。

参照

reprojectImageTo3D

undistort()

void cv::undistort	(	InputArray	src,
		OutputArray	dst,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	newCameraMatrix = noArray() )

Python:
	cv.undistort(	src, cameraMatrix, distCoeffs[, dst[, newCameraMatrix]]	) ->	dst

#include <opencv2/calib3d.hpp>

レンズの歪みを補償するために画像を変換する。

この関数は、半径方向および接線方向のレンズ歪みを補償するために画像を変換する。

この関数は単に initUndistortRectifyMap (R を単位行列として)と remap (バイリニア補間で)を組み合わせたものである。実行される変換の詳細については前者の関数を参照のこと。

出力画像中で、入力画像に対応するピクセルが存在しないピクセルは、ゼロ(黒色)で埋められる。

補正画像に表示される入力画像の特定の部分集合は、newCameraMatrix によって調整できる。要件に応じて適切な newCameraMatrix を計算するには getOptimalNewCameraMatrix を使用できる。

カメラ行列と歪みパラメータは calibrateCamera を使って求められる。画像の解像度がキャリブレーション段階で使用した解像度と異なる場合、\(f_x, f_y, c_x\) と \(c_y\) はそれに応じてスケーリングする必要があるが、歪み係数は同じままである。

引数

src	入力（歪んだ）画像。
dst	src と同じサイズおよび型を持つ出力（補正済み）画像。
cameraMatrix	入力カメラ行列 \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs	歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
newCameraMatrix	歪んだ画像のカメラ行列。デフォルトでは cameraMatrix と同じだが、異なる行列を使って結果をさらにスケールおよびシフトすることもできる。

undistortImagePoints()

void cv::undistortImagePoints	(	InputArray	src,
		OutputArray	dst,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		TermCriteria	= TermCriteria(TermCriteria::MAX_ITER, 5, 0.01) )

Python:
	cv.undistortImagePoints(	src, cameraMatrix, distCoeffs[, dst[, arg1]]	) ->	dst

#include <opencv2/calib3d.hpp>

歪み補正された画像点の位置を計算する。

引数

src	観測された点の位置。2xN/Nx2 の1チャンネル、または 1xN/Nx1 の2チャンネル（CV_32FC2 または CV_64FC2）（あるいは vector<Point2f> ）。
dst	出力の歪み補正された点の位置（1xN/Nx1 の2チャンネル、または vector<Point2f> ）。
cameraMatrix	カメラ行列 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs	歪み係数

undistortPoints() [1/2]

void cv::undistortPoints	(	InputArray	src,
		OutputArray	dst,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	R,
		InputArray	P,
		TermCriteria	criteria )

Python:
	cv.undistortPoints(	src, cameraMatrix, distCoeffs[, dst[, R[, P]]]	) ->	dst
	cv.undistortPointsIter(	src, cameraMatrix, distCoeffs, R, P, criteria[, dst]	) ->	dst

#include <opencv2/calib3d.hpp>

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

覚え書き

undistortPoints のデフォルト版は、歪み補正された点を計算するために5回の反復を行う。

undistortPoints() [2/2]

void cv::undistortPoints	(	InputArray	src,
		OutputArray	dst,
		InputArray	cameraMatrix,
		InputArray	distCoeffs,
		InputArray	R = noArray(),
		InputArray	P = noArray() )

Python:
	cv.undistortPoints(	src, cameraMatrix, distCoeffs[, dst[, R[, P]]]	) ->	dst
	cv.undistortPointsIter(	src, cameraMatrix, distCoeffs, R, P, criteria[, dst]	) ->	dst

#include <opencv2/calib3d.hpp>

観測された点の座標から理想的な点の座標を計算する。

この関数は undistort や initUndistortRectifyMap に似ているが、ラスタ画像ではなく疎な点集合に対して動作する。また、この関数は projectPoints の逆変換を実行する。3Dオブジェクトの場合、その3D座標を再構成しないが、平面オブジェクトの場合は、適切な R が指定されていれば、並進ベクトルを除いて再構成する。

観測された各点の座標 \((u, v)\) について、この関数は次を計算する:

\[ \begin{array}{l} x^{"} \leftarrow (u - c_x)/f_x \\ y^{"} \leftarrow (v - c_y)/f_y \\ (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x \leftarrow X/W \\ y \leftarrow Y/W \\ \text{only performed if P is specified:} \\ u' \leftarrow x {f'}_x + {c'}_x \\ v' \leftarrow y {f'}_y + {c'}_y \end{array} \]

ここで undistort は、正規化された歪んだ点の座標から正規化された元の点の座標を推定する近似的な反復アルゴリズムである(「正規化」とは座標がカメラ行列に依存しないことを意味する)。

この関数は、ステレオカメラヘッドと単眼カメラ(R が空の場合)の両方に使用できる。

引数

src	観測された点の座標。2xN/Nx2 の1チャンネル、または 1xN/Nx1 の2チャンネル（CV_32FC2 または CV_64FC2）（あるいは vector<Point2f> ）。
dst	歪み補正および逆透視変換後の出力の理想点座標（1xN/Nx1 の2チャンネル、または vector<Point2f> ）。行列 P が単位行列または省略された場合、dst には正規化された点座標が格納される。
cameraMatrix	カメラ行列 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
distCoeffs	歪み係数の入力ベクトル \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) で、4, 5, 8, 12, または 14 要素。ベクトルが NULL/空の場合、歪み係数は 0 と仮定される。
R	オブジェクト空間における整列変換（3x3行列）。stereoRectify で計算された R1 または R2 をここに渡せる。行列が空の場合、恒等変換が使用される。
P	新しいカメラ行列（3x3）または新しい射影行列（3x4） \(\begin{bmatrix} {f'}_x & 0 & {c'}_x & t_x \\ 0 & {f'}_y & {c'}_y & t_y \\ 0 & 0 & 1 & t_z \end{bmatrix}\)。stereoRectify で計算された P1 または P2 をここに渡せる。行列が空の場合、恒等の新しいカメラ行列が使用される。

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/calib3d.hpp>

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