OpenCV 5.0.0
Open Source Computer Vision
読み込み中...
検索中...
見つかりません
🤖 AIによる機械翻訳（非公式） — これは OpenCV 5.0.0 公式リファレンス（英語）を AI (Claude) で自動翻訳したものです。訳に誤りを含む場合があります。正確な情報は 公式英語版（原文） を参照してください。
Topics | Namespaces | Macros | Enumerations | Enumerator | Functions
カメラキャリブレーション

トピック

 魚眼カメラモデル
 

詳細説明

このセクションの関数は、いわゆるピンホールカメラモデルを使用する。シーンのビューは、シーンの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\) ([328] と同じ表記で、一般には \(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\) は適切にスケーリングする必要がある。

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

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

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 \)) を計算できる。この変換行列は3x3の回転行列 \( {}^{c}\mathbf{R}_o \) と3x1の並進ベクトル \( {}^{c}\mathbf{t}_o \) から構成される。3x1の並進ベクトル \( {}^{c}\mathbf{t}_o \) はカメラ座標系におけるオブジェクト座標系の位置であり、3x3の回転行列 \( {}^{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} \]

3x3の回転行列の逆行列は、その行列の転置そのものになる点に注意。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の回転行列は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（球面線形補間） 法を用いて行える
  • quick conversions between the different rotation formalisms can be done using this online tool Intrinsic parameters from camera lens specifications
    When dealing with industrial cameras, the camera intrinsic matrix or more precisely \( \left(f_x, f_y \right) \) can be deduced, approximated from the camera specifications:

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

    In a same way, the physical focal length can be deduced from the angular field of view:

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

    This latter conversion can be useful when using a rendering software to mimic a physical camera device.

追加の参考文献、注記

覚え書き
  • このモジュールの多くの関数は、カメラ内部行列を入力パラメータとして受け取る。すべての関数がこのパラメータについて同じ構造を仮定しているが、関数によって名前が異なる場合がある。ただし、パラメータの説明には、上記に示した構造のカメラ内部行列が必要であることが明確に記されている。
  • 水平方向に配置した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 にある

名前空間

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

マクロ定義

#define CALIB_NINTRINSIC   18
 カメラ内部パラメータ（intrinsics）ベクトルの最大サイズ。
 

列挙型

enum  {
  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_DISABLE_SCHUR_COMPLEMENT = (1 << 18) ,
  cv::CALIB_USE_EXTRINSIC_GUESS = (1 << 22) ,
  cv::CALIB_RECOMPUTE_EXTRINSIC = (1 << 23) ,
  cv::CALIB_CHECK_COND = (1 << 24) ,
  cv::CALIB_FIX_SKEW = (1 << 25) ,
  cv::CALIB_STEREO_REGISTRATION = (1 << 26)
}
 
enum  cv::CameraModel {
  cv::CALIB_MODEL_PINHOLE = 0 ,
  cv::CALIB_MODEL_FISHEYE = 1
}
 
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::RobotWorldHandEyeCalibrationMethod {
  cv::CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0 ,
  cv::CALIB_ROBOT_WORLD_HAND_EYE_LI = 1
}
 

関数

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, 500, 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, 500, 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, 500, 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, 500, 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\)。
 
double cv::calibrateMultiview (InputArrayOfArrays objPoints, const std::vector< std::vector< Mat > > &imagePoints, const std::vector< cv::Size > &imageSize, InputArray detectionMask, InputArray models, InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions, InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts, InputArray flagsForIntrinsics=noArray(), int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON))
 これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは受け取る引数のみが異なる。
 
double cv::calibrateMultiview (InputArrayOfArrays objPoints, const std::vector< std::vector< Mat > > &imagePoints, const std::vector< cv::Size > &imageSize, InputArray detectionMask, InputArray models, InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions, InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts, OutputArray initializationPairs, OutputArrayOfArrays rvecs0, OutputArrayOfArrays tvecs0, OutputArray perFrameErrors, InputArray flagsForIntrinsics=noArray(), int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON))
 マルチカメラシステム（別名マルチビューキャリブレーション）の内部パラメータと外部パラメータ（カメラの姿勢）を推定する。
 
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\)。
 
Mat cv::initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0)
 3D-2D点対応から初期カメラ内部行列を求める。
 
double cv::registerCameras (InputArrayOfArrays objectPoints1, InputArrayOfArrays objectPoints2, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputArray cameraMatrix1, InputArray distCoeffs1, CameraModel cameraModel1, InputArray cameraMatrix2, InputArray distCoeffs2, CameraModel cameraModel2, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6))
 これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは受け取る引数のみが異なる。
 
double cv::registerCameras (InputArrayOfArrays objectPoints1, InputArrayOfArrays objectPoints2, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputArray cameraMatrix1, InputArray distCoeffs1, CameraModel cameraModel1, InputArray cameraMatrix2, InputArray distCoeffs2, CameraModel cameraModel2, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6))
 カメラペアのセットアップをキャリブレーションする。この関数は 2 台のカメラ間の外部パラメータを求める。
 
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, 100, 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, 100, 1e-6))
 これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは受け取る引数のみが異なる。
 

マクロ定義詳解

◆ CALIB_NINTRINSIC

#define CALIB_NINTRINSIC   18

#include <opencv2/calib.hpp>

カメラ内部パラメータ(intrinsics)ベクトルの最大サイズ。

列挙型詳解

◆ anonymous enum

anonymous enum

#include <opencv2/calib.hpp>

列挙値
CALIB_USE_INTRINSIC_GUESS 
Python: cv.CALIB_USE_INTRINSIC_GUESS

ユーザが提供した内部パラメータを最適化の初期点として使用する。

CALIB_FIX_ASPECT_RATIO 
Python: cv.CALIB_FIX_ASPECT_RATIO

CALIB_USE_INTRINSIC_GUESS とともに使用する。比率 fx/fy は入力 cameraMatrix と同じにとどまる。

CALIB_FIX_PRINCIPAL_POINT 
Python: cv.CALIB_FIX_PRINCIPAL_POINT

主点 (cx, cy) は入力カメラ行列と同じにとどまる。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、画像の中心が主点として使用される。

CALIB_ZERO_TANGENT_DIST 
Python: cv.CALIB_ZERO_TANGENT_DIST

ピンホールモデルのみ。接線方向の歪み係数 \((p_1, p_2)\) はゼロに設定され、ゼロのままにとどまる。

CALIB_FIX_FOCAL_LENGTH 
Python: cv.CALIB_FIX_FOCAL_LENGTH

CALIB_USE_INTRINSIC_GUESS とともに使用する。焦点距離 (fx, fy) は入力 cameraMatrix と同じにとどまる。

CALIB_FIX_K1 
Python: cv.CALIB_FIX_K1

対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_FIX_K2 
Python: cv.CALIB_FIX_K2

対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_FIX_K3 
Python: cv.CALIB_FIX_K3

対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_FIX_K4 
Python: cv.CALIB_FIX_K4

対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_FIX_K5 
Python: cv.CALIB_FIX_K5

ピンホールモデルのみ。対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_FIX_K6 
Python: cv.CALIB_FIX_K6

ピンホールモデルのみ。対応する歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_RATIONAL_MODEL 
Python: cv.CALIB_RATIONAL_MODEL

ピンホールモデルのみ。係数 k4..k6 を伴う有理歪みモデルを使用する。

CALIB_THIN_PRISM_MODEL 
Python: cv.CALIB_THIN_PRISM_MODEL

ピンホールモデルのみ。係数 s1..s4 を伴う薄プリズム歪みモデルを使用する。

CALIB_FIX_S1_S2_S3_S4 
Python: cv.CALIB_FIX_S1_S2_S3_S4

ピンホールモデルのみ。薄プリズムの歪み係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_TILTED_MODEL 
Python: cv.CALIB_TILTED_MODEL

ピンホールモデルのみ。カメラ行列で係数 tauX と tauY が有効になる。

CALIB_FIX_TAUX_TAUY 
Python: cv.CALIB_FIX_TAUX_TAUY

ピンホールモデルのみ。tauX と tauY の係数は最適化の間に変更されない。CALIB_USE_INTRINSIC_GUESS が設定されていない場合、0の値が使用される。

CALIB_USE_QR 
Python: cv.CALIB_USE_QR

求解に SVD 分解の代わりに QR を使用する。高速だが精度はやや劣る可能性がある。

CALIB_FIX_TANGENT_DIST 
Python: cv.CALIB_FIX_TANGENT_DIST

ピンホールモデルのみ。接線方向の歪み係数 (p1,p2) はゼロに設定され、ゼロのままにとどまる。

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

STEREO_ZERO_DISPARITY の非推奨の同義語。stereoRectify を参照。

CALIB_USE_LU 
Python: cv.CALIB_USE_LU

解法に SVD 分解の代わりに LU を使用する。はるかに高速だが精度が劣る可能性がある

CALIB_DISABLE_SCHUR_COMPLEMENT 
Python: cv.CALIB_DISABLE_SCHUR_COMPLEMENT

シューア補元を無効にする（Bouguetキャリブレーションエンジンを使用する）

CALIB_USE_EXTRINSIC_GUESS 
Python: cv.CALIB_USE_EXTRINSIC_GUESS

ステレオおよびマルチビューキャリブレーション用。ユーザが提供した外部パラメータ (R, T) を最適化の初期点として使用する。

CALIB_RECOMPUTE_EXTRINSIC 
Python: cv.CALIB_RECOMPUTE_EXTRINSIC

魚眼モデルのみ。各キャリブレーション反復でボードの位置を再計算する。

CALIB_CHECK_COND 
Python: cv.CALIB_CHECK_COND

魚眼モデル専用。外部パラメータ推定の際、各フレームについて SVD 分解の品質を確認する。

CALIB_FIX_SKEW 
Python: cv.CALIB_FIX_SKEW

魚眼モデルのみ。スキュー係数 (alpha) はゼロに設定され、ゼロのままにとどまる。

CALIB_STEREO_REGISTRATION 
Python: cv.CALIB_STEREO_REGISTRATION

マルチビューキャリブレーションのみ。初期の外部パラメータの推測にステレオ対応付けの手法を使用する。制限: すべてのカメラが同じ型でなければならない。

◆ CameraModel

enum cv::CameraModel

#include <opencv2/calib.hpp>

列挙値
CALIB_MODEL_PINHOLE 
Python: cv.CALIB_MODEL_PINHOLE

ピンホールカメラモデル。

CALIB_MODEL_FISHEYE 
Python: cv.CALIB_MODEL_FISHEYE

魚眼カメラモデル。

◆ HandEyeCalibrationMethod

enum cv::HandEyeCalibrationMethod

#include <opencv2/calib.hpp>

列挙値
CALIB_HAND_EYE_TSAI 
Python: cv.CALIB_HAND_EYE_TSAI

完全自律的かつ効率的な3Dロボティクスのハンド/アイキャリブレーションのための新しい手法 [284]。

CALIB_HAND_EYE_PARK 
Python: cv.CALIB_HAND_EYE_PARK

Robot Sensor Calibration: Solving AX = XB on the Euclidean Group [221].

CALIB_HAND_EYE_HORAUD 
Python: cv.CALIB_HAND_EYE_HORAUD

Hand-eye Calibration [129].

CALIB_HAND_EYE_ANDREFF 
Python: cv.CALIB_HAND_EYE_ANDREFF

オンラインハンドアイキャリブレーション [14]。

CALIB_HAND_EYE_DANIILIDIS 
Python: cv.CALIB_HAND_EYE_DANIILIDIS

双対四元数を用いたハンドアイキャリブレーション [68]。

◆ RobotWorldHandEyeCalibrationMethod

enum cv::RobotWorldHandEyeCalibrationMethod

#include <opencv2/calib.hpp>

列挙値
CALIB_ROBOT_WORLD_HAND_EYE_SHAH 
Python: cv.CALIB_ROBOT_WORLD_HAND_EYE_SHAH

Solving the robot-world/hand-eye calibration problem using the kronecker product [253].

CALIB_ROBOT_WORLD_HAND_EYE_LI 
Python: cv.CALIB_ROBOT_WORLD_HAND_EYE_LI

Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product [167].

関数詳解

◆ 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, 500, 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/calib.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, 500, 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/calib.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ゼロまたは以下の値の組み合わせとなる各種フラグ。
  • CALIB_USE_INTRINSIC_GUESS cameraMatrix にはさらに最適化される fx, fy, cx, cy の有効な初期値が含まれる。そうでない場合、(cx, cy) は最初に画像の中心に設定され（ imageSize が使用される）、焦点距離は最小二乗法で計算される。なお、内部パラメータが既知であれば、外部パラメータを推定するためだけにこの関数を使用する必要はない。代わりに solvePnP を使用すること。
  • CALIB_DISABLE_SCHUR_COMPLEMENT シューア補元を無効にし、Bouguetキャリブレーションエンジンを使用する（[328]、[39]）。
  • 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)\) はゼロに設定され、ゼロのままにとどまる。
  • 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再投影誤差。

この関数は、内部カメラパラメータと、各ビューの外部パラメータを推定する。デフォルトでは、最適化はシューア補元を用いた疎なバンドル調整(sparse bundle adjustment)の定式化に従う。背景については [283] と [178] を参照。Bouguetキャリブレーションエンジンに切り替えるには CALIB_DISABLE_SCHUR_COMPLEMENT を使う。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, 500, 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/calib.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, 500, 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/calib.hpp>

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

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

引数
objectPointsキャリブレーションパターン座標空間におけるキャリブレーションパターン点のベクトルのベクトル。詳細は calibrateCamera を参照。物体解放法を使用する場合、各ビューで同一のキャリブレーションボードを使用し、それが完全に見えている必要があり、すべての objectPoints[i] は同一で、すべての点はおおよそ平面に近い必要がある。キャリブレーションターゲットは剛体である必要があり、少なくとも画像取得のために（キャリブレーションターゲットではなく）カメラを動かす場合は静止している必要がある。
imagePointsキャリブレーションパターン点の投影のベクトルのベクトル。詳細は calibrateCamera を参照。
imageSize内部カメラ行列の初期化にのみ使用される画像のサイズ。
iFixedPoint固定される objectPoints[0] 内の3D物体点のインデックス。キャリブレーション手法の選択を切り替えるスイッチとしても機能する。物体解放法を使用する場合は [1, objectPoints[0].size()-2] の範囲でパラメータを渡し、そうでなければこの範囲外の値を指定すると標準のキャリブレーション手法が選択される。通常、物体解放法を利用する場合はキャリブレーションボードグリッドの右上隅の点を固定することが推奨される。[264] によれば、他に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ゼロまたはいくつかの定義済み値の組み合わせとなる各種フラグ。詳細は calibrateCamera を参照。物体解放法を使用する場合、キャリブレーション時間が大幅に長くなることがある。より高速なキャリブレーションには CALIB_USE_QR または CALIB_USE_LU を使用できるが、まれに精度や安定性が劣る場合がある。
criteria反復最適化アルゴリズムの終了条件。
戻り値
全体のRMS再投影誤差。

この関数は、内部カメラパラメータと、各ビューの外部パラメータを推定する。オブジェクト解放拡張は [264] に従い、calibrateCamera と同じ最適化コアを使用する。その他の詳細な説明については 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 )

#include <opencv2/calib.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 A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration [284]
  • F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group [221]
  • R. Horaud, F. Dornaika Hand-Eye Calibration [129]

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

  • 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つの異なる姿勢が必要だが、はるかに多くの姿勢を使うことが強く推奨される。

◆ calibrateMultiview() [1/2]

double cv::calibrateMultiview ( InputArrayOfArrays objPoints,
const std::vector< std::vector< Mat > > & imagePoints,
const std::vector< cv::Size > & imageSize,
InputArray detectionMask,
InputArray models,
InputOutputArrayOfArrays Ks,
InputOutputArrayOfArrays distortions,
InputOutputArrayOfArrays Rs,
InputOutputArrayOfArrays Ts,
InputArray flagsForIntrinsics = noArray(),
int flags = 0,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON) )
Python:
cv.calibrateMultiview(objPoints, imagePoints, imageSize, detectionMask, models, Ks, distortions, Rs, Ts[, flagsForIntrinsics[, flags[, criteria]]]) -> retval, Ks, distortions, Rs, Ts
cv.calibrateMultiviewExtended(objPoints, imagePoints, imageSize, detectionMask, models, Ks, distortions, Rs, Ts[, initializationPairs[, rvecs0[, tvecs0[, perFrameErrors[, flagsForIntrinsics[, flags[, criteria]]]]]]]) -> retval, Ks, distortions, Rs, Ts, initializationPairs, rvecs0, tvecs0, perFrameErrors

#include <opencv2/calib.hpp>

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

◆ calibrateMultiview() [2/2]

double cv::calibrateMultiview ( InputArrayOfArrays objPoints,
const std::vector< std::vector< Mat > > & imagePoints,
const std::vector< cv::Size > & imageSize,
InputArray detectionMask,
InputArray models,
InputOutputArrayOfArrays Ks,
InputOutputArrayOfArrays distortions,
InputOutputArrayOfArrays Rs,
InputOutputArrayOfArrays Ts,
OutputArray initializationPairs,
OutputArrayOfArrays rvecs0,
OutputArrayOfArrays tvecs0,
OutputArray perFrameErrors,
InputArray flagsForIntrinsics = noArray(),
int flags = 0,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, DBL_EPSILON) )
Python:
cv.calibrateMultiview(objPoints, imagePoints, imageSize, detectionMask, models, Ks, distortions, Rs, Ts[, flagsForIntrinsics[, flags[, criteria]]]) -> retval, Ks, distortions, Rs, Ts
cv.calibrateMultiviewExtended(objPoints, imagePoints, imageSize, detectionMask, models, Ks, distortions, Rs, Ts[, initializationPairs[, rvecs0[, tvecs0[, perFrameErrors[, flagsForIntrinsics[, flags[, criteria]]]]]]]) -> retval, Ks, distortions, Rs, Ts, initializationPairs, rvecs0, tvecs0, perFrameErrors

#include <opencv2/calib.hpp>

マルチカメラシステム(別名マルチビューキャリブレーション)について、内部パラメータと外部パラメータ(カメラ姿勢)を推定する。

引数
[in]objPointsキャリブレーションパターンの物体点。想定される形状: NUM_FRAMES x NUM_POINTS x 3。サポートされるデータ型: CV_32F。
[in]imagePointsカメラ画像上で検出されたパターン点。想定される形状: NUM_CAMERAS x NUM_FRAMES x NUM_POINTS x 2。この関数はキャリブレーションパターンの部分的な観測をサポートする。これを有効にするには、観測されない画像点を無効な点（例: (-1., -1.)）に設定する。
[in]imageSize各カメラの画像解像度の配列。
[in]detectionMaskパターン検出マスク。各値は、i番目のカメラがj番目のフレームでキャリブレーションパターンを観測するかどうかを定義する。想定されるサイズ: NUM_CAMERAS x NUM_FRAMES。想定される型: CV_8U。
[in]models各カメラのカメラモデルを示す: cv::CALIB_MODEL_PINHOLE または cv::CALIB_MODEL_PINHOLE。現在の実装は異なるカメラモデルの混在をサポートしていない。想定される型: CV_8U。
[in]flagsForIntrinsics各カメラの内部パラメータのキャリブレーションに使用されるフラグ。カメラごとの呼び出しと useIntrinsicsGuess フラグを使用して、各カメラに対するカスタムな内部パラメータのキャリブレーションを得ることができる。
[in]flags共通のマルチビューキャリブレーションフラグ。cv::CALIB_USE_INTRINSIC_GUESS と cv::CALIB_USE_EXTRINSIC_GUESS がサポートされている。CALIB_USE_INTRINSIC_GUESS およびその他の CALIB_ 定数を参照。想定される形状: NUM_CAMERAS x 1。サポートされるデータ型: CV_32S。
[out]Rsカメラ0を基準とする回転ベクトル。Rs[0] = 0。出力サイズ: NUM_CAMERAS x 3 x 3。
[out]Tsカメラ0を基準として推定された並進ベクトル。Ts[0] = 0。出力サイズ: NUM_CAMERAS x 3 x 1。
[out]rvecs0カメラ0について推定された回転ベクトル。出力サイズ: NUM_FRAMES x 3 x 1（フレームが有効でない場合、null の Mat を含むことがある）。Rodrigues を参照。
[out]tvecs0カメラ0の並進ベクトル。出力サイズ: NUM_FRAMES x 3 x 1。（フレームが有効でない場合、null の Mat を含むことがある）。
[out]Ks推定された浮動小数点カメラ内部行列。出力サイズ: NUM_CAMERAS x 3 x 3。
[out]distortions歪み係数。出力サイズ: NUM_CAMERAS x NUM_PARAMS。
[out]perFrameErrors可視の各フレームに対するRMSE値（可視でない場合は-1）。出力サイズ: NUM_CAMERAS x NUM_FRAMES。
[out]initializationPairs初期のペアごとのステレオキャリブレーションに使用されたカメラインデックスのペア。
[in]criteria反復最適化アルゴリズムの終了条件。

出力サイズ: (NUM_CAMERAS-1) x 2。

マルチビューカメラキャリブレーションのチュートリアル がこの関数の使い方を詳しく解説している。詳細はそちらを参照。

マルチビューキャリブレーションでは通常、複数のカメラが同じキャリブレーションパターンを同時に観測する必要がある。基本的な前提は、カメラ間の相対姿勢が固定されていることであり、その上で各フレームについて、単一のカメラの絶対カメラ姿勢だけがあれば複数のカメラのカメラ姿勢を確定できる

上の図は、マルチビューカメラキャリブレーションの設定例を示している。

各フレームについて、カメラ \(i\) の絶対カメラ姿勢を \(R_i, t_i\) とし、カメラ \(i\) とカメラ \(j\) の間の相対カメラ姿勢を \(R_{ij}, t_{ij}\) とする。\(R_1, t_1\) および任意の \(i\not=1\) に対する \(R_{1i}\) が既知であれば、その姿勢は次のように計算できる

\[ R_i = R_{1i} R_1\]

\[ t_i = R_{1i} t_1 + t_{1i}\]

2つのカメラ間の相対姿勢は次のように計算できるので

\[ R_{ij} = R_j R_i^\top \]

\[ t_{ij} = -R_{ij} t_i + R_j \]

これは、\(R_{ij}, i\not=1\) の形をした他の相対姿勢がすべて冗長であることを意味する。これを踏まえると、決定すべき姿勢の総数は (NUM_CAMERAS-1) と NUM_FRAMES である。これがこの関数の基礎となっている。

calibrateCamera と同様に、この関数はすべてのカメラの利用可能なすべてのビューにおける全点の再投影誤差の総和を最小化する。

戻り値
detectionMask 全体での全体的なRMS再投影誤差。
参照
findChessboardCorners, findCirclesGrid, calibrateCamera, fisheye::calibrate, registerCameras

◆ 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 )

#include <opencv2/calib.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 [253]

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

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

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

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

  • 静止したキャリブレーションパターンを用いて、ターゲットフレームとカメラフレームの間の変換を推定する
  • 複数の姿勢を取得するためにロボットのグリッパを動かす
  • 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以上でなければならない）。

◆ initCameraMatrix2D()

Mat cv::initCameraMatrix2D ( InputArrayOfArrays objectPoints,
InputArrayOfArrays imagePoints,
Size imageSize,
double aspectRatio = 1.0 )
Python:
cv.initCameraMatrix2D(objectPoints, imagePoints, imageSize[, aspectRatio]) -> retval

#include <opencv2/calib.hpp>

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

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

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

◆ registerCameras() [1/2]

double cv::registerCameras ( InputArrayOfArrays objectPoints1,
InputArrayOfArrays objectPoints2,
InputArrayOfArrays imagePoints1,
InputArrayOfArrays imagePoints2,
InputArray cameraMatrix1,
InputArray distCoeffs1,
CameraModel cameraModel1,
InputArray cameraMatrix2,
InputArray distCoeffs2,
CameraModel cameraModel2,
InputOutputArray R,
InputOutputArray T,
OutputArray E,
OutputArray F,
OutputArray perViewErrors,
int flags = 0,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) )
Python:
cv.registerCameras(objectPoints1, objectPoints2, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraModel1, cameraMatrix2, distCoeffs2, cameraModel2, R, T[, E[, F[, perViewErrors[, flags[, criteria]]]]]) -> retval, R, T, E, F, perViewErrors
cv.registerCamerasExtended(objectPoints1, objectPoints2, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraModel1, cameraMatrix2, distCoeffs2, cameraModel2, R, T[, E[, F[, rvecs[, tvecs[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, R, T, E, F, rvecs, tvecs, perViewErrors

#include <opencv2/calib.hpp>

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

◆ registerCameras() [2/2]

double cv::registerCameras ( InputArrayOfArrays objectPoints1,
InputArrayOfArrays objectPoints2,
InputArrayOfArrays imagePoints1,
InputArrayOfArrays imagePoints2,
InputArray cameraMatrix1,
InputArray distCoeffs1,
CameraModel cameraModel1,
InputArray cameraMatrix2,
InputArray distCoeffs2,
CameraModel cameraModel2,
InputOutputArray R,
InputOutputArray T,
OutputArray E,
OutputArray F,
OutputArrayOfArrays rvecs,
OutputArrayOfArrays tvecs,
OutputArray perViewErrors,
int flags = 0,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) )
Python:
cv.registerCameras(objectPoints1, objectPoints2, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraModel1, cameraMatrix2, distCoeffs2, cameraModel2, R, T[, E[, F[, perViewErrors[, flags[, criteria]]]]]) -> retval, R, T, E, F, perViewErrors
cv.registerCamerasExtended(objectPoints1, objectPoints2, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraModel1, cameraMatrix2, distCoeffs2, cameraModel2, R, T[, E[, F[, rvecs[, tvecs[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, R, T, E, F, rvecs, tvecs, perViewErrors

#include <opencv2/calib.hpp>

カメラペアのセットアップをキャリブレーションする。この関数は2つのカメラ間の外部パラメータを求める。

引数
objectPoints1カメラ1のキャリブレーションパターン点のベクトルのベクトル。calibrateCamera の objectPoints と同様の構造であり、各パターンビューについて、両方のカメラが同じ物体点を見る必要はない。objectPoints1.size(), imagePoints1.size() は等しく、また各 i について objectPoints1[i].size(), imagePoints1[i].size() も等しくなければならない。
objectPoints2カメラ2のキャリブレーションパターン点のベクトルのベクトル。objectPoints1 と同様の構造。objectPoints2.size() と imagePoints2.size() は等しく、また各 i について objectPoints2[i].size(), imagePoints2[i].size() も等しくなければならない。ただし、objectPoints1[i].size() と objectPoints2[i].size() は等しい必要はない。
imagePoints1最初のカメラによって観測されたキャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
imagePoints22番目のカメラによって観測されたキャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
cameraMatrix1最初のカメラの入力/出力カメラ内部行列。calibrateCamera と同じ。さらに、ステレオの場合は追加のフラグが使用できる。下記を参照。
distCoeffs1歪み係数の入力/出力ベクトル。calibrateCamera と同じ。
cameraModel1カメラ1のモデルの種類（pinhole / fisheye）を反映するフラグ。
cameraMatrix22台目のカメラの入出力カメラ内部行列。cameraMatrix1 の説明を参照。
distCoeffs22台目のカメラの入出力レンズ歪み係数。distCoeffs1 の説明を参照。
cameraModel2カメラ2のモデルの種類（pinhole / fisheye）を反映するフラグ。cameraModel1 の説明を参照。
R出力の回転行列。並進ベクトル T と組み合わせることで、この行列は1台目のカメラ座標系で与えられた点を2台目のカメラ座標系の点に変換する。より技術的に言えば、R と T のタプルは1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行う。その双対性により、このタプルは2台目のカメラ座標系に対する1台目のカメラの位置と等価である。
T出力の並進ベクトル。上記の説明を参照。
E出力の基本行列。
F出力の基礎行列。
rvecsステレオペアの最初のカメラの座標系で各パターンビューに対して推定された回転ベクトル（ Rodrigues ）の出力ベクトル（例: std::vector<cv::Mat>）。より詳しくは、各i番目の回転ベクトルは、対応するi番目の並進ベクトル（次の出力パラメータの説明を参照）とともに、キャリブレーションパターンを物体座標空間（物体点が指定される空間）からステレオペアの最初のカメラのカメラ座標空間へと変換する。より技術的に言えば、i番目の回転ベクトルと並進ベクトルの組は、物体座標空間からステレオペアの最初のカメラのカメラ座標空間への基底変換を実行する。
tvecs各パターンビューについて推定された並進ベクトルの出力ベクトル。前の出力パラメータ ( rvecs ) の説明を参照。
perViewErrors各パターンビューについて推定された RMS 再投影誤差の出力ベクトル。
flagsゼロまたは以下の値の組み合わせとなる各種フラグ。
criteria反復最適化アルゴリズムの終了条件。

この関数は、ステレオペアのキャリブレーションと同様に2つのカメラ間の変換を推定する。原理は stereoCalibrate に密接に従う。カメラペア間の相対姿勢を推定する問題を理解するには、そちらの説明を参照すること。この関数の違いは、カメラの内部パラメータが最適化されないこと、および両カメラが同じキャリブレーションターゲットを観測しており各オブジェクト点の絶対位置が既知である限り、2つのカメラが重なり合う視野を持つ必要がないことである。

上の図は、そのようなケースが関係しうる例を示している。さらに、この関数は混合モデル(ピンホール / 魚眼)のカメラペアをサポートする。calibrateCamera と同様に、この関数は両カメラの利用可能なすべてのビューにおける全点の再投影誤差の総和を最小化する。

戻り値
再投影誤差の最終値。
参照
calibrateCamera, stereoCalibrate

◆ 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/calib.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, 100, 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/calib.hpp>

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

引数
objectPointsキャリブレーションパターン点のベクトルのベクトル。calibrateCamera と同じ構造。各パターンビューについて、両方のカメラが同じ物体点を見る必要がある。したがって、objectPoints.size(), imagePoints1.size(), imagePoints2.size() は等しく、また各 i について objectPoints[i].size(), imagePoints1[i].size(), imagePoints2[i].size() も等しくなければならない。
imagePoints1最初のカメラによって観測されたキャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
imagePoints22番目のカメラによって観測されたキャリブレーションパターン点の投影のベクトルのベクトル。calibrateCamera と同じ構造。
cameraMatrix1最初のカメラの入力/出力カメラ内部行列。calibrateCamera と同じ。さらに、ステレオの場合は追加のフラグが使用できる。下記を参照。
distCoeffs1歪み係数の入力/出力ベクトル。calibrateCamera と同じ。
cameraMatrix22台目のカメラの入出力カメラ内部行列。cameraMatrix1 の説明を参照。
distCoeffs22台目のカメラの入出力レンズ歪み係数。distCoeffs1 の説明を参照。
imageSizeカメラ内部行列の初期化のみに使用される画像のサイズ。
R出力の回転行列。並進ベクトル T と組み合わせることで、この行列は1台目のカメラ座標系で与えられた点を2台目のカメラ座標系の点に変換する。より技術的に言えば、R と T のタプルは1台目のカメラ座標系から2台目のカメラ座標系への基底変換を行う。その双対性により、このタプルは2台目のカメラ座標系に対する1台目のカメラの位置と等価である。
T出力の並進ベクトル。上記の説明を参照。
E出力の基本行列。
F出力の基礎行列。
rvecsステレオペアの最初のカメラの座標系で各パターンビューに対して推定された回転ベクトル（ Rodrigues ）の出力ベクトル（例: std::vector<cv::Mat>）。より詳しくは、各i番目の回転ベクトルは、対応するi番目の並進ベクトル（次の出力パラメータの説明を参照）とともに、キャリブレーションパターンを物体座標空間（物体点が指定される空間）からステレオペアの最初のカメラのカメラ座標空間へと変換する。より技術的に言えば、i番目の回転ベクトルと並進ベクトルの組は、物体座標空間からステレオペアの最初のカメラのカメラ座標空間への基底変換を実行する。
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, 100, 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/calib.hpp>

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

Generated on Fri Jun 5 2026 21:15:50 for OpenCV by doxygen 1.12.0