相機標定與 3D 重建

主題
	魚眼相機模型

詳細說明

本節中的函式使用所謂的針孔相機模型。場景的檢視是透過使用透視變換將場景的三維點 \(P_w\) 投影到影像平面中，從而形成相應的畫素 \(p\)。\(P_w\) 和 \(p\) 都以齊次座標表示，即分別為三維和二維齊次向量。您將在本節介紹的末尾找到關於射影幾何、齊次向量和齊次變換的簡要介紹。為了更簡潔的表示，我們通常省略“齊次”一詞，而直接稱之為向量。

由針孔相機模型給出的無畸變透視變換如下所示。

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

其中 \(P_w\) 是相對於世界座標系表示的三維點，\(p\) 是影像平面中的二維畫素，\(A\) 是相機內參矩陣，\(R\) 和 \(t\) 是描述從世界座標系到相機座標系（或相機幀）座標變化的旋轉和平移，\(s\) 是透視變換的任意縮放，不屬於相機模型的一部分。

相機內參矩陣 \(A\)（如 [324] 中使用的符號，通常也表示為 \(K\)）將相機座標系中給出的三維點投影到二維畫素座標，即

\[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]\) 是透視變換和齊次變換的矩陣乘積。3x4 透視變換將相機座標中表示的三維點對映到影像平面中以歸一化相機座標 \(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,\]

這個齊次變換由一個 3x3 旋轉矩陣 \(R\) 和一個 3x1 平移向量 \(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}.\]

結合透視變換和齊次變換，我們得到了將世界座標系中的三維點對映到影像平面中以歸一化相機座標表示的二維點的透視變換

\[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}.\]

下圖展示了針孔相機模型。

針孔相機模型

實際鏡頭通常存在一些畸變，主要是徑向畸變和輕微的切向畸變。因此，上述模型被擴充套件為

\[\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 中不考慮更高階的係數。

接下來的圖展示了兩種常見的徑向畸變型別：桶形畸變（\( 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 相機標定中使用的最佳化方法不包括這些約束，因為該框架不支援所需的整數規劃和多項式不等式。有關更多資訊，請參閱問題 #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\) 的旋轉定義，

\[ 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]]]])\]

向量。也就是說，如果向量包含四個元素，則表示 \(k_3=0\)。畸變係數不依賴於所檢視的場景。因此，它們也屬於相機內參。並且它們在捕獲影像解析度方面保持不變。例如，如果相機已在 320 x 240 解析度的影像上進行標定，則對於來自同一相機的 640 x 480 影像，可以使用完全相同的畸變係數，而 \(f_x\)、\(f_y\)、\(c_x\) 和 \(c_y\) 需要進行適當的縮放。

下面的函式使用上述模型執行以下操作：

• 根據內參和外參將三維點投影到影像平面。
• 根據內參、少量三維點及其投影計算外參。
• 從已知標定圖案的多個檢視中估算相機內參和外參（每個檢視由多個 3D-2D 點對應關係描述）。
• 估算立體相機“頭部”的相對位置和方向，並計算使相機光軸平行的校正*變換。

齊次座標
齊次座標是射影幾何中使用的一種座標系。它們的使用允許用有限座標表示無窮遠處的點，並與笛卡爾座標相比簡化了公式，例如，它們具有仿射變換可以表示為線性齊次變換的優點。

透過在 n 維笛卡爾向量 \(P\) 後附加 1 來獲得齊次向量 \(P_h\)，例如對於三維笛卡爾向量，對映 \(P \rightarrow P_h\) 為

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

對於逆對映 \(P_h \rightarrow P\)，將齊次向量的所有元素除以其最後一個元素，例如對於三維齊次向量，透過以下方式獲得其二維笛卡爾對應物

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

如果 \(W \ne 0\)。

由於這種對映，齊次點 \(P_h\) 的所有倍數 \(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}.\]

齊次變換，物件幀/相機幀
使用以下符號可以輕鬆實現基變換或計算從一個幀到另一個幀的三維座標

\[ \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} \]

對於在物件幀中表示的三維點（\( \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 \) 是物件幀在相機幀中的方向。

有了這個簡單的符號，很容易串聯變換。例如，計算在物件幀中表示的點在世界幀中的三維座標可以透過以下方式完成

\[ \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 旋轉矩陣的逆直接是其轉置矩陣。

透視投影，從物件幀到相機幀

此圖總結了整個過程。solvePnP 函式或從 fiducial 標記檢測返回的物件姿態就是這個 \( {}^{c}\mathbf{T}_o \) 變換。

相機內參矩陣 \( \mathbf{K} \) 允許將相機幀中表示的三維點投影到影像平面上，假設採用透視投影模型（針孔相機模型）。從經典影像處理函式中提取的影像座標假定為 (u,v) 左上角座標系。

注意

• 有關此主題的線上影片課程，例如參見
  • “3.3.1. 齊次變換矩陣”，Modern Robotics，Kevin M. Lynch 和 Frank C. Park
• 3x3 旋轉矩陣由 9 個值組成，但描述的是 3 自由度變換
• 3x3 旋轉矩陣的一些額外屬性是
  • \( \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

附加參考資料、注意事項

注意

• 本模組中的許多函式都接受相機內參矩陣作為輸入引數。儘管所有函式都假定此引數具有相同的結構，但它們可能以不同的名稱命名。然而，引數的描述將清楚地表明需要具有上述結構的相機內參矩陣。
• 可以在 opencv_source_code/samples/cpp/3calibration.cpp 中找到一個水平位置的 3 個攝像頭的標定示例
• 可以在 opencv_source_code/samples/cpp/calibration.cpp 中找到一個基於影像序列的標定示例
• 可以在 opencv_source_code/samples/cpp/build3dmodel.cpp 中找到一個用於 3D 重建的標定示例
• 可以在 opencv_source_code/samples/cpp/stereo_calib.cpp 中找到一個立體標定示例
• 可以在 opencv_source_code/samples/cpp/stereo_match.cpp 中找到一個立體匹配示例
• (Python) 可以在 opencv_source_code/samples/python/calibrate.py 中找到一個相機標定示例

類
結構體	cv::CirclesGridFinderParameters
類	cv::LMSolver
類	cv::StereoBM
	使用塊匹配演算法計算立體對應關係的類，由 K. Konolige 引入並貢獻給 OpenCV。更多...
類	cv::StereoMatcher
	立體對應演算法的基類。更多...
類	cv::StereoSGBM
	該類實現了改進的 H. Hirschmuller 演算法 [129]，該演算法與原始演算法的區別如下：更多...
結構體	cv::UsacParams

型別定義 (Typedefs)
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())
	結合兩個旋轉和平移變換。
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)
	計算兩個 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)
	計算兩個 3D 點集之間的最佳仿射變換。
int	cv::estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
	計算兩個 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)
	計算兩個 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)
	計算兩個 2D 點集之間的純 2D 平移。
int	cv::estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
	計算兩個 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())
	根據兩幅影像中的對應點計算本質矩陣。
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())
	根據兩幅影像（可能來自兩臺不同的相機）中的對應點計算本質矩陣。
Mat	cv::findFundamentalMat (InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
	根據兩幅影像中的對應點計算基礎矩陣。
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)
	尋找兩個平面之間的透視變換。
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())
	根據估算的本質矩陣和兩幅影像中的對應點，透過手性檢查（chirality check）恢復相機的相對旋轉和平移。返回透過檢查的內點數量。
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())
	利用手性檢查（cheirality check），從兩臺不同相機的兩幅影像中的對應點恢復相機的相對旋轉和平移。返回透過檢查的內點（inliers）數量。
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)
	計算三頭相機的校正變換，其中所有相機頭都在同一直線上。
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)
	計算兩點之間的 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))
	標定雙目相機設定。此函式計算兩個相機各自的內參數，以及兩個相機之間的外引數。
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)
	此函式利用立體相機的觀測結果重建三維點（齊次座標）。
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)
	使用左右檢查（left-right check）驗證視差。矩陣“cost”應由雙目匹配演算法計算得出。

型別定義文件 (Typedef Documentation)

CirclesGridFinderParameters2

typedef CirclesGridFinderParameters cv::CirclesGridFinderParameters2

#include <opencv2/calib3d.hpp>

列舉型別文件 (Enumeration Type Documentation)

anonymous enum

匿名列舉

#include <opencv2/calib3d.hpp>

魯棒估計算法型別

列舉值 (Enumerator)
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

匿名列舉

#include <opencv2/calib3d.hpp>

列舉值 (Enumerator)
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

匿名列舉

#include <opencv2/calib3d.hpp>

列舉值 (Enumerator)
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

匿名列舉

#include <opencv2/calib3d.hpp>

列舉值 (Enumerator)
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	使用QR而非SVD分解進行求解。速度更快但可能精度較低
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	使用LU而非SVD分解進行求解。速度快得多但可能精度較低
CALIB_USE_EXTRINSIC_GUESS  Python: cv.CALIB_USE_EXTRINSIC_GUESS	用於stereoCalibrate

anonymous enum

匿名列舉

#include <opencv2/calib3d.hpp>

用於尋找基礎矩陣的演算法

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
SOLVEPNP_ITERATIVE  Python: cv.SOLVEPNP_ITERATIVE	使用非線性Levenberg-Marquardt最小化方案進行姿態最佳化 [184] [81] 非平面"objectPoints"的初始解需要至少6個點，並使用DLT演算法。 平面"objectPoints"的初始解需要至少4個點，並使用單應性分解的姿態。
SOLVEPNP_EPNP  Python: cv.SOLVEPNP_EPNP	EPnP：高效的透視n點相機姿態估計 [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	透視三點問題的有效代數解 [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：透視n點問題的持續快速且全域性最優解 [274]。

UndistortTypes

enum cv::UndistortTypes

#include <opencv2/calib3d.hpp>

cv::undistort 模式

列舉值 (Enumerator)
PROJ_SPHERICAL_ORTHO  Python: cv.PROJ_SPHERICAL_ORTHO
PROJ_SPHERICAL_EQRECT  Python: cv.PROJ_SPHERICAL_EQRECT

函式文件 (Function Documentation)

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）。只要提供初始cameraMatrix，也可以使用3D校準裝置。
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)\) 如果其中一個引數未估計，則其偏差等於零。
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_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重投影誤差。

該函式估計相機的內參和每個檢視的外參。該演算法基於 [324] 和 [39]。必須指定3D物件點的座標及其在每個檢視中對應的2D投影。這可以透過使用具有已知幾何形狀和易於檢測特徵點的物件來實現。這樣的物件稱為校準裝置或校準圖案，OpenCV內建支援棋盤作為校準裝置（參見 findChessboardCorners）。目前，內參的初始化（當未設定 CALIB_USE_INTRINSIC_GUESS 時）僅適用於平面校準圖案（其中物件點的Z座標必須都為零）。只要提供初始cameraMatrix，也可以使用3D校準裝置。

該演算法執行以下步驟

• 計算初始內參（僅適用於平面校準圖案的選項）或從輸入引數中讀取它們。除非指定了某些 CALIB_FIX_K?，否則畸變係數最初都設定為零。
• 估計初始相機姿態，如同內參已經已知一樣。這是使用 solvePnP 完成的。
• 執行全域性Levenberg-Marquardt最佳化演算法，以最小化重投影誤差，即觀察到的特徵點 imagePoints 和投影的（使用當前相機引數和姿態估計）物件點 objectPoints 之間距離的平方和。有關詳細資訊，請參閱 projectPoints。

注意

如果您使用非方形（即非 N-by-N）網格和 findChessboardCorners 進行校準，並且 calibrateCamera 返回不好的值（零畸變係數、\(c_x\) 和 \(c_y\) 離影像中心很遠，和/或 \(f_x\) 和 \(f_y\) 之間差異很大（比例為 10:1 或更大）），那麼您可能在 findChessboardCorners 中使用了 patternSize=cvSize(rows,cols) 而不是 patternSize=cvSize(cols,rows)。

如果提供不支援的引數組合或系統受約束不足，該函式可能會丟擲異常。

另請參閱

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]，還有另外兩個點也被固定。在此實現中，使用了 objectPoints[0].front 和 objectPoints[0].back.z。使用物件釋放方法時，只有當這三個固定點的座標足夠準確時，才能獲得準確的 rvecs、tvecs 和 newObjPoints。如果不需要，可以傳入 noArray()。標準校準方法會忽略此引數。
cameraMatrix	輸出 3x3 浮點相機矩陣。詳見 calibrateCamera。
distCoeffs	畸變係數輸出向量。詳見 calibrateCamera。
rvecs	為每個模式檢視估計的旋轉向量輸出向量。詳見 calibrateCamera。
tvecs	為每個模式檢視估計的平移向量輸出向量。
newObjPoints	校準圖案點更新後的輸出向量。座標可能會根據三個固定點進行縮放。只有當上述三個固定點準確時，返回的座標才準確。如果不需要，可以傳入 noArray()。標準校準方法會忽略此引數。
stdDeviationsIntrinsics	內參估計的標準偏差輸出向量。詳見 calibrateCamera。
stdDeviationsExtrinsics	外參估計的標準偏差輸出向量。詳見 calibrateCamera。
stdDeviationsObjPoints	精煉後的校準圖案點座標的標準偏差輸出向量。它與 objectPoints[0] 向量具有相同的大小和順序。標準校準方法會忽略此引數。
perViewErrors	為每個模式檢視估計的RMS重投影誤差輸出向量。
flags (標誌)	可以是零或一些預定義值的組合的不同標誌。有關詳細資訊，請參閱 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\))。這是一個向量（vector<Mat>），其中包含從夾持器框架到機器人基座框架的所有變換的旋轉（3x3旋轉矩陣或3x1旋轉向量）。
[in]	t_gripper2base	從將夾持器框架中表示的點變換到機器人基座框架中的齊次矩陣中提取的平移部分（ \(_{}^{b}\textrm{T}_g\))。這是一個向量（vector<Mat>），其中包含從夾持器框架到機器人基座框架的所有變換的3x1平移向量。
[in]	R_target2cam	從將目標框架中表示的點變換到相機框架中的齊次矩陣中提取的旋轉部分（ \(_{}^{c}\textrm{T}_t\))。這是一個向量（vector<Mat>），其中包含從校準目標框架到相機框架的所有變換的旋轉（3x3旋轉矩陣或3x1旋轉向量）。
[in]	t_target2cam	從將目標框架中表示的點變換到相機框架中的齊次矩陣中提取的旋轉部分（ \(_{}^{c}\textrm{T}_t\))。這是一個向量（vector<Mat>），其中包含從校準目標框架到相機框架的所有變換的3x1平移向量。
[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]

下圖描述了手眼標定問題，其中必須估計安裝在機器人夾具（“手”）上的相機（“眼”）之間的變換。這種配置稱為手持式。

眼對手配置包括一個靜態相機觀察安裝在機器人末端執行器上的校準圖案。然後可以透過將合適的變換輸入函式來估計從相機到機器人基座框架的變換，如下所示。

標定過程如下：

• 使用靜態校準圖案來估計目標框架與相機框架之間的變換
• 移動機器人夾持器以獲取多個姿態
• 對於每個姿態，使用機器人運動學記錄夾持器框架和機器人基座框架之間的齊次變換

  \[ \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} \]

• 對於每個姿態，使用例如基於2D-3D點對應關係的姿態估計方法（PnP）記錄校準目標框架與相機框架之間的齊次變換

  \[ \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}\) 方程

• 用於手持式配置

  \[ \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*} \]

• 用於眼對手配置

  \[ \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\))。這是一個向量（vector<Mat>），其中包含從世界座標系到相機座標系的所有變換的旋轉（3x3旋轉矩陣或3x1旋轉向量）。
[in]	t_world2cam	從將世界座標系中的點變換到相機座標系中的齊次矩陣中提取的平移部分（ \(_{}^{c}\textrm{T}_w\))。這是一個向量（vector<Mat>），其中包含從世界座標系到相機座標系的所有變換的3x1平移向量。
[in]	R_base2gripper	從將機器人基座座標系中的點變換到夾持器座標系中的齊次矩陣中提取的旋轉部分（ \(_{}^{g}\textrm{T}_b\))。這是一個向量（vector<Mat>），其中包含從機器人基座座標系到夾持器座標系的所有變換的旋轉（3x3旋轉矩陣或3x1旋轉向量）。
[in]	t_base2gripper	從將機器人基座座標系中的點變換到夾持器座標系中的齊次矩陣中提取的旋轉部分（ \(_{}^{g}\textrm{T}_b\))。這是一個向量（vector<Mat>），其中包含從機器人基座座標系到夾持器座標系的所有變換的3x1平移向量。
[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，使用克羅內克積解決機器人-世界/手眼標定問題 [250]

另一種方法是同時估計旋轉和平移（同時解），並實現了以下方法

• A. Li, L. Wang, 和 D. Wu，使用雙四元數和克羅內克積同時進行機器人-世界和手眼標定 [168]

下圖描述了機器人-世界/手眼標定問題，其中必須估計機器人和世界座標系之間以及機器人夾持器（“手”）和安裝在機器人末端執行器上的相機（“眼”）之間的變換。

標定過程如下：

• 使用靜態校準圖案來估計目標框架與相機框架之間的變換
• 移動機器人夾持器以獲取多個姿態
• 對於每個姿態，使用機器人運動學記錄夾持器框架和機器人基座框架之間的齊次變換

  \[ \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} \]

• 對於每個姿態，使用例如基於2D-3D點對應關係的姿態估計方法（PnP）記錄校準目標框架（世界框架）與相機框架之間的齊次變換

  \[ \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	感測器物理寬度，單位為毫米。
apertureHeight	感測器物理高度，單位為毫米。
fovx	輸出視場角，單位為度，沿水平感測器軸線。
fovy	輸出視場角，單位為度，沿垂直感測器軸線。
focalLength	鏡頭焦距，單位為毫米。
principalPoint	主點，單位為毫米。
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, dt3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2

#include <opencv2/calib3d.hpp>

結合兩個旋轉和平移變換。

引數

rvec1	第一個旋轉向量。
tvec1	第一個平移向量。
rvec2	第二個旋轉向量。
tvec2	第二個平移向量。
rvec3	疊加的輸出旋轉向量。
tvec3	疊加的輸出平移向量。
dr3dr1	rvec3 對 rvec1 的可選輸出導數
dr3dt1	rvec3 對 tvec1 的可選輸出導數
dr3dr2	rvec3 對 rvec2 的可選輸出導數
dr3dt2	rvec3 對 tvec2 的可選輸出導數
dt3dr1	tvec3 對 rvec1 的可選輸出導數
dt3dt1	tvec3 對 tvec1 的可選輸出導數
dt3dr2	tvec3 對 rvec2 的可選輸出導數
dt3dt2	tvec3 對 tvec2 的可選輸出導數

函式計算

\[\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	輸入點。\(N \times 1\) 或 \(1 \times N\) 型別的 CV_32FC2 矩陣或 vector<Point2f>。
whichImage	包含點的影像索引（1 或 2）。
F	基本矩陣，可以使用 findFundamentalMat 或 stereoRectify 估計。
lines	對應於另一幅影像中點的對極線的輸出向量。每條線 \(ax + by + c=0\) 由 3 個數字 \((a, b, c)\) 編碼。

對於立體像對兩幅影像中的每個點，該函式查詢另一幅影像中對應對極線的方程。

根據基本矩陣定義（參見 findFundamentalMat ），當 whichImage=1 時，第一幅影像中點 \(p^{(1)}_i\) 在第二幅影像中的直線 \(l^{(2)}_i\) 計算為

\[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	2D、3D 或 4D 點的輸入陣列或向量。
dst	2D、3D 或 4D 點的輸出向量。

該函式透過呼叫 convertPointsToHomogeneous 或 convertPointsFromHomogeneous 將 2D 或 3D 點從/轉換為齊次座標。

注意

該函式已過時。請改用前兩個函式之一。

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	包含第一組點的 1xN 陣列。
points2	包含第二組點的 1xN 陣列。
newPoints1	最佳化後的 points1。
newPoints2	最佳化後的 points2。

該函式實現了最佳三角測量方法（詳見多檢視幾何 [120]）。對於每個給定的點對應關係 points1[i] <-> points2[i] 和基本矩陣 F，它計算校正後的對應關係 newPoints1[i] <-> newPoints2[i]，以最小化幾何誤差 \(d(points1[i], newPoints1[i])^2 + d(points2[i],newPoints2[i])^2\)（其中 \(d(a,b)\) 是點 \(a\) 和 \(b\) 之間的幾何距離），並滿足對極約束 \(newPoints2^T \cdot F \cdot newPoints1 = 0\)。

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	一個可能的旋轉矩陣。
R2	另一個可能的旋轉矩陣。
t	一個可能的平移。

此函式使用奇異值分解 (svd decomposition) [120] 分解本質矩陣 E。通常，E 的分解存在四種可能的姿態：\([R_1, t]\)、\([R_1, -t]\)、\([R_2, t]\)、\([R_2, -t]\)。

如果 E 給出了影像點 \(p_1\)（在第一張影像中）和 \(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]\) 都是從第一個相機的座標系到第二個相機的座標系的基變換。然而，透過分解 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	兩個影像之間的輸入單應性矩陣。
K	輸入的相機內部矩陣。
rotations	旋轉矩陣陣列。
translations	平移矩陣陣列。
normals	平面法線矩陣陣列。

此函式提取平面物件在兩個檢視之間的相對相機運動，並返回最多四個旋轉、平移和平面法線的數學解元組。單應性矩陣 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，只能得到由場景的（通常未知）深度歸一化的平移，即其方向但具有歸一化長度。

如果存在點對應關係，則透過應用正深度約束，即所有點必須位於相機前方，至少兩個解可能進一步無效。

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	可選的 3x3 繞 x 軸旋轉矩陣。
rotMatrixY	可選的 3x3 繞 y 軸旋轉矩陣。
rotMatrixZ	可選的 3x3 繞 z 軸旋轉矩陣。
eulerAngles	可選的三元素向量，包含三個以度為單位的尤拉旋轉角。

該函式將投影矩陣分解為校準矩陣和旋轉矩陣以及相機位置。

它可選地返回三個旋轉矩陣，每個軸一個，以及三個可在 OpenGL 中使用的尤拉角。請注意，始終存在不止一種圍繞三個主軸的旋轉序列，可以使物體具有相同的方向，例如參見 [254] 。返回的三個旋轉矩陣和相應的三個尤拉角只是可能的解決方案之一。

該函式基於 RQDecomp3x3。

drawChessboardCorners()

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

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

#include <opencv2/calib3d.hpp>

渲染檢測到的棋盤格角點。

引數

影像	目標影像。它必須是 8 位彩色影像。
patternSize	每個棋盤格行和列的內部角點數量 (patternSize = cv::Size(points_per_row,points_per_column))。
corners	檢測到的角點陣列，是 findChessboardCorners 的輸出。
patternWasFound	指示是否找到完整棋盤格的引數。此處應傳遞 findChessboardCorners 的返回值。

該函式繪製檢測到的單個棋盤格角點，如果未找到棋盤格，則繪製為紅色圓圈，如果找到棋盤格，則繪製為用線連線的彩色角點。

drawFrameAxes()

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

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

#include <opencv2/calib3d.hpp>

根據姿態估計繪製世界/物體座標系的軸。

另請參閱

solvePnP

引數

影像	輸入/輸出影像。它必須有 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>

計算兩個 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)\) 的第一個輸入 2D 點集。
to	包含 \((x,y)\) 的第二個輸入 2D 點集。
inliers	輸出向量，指示哪些點是內點（1-內點，0-外點）。
method	用於計算變換的魯棒方法。以下方法是可能的 RANSAC - 基於 RANSAC 的魯棒方法 LMEDS - 最小中位數魯棒方法，RANSAC 為預設方法。
ransacReprojThreshold	RANSAC 演算法中的最大重投影誤差，用於將點視為內點。僅適用於 RANSAC。
maxIters	魯棒方法的最大迭代次數。
confidence	估計變換的置信水平，介於 0 和 1 之間。通常 0.95 到 0.99 之間就足夠了。過接近 1 的值會顯著減慢估計速度。低於 0.8-0.9 的值可能導致估計變換不正確。
refineIters	細化演算法（Levenberg-Marquardt）的最大迭代次數。傳遞 0 將停用細化，因此輸出矩陣將是魯棒方法的輸出。

返回

輸出 2D 仿射變換矩陣 \(2 \times 3\)，如果無法估計變換則為空矩陣。返回的矩陣形式如下：

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

該函式使用選定的魯棒演算法估計兩個 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>

計算兩個 3D 點集之間的最佳仿射變換。

它計算 \(R,s,t\) 最小化 \(\sum{i} dst_i - c \cdot R \cdot src_i \) ，其中 \(R\) 是一個 3x3 旋轉矩陣，\(t\) 是一個 3x1 平移向量，\(s\) 是一個標量尺寸值。這是 Umeyama [284] 演算法的實現。估計的仿射變換具有齊次比例，是具有 7 個自由度的仿射變換的一個子類。配對點集需要至少包含 3 個點。

引數

src	第一個輸入 3D 點集。
dst	第二個輸入 3D 點集。
scale	如果傳入 null，則比例引數 c 將被假定為 1.0。否則，指向的變數將被設定為最佳比例。
force_rotation	如果為 true，則返回的旋轉永遠不會是反射。這可能是意料之外的，例如在最佳化右旋和左旋座標系之間的變換時。

返回

3D 仿射變換矩陣 \(3 \times 4\)，形式為

\[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>

計算兩個 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	第一個輸入 3D 點集，包含 \((X,Y,Z)\)。
dst	第二個輸入 3D 點集，包含 \((x,y,z)\)。
out	輸出 3D 仿射變換矩陣 \(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 演算法估計兩個 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>

計算兩個 2D 點集之間的具有 4 個自由度的最佳受限仿射變換。

引數

from	第一個輸入 2D 點集。
to	第二個輸入 2D 點集。
inliers	輸出向量，指示哪些點是內點。
method	用於計算變換的魯棒方法。以下方法是可能的 RANSAC - 基於 RANSAC 的魯棒方法 LMEDS - 最小中位數魯棒方法，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\)，如果無法估計變換則為空矩陣。

該函式估計兩個 2D 點集之間具有 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	影像,
		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 畫素。

引數

影像	用於查詢棋盤角點的灰度影像
patternSize	找到的棋盤格圖案大小
corners	findChessboardCornersSB 找到的角點
rise_distance	上升距離 0.8 表示最終訊號強度的 10%...90%
vertical	預設情況下計算水平線的邊緣響應
sharpness	可選輸出陣列，包含計算出的邊緣響應的清晰度值（見描述）

可選的銳度陣列型別為 CV_32FC1，每行包含以下五個條目，對應於每個計算出的輪廓：0 = 影像中底層邊緣的 x 座標 1 = 影像中底層邊緣的 y 座標 2 = 過渡區域的寬度（銳度） 3 = 黑色單元格中的訊號強度（最小亮度） 4 = 白色單元格中的訊號強度（最大亮度）

返回

Scalar(平均清晰度, 平均最小亮度, 平均最大亮度, 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>

計算兩個 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)\) 的第一個輸入 2D 點集。
to	包含 \((x,y)\) 的第二個輸入 2D 點集。
inliers	輸出向量，指示哪些點是內點（1-內點，0-外點）。
method	用於計算變換的魯棒方法。以下方法是可能的 RANSAC - 基於 RANSAC 的魯棒方法 LMEDS - 最小中位數魯棒方法，RANSAC 為預設方法。
ransacReprojThreshold	RANSAC 演算法中的最大重投影誤差，用於將點視為內點。僅適用於 RANSAC。
maxIters	魯棒方法的最大迭代次數。
confidence	估計變換的置信度，介於 0 和 1 之間。通常 0.95 到 0.99 之間就足夠了。過接近 1 的值會顯著減慢估計速度。低於 0.8-0.9 的值可能導致估計變換不正確。
refineIters	細化演算法的最大迭代次數。對於純平移，內點上的最小二乘解是閉式解，因此建議傳遞 0（不進行額外細化）。

返回

一個 2D 平移向量 \([t_x, t_y]^T\)，作為 cv::Vec2d。如果無法估計平移，則兩個分量都設定為 NaN，並且如果提供了 inliers，則掩碼將填充零。

轉換為 2x3 變換矩陣

\[ \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]);

該函式使用選定的魯棒演算法估計兩個 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>

計算兩個 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	第一個輸入 3D 點集，包含 \((X,Y,Z)\)。
dst	第二個輸入 3D 點集，包含 \((x,y,z)\)。
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 演算法估計兩個 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	經過濾波後的可行解集（整數索引）向量
pointsMask	可選的 Mat/Vector 8u 型別，表示 findHomography 函式給出的內點掩碼

該函式旨在根據 [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>

過濾視差圖中的細小噪聲點（斑點）。

引數

img	輸入的 16 位有符號視差影像
newVal	用於塗抹斑點的視差值
maxSpeckleSize	將其視為斑點的最大斑點尺寸。更大的斑點不受演算法影響
maxDiff	相鄰視差畫素之間的最大差異，以將它們放入同一斑點。請注意，由於 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	影像,
		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>

尋找棋盤格內角點的位置。

引數

影像	源棋盤檢視。它必須是 8 位灰度或彩色影像。
patternSize	每個棋盤格行和列的內部角點數量 ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) )。
corners	檢測到的角點的輸出陣列。
flags (標誌)	各種操作標誌，可以是零或以下值的組合 CALIB_CB_ADAPTIVE_THRESH 使用自適應閾值將影像轉換為黑白，而不是固定的閾值級別（從平均影像亮度計算）。 CALIB_CB_NORMALIZE_IMAGE 在應用固定或自適應閾值之前，使用 equalizeHist 歸一化影像 gamma。 CALIB_CB_FILTER_QUADS 使用額外標準（如輪廓面積、周長、類似正方形的形狀）在輪廓檢索階段過濾掉錯誤的四邊形。 CALIB_CB_FAST_CHECK 對影像進行快速檢查，查詢棋盤格角點，如果沒有找到則跳過呼叫。這可以顯著加快在未檢測到棋盤格的退化條件下的呼叫速度。 CALIB_CB_PLAIN 忽略所有其他標誌。輸入影像按原樣處理。不進行影像處理以改進棋盤格的查詢。這會加快函式的執行速度，但如果影像未事先以適當的方式二值化，則可能導致無法識別棋盤格。

該函式嘗試確定輸入影像是否為棋盤格圖案的檢視，並定位棋盤格內部角點。如果找到所有角點並按特定順序放置（逐行，每行從左到右），則函式返回非零值。否則，如果函式未能找到所有角點或未能重新排序，則返回 0。例如，一個規則的棋盤格有 8 x 8 個方格和 7 x 7 個內部角點，即黑方格相互接觸的點。檢測到的座標是近似值，為了更準確地確定它們的位置，函式呼叫 cornerSubPix。如果返回的座標不夠準確，您也可以使用不同引數的 cornerSubPix 函式。

檢測和繪製棋盤角點的示例用法：

Size patternsize(8,6); //內部角點數
Mat gray = ....; //源影像
vector<Point2f> corners; //這將填充檢測到的角點
 
//CALIB_CB_FAST_CHECK 在不包含任何棋盤格角點的影像上節省大量時間
//如果影像不包含任何棋盤格角點，CALIB_CB_FAST_CHECK 可節省大量時間
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	影像,
		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>

使用基於扇區的方法尋找棋盤格內角點的位置。

引數

影像	源棋盤檢視。它必須是 8 位灰度或彩色影像。
patternSize	每個棋盤格行和列的內部角點數量 ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) )。
corners	檢測到的角點的輸出陣列。
flags (標誌)	各種操作標誌，可以是零或以下值的組合 CALIB_CB_NORMALIZE_IMAGE 在檢測前使用 equalizeHist 歸一化影像 gamma。 CALIB_CB_EXHAUSTIVE 執行詳盡搜尋以提高檢測率。 CALIB_CB_ACCURACY 上取樣輸入影像以改善由於混疊效應引起的亞畫素精度。 CALIB_CB_LARGER 允許檢測到的圖案大於 patternSize（參見描述）。 CALIB_CB_MARKER 檢測到的圖案必須有標記（參見描述）。如果需要精確的相機校準，應使用此選項。
meta	可選的檢測到的角點輸出陣列（CV_8UC1 型別，大小 = cv::Size(columns,rows)）。每個條目代表圖案的一個角點，可以具有以下值之一： 0 = 未附加元資料 1 = 黑色單元格的左上角 2 = 白色單元格的左上角 3 = 帶白色標記點的黑色單元格的左上角 4 = 帶黑色標記點的白色單元格的左上角（帶標記情況下的圖案原點，否則為第一個角點）

該函式類似於 findChessboardCorners，但使用透過盒式濾波器近似的區域性 Radon 變換，對各種噪聲更魯棒，在大型影像上更快，並且能夠直接返回內部棋盤格角點的亞畫素位置。該方法基於論文 [78] "Accurate Detection and Localization of Checkerboard Corners for Calibration"，該論文證明返回的亞畫素位置比 cornerSubPix 返回的更準確，從而可以對要求高的應用進行精確的相機校準。

如果給定標誌 CALIB_CB_LARGER 或 CALIB_CB_MARKER，結果可以從可選的元資料陣列中恢復。這兩個標誌都有助於使用超出相機視場的校準圖案。這些超大圖案允許更準確的校準，因為可以使用盡可能靠近影像邊界的角點。為了在所有影像中保持一致的座標系，可以使用可選標記（見下圖）將棋盤格的原點移動到黑圓圈所在的位置。

注意

該函式要求棋盤格周圍有白色邊框，寬度大致與棋盤格的一個欄位相同，以改善在各種環境中的檢測。此外，由於區域性 Radon 變換，對棋盤格外部的欄位角點使用圓角是有益的。下圖說明了為檢測最佳化的示例棋盤格。但是，也可以使用任何其他棋盤格。

使用 generate_pattern.py Python 指令碼（建立校準圖案）建立相應的棋盤格圖案

findChessboardCornersSB() [2/2]

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

內聯

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	影像,
		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>

尋找圓網格中的中心點。

引數

影像	輸入圓的網格檢視；它必須是 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); //中心點數量
Mat gray = ...; //源影像
vector<Point2f> centers; //這將由檢測到的中心填充
 
bool patternfound = findCirclesGrid(gray, patternsize, centers);
 
drawChessboardCorners(img, patternsize, Mat(centers), patternfound);

注意

該函式要求棋盤格周圍有空白區域（例如方形厚邊框，越寬越好），以提高在各種環境下的檢測魯棒性。

findCirclesGrid() [2/2]

bool cv::findCirclesGrid	(	InputArray	影像,
		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	來自第一幅影像的 N 個（N >= 5）2D 點陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
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>

根據兩幅影像中的對應點計算本質矩陣。

引數

points1	來自第一幅影像的 N 個（N >= 5）2D 點陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
cameraMatrix	相機內部矩陣 \(\cameramatrix{A}\)。請注意，此函式假設 points1 和 points2 是來自具有相同相機內部矩陣的相機的特徵點。如果此假設不適用於您的用例，請使用其他函式過載或 undistortPoints 併為兩個相機使用 P = cv::NoArray() 將影像點轉換為歸一化影像座標，這對於單位相機內部矩陣是有效的。當傳遞這些座標時，將此引數傳遞為單位矩陣。
method	計算本質矩陣的方法。 RANSAC 用於 RANSAC 演算法。 LMEDS 用於 LMedS 演算法。
prob	僅用於 RANSAC 或 LMedS 方法的引數。它指定了估計矩陣正確的期望置信度（機率）。
閾值 (threshold)	RANSAC 引數。它是從點到對極線在畫素中的最大距離，超出此距離的點被視為離群點，不用於計算最終的基本矩陣。可以設定為 1-3 左右，具體取決於點定位的精度、影像解析度和影像噪聲。
mask	N 個元素的輸出陣列，每個元素對離群點設定為 0，對其他點設定為 1。該陣列僅在 RANSAC 和 LMedS 方法中計算。
maxIters	魯棒方法的最大迭代次數。

此函式基於 [214] 中的五點演算法求解器估算本質矩陣。 [258] 也與此相關。對極幾何由以下方程描述

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

其中 \(E\) 是本質矩陣，\(p_1\) 和 \(p_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>

根據兩幅影像（可能來自兩臺不同的相機）中的對應點計算本質矩陣。

引數

points1	來自第一幅影像的 N 個（N >= 5）2D 點陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
cameraMatrix1	第一個相機的相機矩陣 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\)。
cameraMatrix2	第二個相機的相機矩陣 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\)。
distCoeffs1	第一個相機的畸變係數輸入向量 \((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/空，則假定畸變係數為零。
distCoeffs2	第二個相機的畸變係數輸入向量 \((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/空，則假定畸變係數為零。
method	計算本質矩陣的方法。 RANSAC 用於 RANSAC 演算法。 LMEDS 用於 LMedS 演算法。
prob	僅用於 RANSAC 或 LMedS 方法的引數。它指定了估計矩陣正確的期望置信度（機率）。
閾值 (threshold)	RANSAC 引數。它是從點到對極線在畫素中的最大距離，超出此距離的點被視為離群點，不用於計算最終的基本矩陣。可以設定為 1-3 左右，具體取決於點定位的精度、影像解析度和影像噪聲。
mask	N 個元素的輸出陣列，每個元素對離群點設定為 0，對其他點設定為 1。該陣列僅在 RANSAC 和 LMedS 方法中計算。

此函式基於 [214] 中的五點演算法求解器估算本質矩陣。 [258] 也與此相關。對極幾何由以下方程描述

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

其中 \(E\) 是本質矩陣，\(p_1\) 和 \(p_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>

根據兩幅影像中的對應點計算基礎矩陣。

引數

	points1	來自第一幅影像的 N 個點陣列。點座標應為浮點數（單精度或雙精度）。
	points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
	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\) 是基本矩陣，\(p_1\) 和 \(p_2\) 分別是第一幅影像和第二幅影像中的對應點。

該函式使用上面列出的四種方法之一計算基本矩陣並返回找到的基本矩陣。通常只找到一個矩陣。但在 7 點演算法的情況下，該函式可能返回最多 3 個解（\(9 \times 3\) 矩陣，按順序儲存所有 3 個矩陣）。

計算出的基本矩陣可以進一步傳遞給 computeCorrespondEpilines，該函式查詢與指定點對應的對極線。它也可以傳遞給 stereoRectifyUncalibrated 來計算校正變換。

// 示例。使用 RANSAC 演算法估計基本矩陣
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// 在此處初始化點...
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>

尋找兩個平面之間的透視變換。

引數

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\) ）都符合剛性透視變換（即存在一些異常值），則此初始估計將很差。在這種情況下，您可以使用三種魯棒方法之一。RANSAC、LMeDS 和 RHO 方法嘗試許多不同的對應點對隨機子集（每組四對，共線對被丟棄），使用此子集和簡單的最小二乘演算法估計單應性矩陣，然後計算計算出的單應性的質量/優劣（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/空，則假定畸變係數為零。
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	如果為零或負，則 \(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{儘管顯示的方程用於徑向去畸變，但函式實現了 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 計算校正變換。對於投影儀和相機，該函式計算單應性 H 作為畫素域中的校正變換，而不是 3D 空間中的旋轉矩陣 R。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/空，則假定畸變係數為零。
R	物件空間中的可選校正變換（3x3 矩陣）。這裡可以傳遞由 stereoRectify 計算的 R1 或 R2。如果矩陣為空，則假定為單位變換。
newCameraMatrix	新的相機矩陣 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\)。
size (大小)	畸變影像大小。
m1type	第一個輸出對映的型別。可以是 CV_32FC1, CV_32FC2 或 CV_16SC2，請參見 convertMaps
map1	remap 的第一個輸出對映。
map2	remap 的第二個輸出對映。

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。例如，這有助於對齊立體相機的兩個頭部，使得兩幅影像上的極線都變為水平並具有相同的 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]]]])\) 是畸變係數。

在立體相機的情況下，該函式被呼叫兩次：在 stereoRectify 之後，每個相機頭一次，而 stereoRectify 又在 stereoCalibrate 之後呼叫。但是，如果立體相機未校準，仍然可以直接從基礎矩陣使用 stereoRectifyUncalibrated 計算校正變換。對於每個相機，該函式計算單應性 H 作為畫素域中的校正變換，而不是 3D 空間中的旋轉矩陣 R。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/空，則假定畸變係數為零。
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	第一個輸出對映的型別，可以是 CV_32FC1, CV_32FC2 或 CV_16SC2，請參見 convertMaps
map1	第一個輸出對映。
map2	第二個輸出對映。

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	第一個相乘矩陣。
B	第二個相乘矩陣。
dABdA	第一個輸出導數矩陣 d(A*B)/dA，大小為 \(\texttt{A.rows*B.cols} \times {A.rows*A.cols}\)。
dABdB	第二個輸出導數矩陣 d(A*B)/dB，大小為 \(\texttt{A.rows*B.cols} \times {B.rows*B.cols}\)。

該函式計算矩陣乘積 \(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	旋轉向量（Rodrigues），與 tvec 一起執行從世界座標系到相機座標系的基變換，詳情請參閱 calibrateCamera。
tvec	平移向量，請參閱上面引數描述。
cameraMatrix	相機內參矩陣 \(\cameramatrix{A}\)。
distCoeffs	輸入畸變係數向量 \(\distcoeffs\)。如果向量為空，則假定為零畸變係數。
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	來自第一張影像的 N 個 2D 點的陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
cameraMatrix	相機內參矩陣 \(\cameramatrix{A}\)。請注意，此函式假定 points1 和 points2 是來自具有相同相機內參矩陣的相機的特徵點。
R	輸出旋轉矩陣。與平移向量一起，此矩陣構成一個元組，執行從第一個相機座標系到第二個相機座標系的基變換。請注意，通常情況下，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>

根據估算的本質矩陣和兩幅影像中的對應點，透過手性檢查（chirality check）恢復相機的相對旋轉和平移。返回透過檢查的內點數量。

引數

E	輸入的本質矩陣。
points1	來自第一張影像的 N 個 2D 點的陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
cameraMatrix	相機內參矩陣 \(\cameramatrix{A}\)。請注意，此函式假定 points1 和 points2 是來自具有相同相機內參矩陣的相機的特徵點。
R	輸出旋轉矩陣。與平移向量一起，此矩陣構成一個元組，執行從第一個相機座標系到第二個相機座標系的基變換。請注意，通常情況下，t 不能用於此元組，請參閱下面描述的引數。
t	輸出平移向量。此向量透過 decomposeEssentialMat 獲得，因此僅已知其尺度，即 t 是平移向量的方向，並且具有單位長度。
mask	points1 和 points2 中內點的輸入/輸出掩碼。如果它不為空，則它標記給定基本矩陣 E 的 points1 和 points2 中的內點。只有這些內點將用於恢復姿態。在輸出掩碼中，只有透過手性檢查的內點。

此函式使用 decomposeEssentialMat 分解基本矩陣，然後透過手性檢查驗證可能的姿態假設。手性檢查意味著三角測量的 3D 點應具有正深度。有關詳細資訊，請參見 [214]。

此函式可用於處理來自 findEssentialMat 的輸出 E 和 mask。在這種情況下，points1 和 points2 是 findEssentialMat 的相同輸入。

// 示例。使用 RANSAC 演算法估計基本矩陣
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// 在此處初始化點...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
 
// 焦距均為 1，主點為 (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	來自第一張影像的 N 個 2D 點的陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
R	輸出旋轉矩陣。與平移向量一起，此矩陣構成一個元組，執行從第一個相機座標系到第二個相機座標系的基變換。請注意，通常情況下，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>

利用手性檢查（cheirality check），從兩臺不同相機的兩幅影像中的對應點恢復相機的相對旋轉和平移。返回透過檢查的內點（inliers）數量。

引數

points1	來自第一張影像的 N 個 2D 點的陣列。點座標應為浮點數（單精度或雙精度）。
points2	第二幅影像中的點陣列，與 points1 大小和格式相同。
cameraMatrix1	第一個相機的輸入/輸出相機矩陣，與 calibrateCamera 中相同。此外，對於立體情況，可以使用額外的標誌，請參閱下文。
distCoeffs1	輸入/輸出畸變係數向量，與 calibrateCamera 中相同。
cameraMatrix2	第一個相機的輸入/輸出相機矩陣，與 calibrateCamera 中相同。此外，對於立體情況，可以使用額外的標誌，請參閱下文。
distCoeffs2	輸入/輸出畸變係數向量，與 calibrateCamera 中相同。
E	輸出基本矩陣。
R	輸出旋轉矩陣。與平移向量一起，此矩陣構成一個元組，執行從第一個相機座標系到第二個相機座標系的基變換。請注意，通常情況下，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 的相同輸入。

// 示例。使用 RANSAC 演算法估計基本矩陣
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
 
// 在此處初始化點...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
 
// 輸入：兩個相機的相機校準，例如使用內部棋盤校準。
Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 
// 輸出：基本矩陣、相對旋轉和相對平移。
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>

計算三頭相機的校正變換，其中所有相機頭都在同一直線上。

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 位有符號格式的值假定沒有小數位。如果視差是 16 位有符號格式，如由 StereoBM 或 StereoSGBM 以及其他演算法計算的，它在使用前應除以 16（並縮放到浮點數）。
_3dImage	輸出 3 通道浮點影像，與視差影像大小相同。_3dImage(x,y) 的每個元素包含從視差圖計算的點 (x,y) 的 3D 座標。如果使用 stereoRectify 獲得的 Q，則返回的點以第一個相機的校正座標系表示。
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 個自由度）。該表示用於全域性 3D 幾何最佳化過程，如 calibrateCamera、stereoCalibrate 或 solvePnP。

注意

有關 3D 旋轉矩陣對其指數座標導數計算的更多資訊，請參見

• 《三維旋轉指數座標導數的緊湊公式》，Guillermo Gallego, Anthony J. Yezzi [100]

有關 SE(3) 和李群的有用資訊，請參見

• 《SE(3) 變換引數化和流形最佳化教程》，Jose-Luis Blanco [31]
• 《2D 和 3D 變換的李群》，Ethan Eade [82]
• 《機器人狀態估計的微李理論》，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	可選輸出 3x3 繞 x 軸旋轉矩陣。
Qy	可選輸出 3x3 繞 y 軸旋轉矩陣。
Qz	可選輸出 3x3 繞 z 軸旋轉矩陣。

該函式使用給定的旋轉計算 RQ 分解。該函式用於 decomposeProjectionMatrix 將投影矩陣的左上角 3x3 子矩陣分解為相機和旋轉矩陣。

它可選地返回三個旋轉矩陣，每個軸一個，以及三個以度為單位的尤拉角（作為返回值），可用於 OpenGL。請注意，始終存在不止一種圍繞三個主軸的旋轉序列，可以產生相同的物件方向，例如參見 [254]。返回的三個旋轉矩陣和相應的三個尤拉角只是可能的解決方案之一。

sampsonDistance()

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

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

#include <opencv2/calib3d.hpp>

計算兩點之間的 Sampson 距離。

函式 cv::sampsonDistance 計算並返回幾何誤差的一階近似值：

\[ 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	第一個齊次 2d 點
pt2	第二個齊次 2d 點
F	基本矩陣

返回

計算出的 Sampson 距離。

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 \)。

透視投影，從物件幀到相機幀

另請參閱

透視-n-點 (PnP) 姿態計算

引數

objectPoints	物體座標空間中的物體點陣列，3x3 1 通道或 1x3/3x1 3 通道。這裡也可以傳遞 vector<Point3f>。
imagePoints	對應的影像點陣列，3x2 1 通道或 1x3/3x1 2 通道。這裡也可以傳遞 vector<Point2f>。
cameraMatrix	輸入相機內參矩陣 \(\cameramatrix{A}\)。
distCoeffs	輸入畸變係數向量 \(\distcoeffs\)。如果向量為 NULL/空，則假定畸變係數為零。
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 \)

透視投影，從物件幀到相機幀

另請參閱

透視-n-點 (PnP) 姿態計算

該函式使用不同的方法返回將物件座標系中表示的 3D 點轉換為相機座標系的旋轉和平移向量。

• P3P 方法（SOLVEPNP_P3P、SOLVEPNP_AP3P）：需要 4 個輸入點才能返回唯一解。
• SOLVEPNP_IPPE 輸入點必須 >= 4 且物件點必須共面。
• SOLVEPNP_IPPE_SQUARE 適用於標記姿態估計的特殊情況。輸入點數必須為 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]
• 對於所有其他標誌，輸入點數必須 >= 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/空，則假定畸變係數為零。
rvec	輸出旋轉向量（參見 Rodrigues），與 tvec 一起將點從模型座標系轉換到相機座標系。
tvec	輸出平移向量。
useExtrinsicGuess	用於 SOLVEPNP_ITERATIVE 的引數。如果為 true (1)，則函式使用提供的 rvec 和 tvec 值作為旋轉和平移向量的初始近似值，並進一步最佳化它們。
flags (標誌)	解決 PnP 問題的方法：參見 calib3d_solvePnP_flags

有關 Perspective-n-Points 的更多資訊，請參見 Perspective-n-Point (PnP) 姿態計算

注意

• 如何在平面增強現實中使用 solvePnP 的示例可以在 opencv_source_code/samples/python/plane_ar.py 中找到。
• 如果您正在使用 Python
  • Numpy 陣列切片不能作為輸入，因為 solvePnP 需要連續陣列（由 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 第 55 行左右的 cv::Mat::checkVector() 斷言強制執行）。
  • P3P 演算法要求影像點為形狀 (N,1,2) 的陣列，因為它呼叫了 undistortPoints（modules/calib3d/src/solvepnp.cpp 版本 2.4.9 第 75 行左右），該函式需要 2 通道資訊。
  • 因此，給定一些資料 D = np.array(...)，其中 D.shape = (N,M)，為了將其子集用作（例如）imagePoints，必須將其有效地複製到一個新陣列中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
• 方法 SOLVEPNP_DLS 和 SOLVEPNP_UPNP 不能使用，因為當前的實現不穩定，有時會給出完全錯誤的結果。如果您傳遞這兩個標誌中的一個，將改用 SOLVEPNP_EPNP 方法。
• 在一般情況下，最小點數為 4。對於 SOLVEPNP_P3P 和 SOLVEPNP_AP3P 方法，需要精確使用 4 個點（前 3 個點用於估計 P3P 問題的所有解，最後一個點用於保留最小化重投影誤差的最佳解）。
• 使用 SOLVEPNP_ITERATIVE 方法且 useExtrinsicGuess=true 時，最小點數為 3（3 個點足以計算姿態，但最多有 4 個解）。初始解應接近全域性解才能收斂。如果找到某個解，函式返回 true。使用者程式碼負責評估解的質量。
• 使用 SOLVEPNP_IPPE 輸入點必須 >= 4 且物件點必須共面。
• 使用 SOLVEPNP_IPPE_SQUARE 這是一種適用於標記姿態估計的特殊情況。輸入點數必須為 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 輸入點必須 >= 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 \)。

透視投影，從物件幀到相機幀

另請參閱

透視-n-點 (PnP) 姿態計算

此函式返回所有可能的解決方案列表（一個解決方案是 <旋轉向量，平移向量> 對），具體取決於輸入點數和所選方法：

• P3P 方法（SOLVEPNP_P3P，SOLVEPNP_AP3P）：3 或 4 個輸入點。3 個輸入點時返回的解決方案數可以在 0 到 4 之間。
• SOLVEPNP_IPPE 輸入點必須 >= 4 且物件點必須共面。返回 2 個解決方案。
• SOLVEPNP_IPPE_SQUARE 適用於標記姿態估計的特殊情況。輸入點數必須為 4，返回 2 個解決方案。物件點必須按以下順序定義：
  • 點 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/空，則假定畸變係數為零。
rvecs	輸出旋轉向量的向量（參見 Rodrigues），與 tvecs 一起將點從模型座標系轉換到相機座標系。
tvecs	輸出平移向量的向量。
useExtrinsicGuess	用於 SOLVEPNP_ITERATIVE 的引數。如果為 true (1)，則函式使用提供的 rvec 和 tvec 值作為旋轉和平移向量的初始近似值，並進一步最佳化它們。
flags (標誌)	解決 PnP 問題的方法：參見 calib3d_solvePnP_flags
rvec	當 flags 為 SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 設定為 true 時，用於初始化迭代 PnP 精煉演算法的旋轉向量。
tvec	當 flags 為 SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 設定為 true 時，用於初始化迭代 PnP 精煉演算法的平移向量。
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 中找到。
• 如果您正在使用 Python
  • Numpy 陣列切片不能作為輸入，因為 solvePnP 需要連續陣列（由 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 第 55 行左右的 cv::Mat::checkVector() 斷言強制執行）。
  • P3P 演算法要求影像點為形狀 (N,1,2) 的陣列，因為它呼叫了 undistortPoints（modules/calib3d/src/solvepnp.cpp 版本 2.4.9 第 75 行左右），該函式需要 2 通道資訊。
  • 因此，給定一些資料 D = np.array(...)，其中 D.shape = (N,M)，為了將其子集用作（例如）imagePoints，必須將其有效地複製到一個新陣列中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
• 方法 SOLVEPNP_DLS 和 SOLVEPNP_UPNP 不能使用，因為當前的實現不穩定，有時會給出完全錯誤的結果。如果您傳遞這兩個標誌中的一個，將改用 SOLVEPNP_EPNP 方法。
• 在一般情況下，最小點數為 4。對於 SOLVEPNP_P3P 和 SOLVEPNP_AP3P 方法，需要精確使用 4 個點（前 3 個點用於估計 P3P 問題的所有解，最後一個點用於保留最小化重投影誤差的最佳解）。
• 使用 SOLVEPNP_ITERATIVE 方法且 useExtrinsicGuess=true 時，最小點數為 3（3 個點足以計算姿態，但最多有 4 個解）。初始解應接近全域性解才能收斂。
• 使用 SOLVEPNP_IPPE 輸入點必須 >= 4 且物件點必須共面。
• 使用 SOLVEPNP_IPPE_SQUARE 這是一種適用於標記姿態估計的特殊情況。輸入點數必須為 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 輸入點必須 >= 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 \)，以處理錯誤匹配。

透視投影，從物件幀到相機幀

另請參閱

透視-n-點 (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/空，則假定畸變係數為零。
rvec	輸出旋轉向量（參見 Rodrigues），與 tvec 一起將點從模型座標系轉換到相機座標系。
tvec	輸出平移向量。
useExtrinsicGuess	用於 SOLVEPNP_ITERATIVE 的引數。如果為 true (1)，則函式使用提供的 rvec 和 tvec 值作為旋轉和平移向量的初始近似值，並進一步最佳化它們。
iterationsCount	迭代次數。
reprojectionError	RANSAC 過程使用的內點閾值。引數值是觀測點和計算點投影之間的最大允許距離，以將其視為內點。
confidence	演算法產生有用結果的機率。
inliers	輸出向量，包含 objectPoints 和 imagePoints 中內點的索引。
flags (標誌)	解決 PnP 問題的方法（參見 solvePnP）。

該函式根據一組物件點、它們對應的影像投影以及相機內參矩陣和畸變係數來估計物件姿態。該函式找到最小化重投影誤差的姿態，即觀測投影 imagePoints 與投影（使用 projectPoints）物件點之間的平方距離之和。使用 RANSAC 使該函式對異常值具有魯棒性。

注意

• 如何使用 solvePnPRansac 進行物體檢測的示例可以在 紋理物體的即時姿態估計 中找到。
• 用於最小樣本集步驟的相機姿態估計的預設方法是 SOLVEPNP_EPNP。例外情況是：
  • 如果您選擇 SOLVEPNP_P3P 或 SOLVEPNP_AP3P，將使用這些方法。
  • 如果輸入點數等於 4，則使用 SOLVEPNP_P3P。
• 使用所有內點估計相機姿態的方法由 flags 引數定義，除非它等於 SOLVEPNP_P3P 或 SOLVEPNP_AP3P。在這種情況下，將改用 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 點變換到相機座標系的平移和旋轉向量）。

另請參閱

透視-n-點 (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/空，則假定畸變係數為零。
rvec	輸入/輸出旋轉向量（參見 Rodrigues），與 tvec 一起將點從模型座標系轉換到相機座標系。輸入值用作初始解。
tvec	輸入/輸出平移向量。輸入值用作初始解。
criteria	Levenberg-Marquard 迭代演算法停止的條件。

該函式細化物件姿態，給定至少 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 點變換到相機座標系的平移和旋轉向量）。

另請參閱

透視-n-點 (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/空，則假定畸變係數為零。
rvec	輸入/輸出旋轉向量（參見 Rodrigues），與 tvec 一起將點從模型座標系轉換到相機座標系。輸入值用作初始解。
tvec	輸入/輸出平移向量。輸入值用作初始解。
criteria	Levenberg-Marquard 迭代演算法停止的條件。
VVSlambda	虛擬視覺伺服控制律的增益，等同於阻尼高斯-牛頓公式中的 \(\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>

標定雙目相機設定。此函式計算兩個相機各自的內參數，以及兩個相機之間的外引數。

引數

objectPoints	校準模式點的向量的向量。與 calibrateCamera 中的結構相同。對於每個模式檢視，兩個相機都需要看到相同的物件點。因此，objectPoints.size()、imagePoints1.size() 和 imagePoints2.size() 需要相等，並且對於每個 i，objectPoints[i].size()、imagePoints1[i].size() 和 imagePoints2[i].size() 也需要相等。
imagePoints1	由第一個相機觀測到的校準模式點投影的向量的向量。與 calibrateCamera 中的結構相同。
imagePoints2	由第二個相機觀測到的校準模式點投影的向量的向量。與 calibrateCamera 中的結構相同。
cameraMatrix1	第一個相機的輸入/輸出相機內參矩陣，與 calibrateCamera 中相同。此外，對於立體情況，可以使用額外的標誌，請參閱下文。
distCoeffs1	輸入/輸出畸變係數向量，與 calibrateCamera 中相同。
cameraMatrix2	第二個相機的輸入/輸出相機內參矩陣。參見 cameraMatrix1 的描述。
distCoeffs2	第二個相機的輸入/輸出鏡頭畸變係數。參見 distCoeffs1 的描述。
imageSize	僅用於初始化相機內參矩陣的影像大小。
R	輸出旋轉矩陣。與平移向量 T 一起，此矩陣將第一個相機座標系中的點轉換到第二個相機座標系中的點。更專業地說，R 和 T 的元組執行從第一個相機座標系到第二個相機座標系的基變換。由於其對偶性，此元組等同於第一個相機相對於第二個相機座標系的位置。
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	迭代最佳化演算法的終止條件。

該函式估計構成立體對的兩個相機之間的變換。如果計算一個物體相對於第一個相機和第二個相機的姿態，分別為（\(R_1\), \(T_1\)）和（\(R_2\), \(T_2\)），對於兩個相機之間相對位置和方向固定的立體相機，這些姿態之間肯定存在關聯。這意味著，如果已知兩個相機的相對位置和方向（\(R\), \(T\)），則在給定（\(R_1\), \(T_1\)）時可以計算（\(R_2\), \(T_2\)）。這就是所描述函式的作用。它計算（\(R\), \(T\)），使得

\[R_2=R R_1\]

\[T_2=R T_1 + T.\]

因此，當給定一個3D點在第一個相機座標系中的座標表示時，可以計算出該點在第二個相機座標系中的座標表示

\[\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}.\]

可選地，它計算本徵矩陣 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\) 。該函式還可以計算基本矩陣 F

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

除了立體相關資訊外，該函式還可以對兩個相機中的每一個進行完整校準。然而，由於引數空間的高維度和輸入資料中的噪聲，該函式可能會偏離正確解。如果可以單獨高精度地估計每個相機的內參（例如，使用 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>

為已標定的立體相機的每個鏡頭計算校正變換。

引數

cameraMatrix1	第一個相機內參矩陣。
distCoeffs1	第一個相機畸變引數。
cameraMatrix2	第二個相機內參矩陣。
distCoeffs2	第二個相機畸變引數。
imageSize	用於立體校準的影像大小。
R	從第一個相機座標系到第二個相機座標系的旋轉矩陣，參見 stereoCalibrate。
T	從第一個相機座標系到第二個相機座標系的平移向量，參見 stereoCalibrate。
R1	第一個相機的輸出 3x3 整流變換（旋轉矩陣）。此矩陣將未整流的第一個相機座標系中的點轉換為整流的第一個相機座標系中的點。更專業地說，它執行從未整流的第一個相機座標系到整流的第一個相機座標系的基變換。
R2	第二個相機的輸出 3x3 整流變換（旋轉矩陣）。此矩陣將未整流的第二個相機座標系中的點轉換為整流的第二個相機座標系中的點。更專業地說，它執行從未整流的第二個相機座標系到整流的第二個相機座標系的基變換。
P1	第一個相機在新（整流）座標系中的輸出 3x4 投影矩陣，即它將整流的第一個相機座標系中的點投影到整流的第一個相機影像中。
P2	第二個相機在新（整流）座標系中的輸出 3x4 投影矩陣，即它將整流的第一個相機座標系中的點投影到整流的第二個相機影像中。
Q	輸出 \(4 \times 4\) 視差到深度對映矩陣（參見 reprojectImageTo3D）。
flags (標誌)	操作標誌，可以是零或 CALIB_ZERO_DISPARITY 。如果設定了該標誌，函式將使每個相機的主點在整流檢視中具有相同的畫素座標。如果未設定該標誌，函式仍可能在水平或垂直方向（取決於外極線的方向）移動影像以最大化有效影像區域。
alpha	自由縮放參數。如果為 -1 或缺失，函式執行預設縮放。否則，引數應在 0 到 1 之間。alpha=0 表示整流影像被縮放和平移，以便只有有效畫素可見（整流後沒有黑色區域）。alpha=1 表示整流影像被抽樣和平移，以便原始影像中來自相機的所有畫素都保留在整流影像中（沒有源影像畫素丟失）。任何中間值都會產生介於這兩個極端情況之間的中間結果。
新影像解析度	整流後的新影像解析度。應將相同的大小傳遞給 initUndistortRectifyMap （參見 OpenCV 示例目錄中的 stereo_calib.cpp 示例）。當傳遞 (0,0) （預設）時，它被設定為原始 imageSize。將其設定為更大的值可以幫助您保留原始影像中的細節，尤其是在存在較大徑向畸變時。
有效畫素ROI1	整流影像中所有畫素都有效的可選輸出矩形。如果 alpha=0，ROI 覆蓋整個影像。否則，它們可能更小（參見下圖）。
有效畫素ROI2	整流影像中所有畫素都有效的可選輸出矩形。如果 alpha=0，ROI 覆蓋整個影像。否則，它們可能更小（參見下圖）。

該函式計算每個相機的旋轉矩陣，這些矩陣（虛擬地）使兩個相機的影像平面處於同一平面。因此，這使得所有對極線平行，從而簡化了稠密立體對應問題。該函式以 stereoCalibrate 計算的矩陣作為輸入。作為輸出，它提供兩個旋轉矩陣以及新座標中的兩個投影矩陣。該函式區分以下兩種情況

• 水平立體：第一個和第二個相機檢視主要沿 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\)。

• 垂直立體：第一個和第二個相機檢視主要在垂直方向上相互偏移（並且可能在水平方向上也有一點偏移）。整流影像中的對極線是垂直的，並且具有相同的 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 的前三列將有效地成為新的“整流”相機矩陣。然後，這些矩陣以及 R1 和 R2 可以傳遞給 initUndistortRectifyMap 以初始化每個相機的整流圖。

參見下面的 stereo_calib.cpp 示例截圖。一些紅色水平線穿過相應的影像區域。這意味著影像已很好地整流，這是大多數立體對應演算法所依賴的。綠色矩形是 roi1 和 roi2。您可以看到它們的內部都是有效畫素。

影像

stereoRectifyUncalibrated()

bool cv::stereoRectifyUncalibrated	(	InputArray	points1,
		InputArray	points2,
		InputArray	F,
		Size	影像尺寸,
		OutputArray	H1,
		OutputArray	H2,
		double	threshold = 5 )

Python
	cv.stereoRectifyUncalibrated(	points1, points2, F, imgSize[, H1[, H2[, threshold]]]	) ->	返回值, H1, H2

#include <opencv2/calib3d.hpp>

為未標定的立體相機計算校正變換。

引數

points1	第一個影像中的特徵點陣列。
points2	第二個影像中對應的點。支援與 findFundamentalMat 相同的格式。
F	輸入基本矩陣。可以使用 findFundamentalMat 從同一組點對計算。
影像尺寸	影像大小。
H1	第一個影像的輸出整流單應矩陣。
H2	第二個影像的輸出整流單應矩陣。
閾值 (threshold)	用於濾除異常值的可選閾值。如果引數大於零，則所有不符合對極幾何的點對（即，對於 \(|\texttt{points2[i]}^T \cdot \texttt{F} \cdot \texttt{points1[i]}|>\texttt{threshold}\) 的點）在計算單應矩陣之前被拒絕。否則，所有點都被視為內點。

該函式在不知道相機內參及其在空間中的相對位置的情況下計算整流變換，這就是“未校準”字尾的原因。與 stereoRectify 的另一個相關區別是，該函式輸出的不是物件（3D）空間中的整流變換，而是由單應矩陣 H1 和 H2 編碼的平面透視變換。該函式實現了演算法 [121] 。

注意

雖然該演算法不需要知道相機的內參，但它嚴重依賴於對極幾何。因此，如果相機鏡頭有顯著畸變，最好在計算基本矩陣和呼叫此函式之前對其進行校正。例如，可以使用 calibrateCamera 分別估計立體相機每個頭部的畸變係數。然後，可以使用 undistort 校正影像，或者只使用 undistortPoints 校正點座標。

triangulatePoints()

void cv::triangulatePoints	(	InputArray	投影矩陣1,
		InputArray	投影矩陣2,
		InputArray	投影點1,
		InputArray	投影點2,
		OutputArray	點4D )

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

#include <opencv2/calib3d.hpp>

此函式利用立體相機的觀測結果重建三維點（齊次座標）。

引數

投影矩陣1	第一個相機的 3x4 投影矩陣，即此矩陣將世界座標系中給定的 3D 點投影到第一個影像中。
投影矩陣2	第二個相機的 3x4 投影矩陣，即此矩陣將世界座標系中給定的 3D 點投影到第二個影像中。
投影點1	第一個影像中的 2xN 陣列特徵點。在 c++ 版本中，它也可以是特徵點向量或 1xN 或 Nx1 大小的雙通道矩陣。
投影點2	第二個影像中對應的 2xN 陣列點。在 c++ 版本中，它也可以是特徵點向量或 1xN 或 Nx1 大小的雙通道矩陣。
點4D	齊次座標中重建點的 4xN 陣列。這些點在世界座標系中返回。

注意

請記住，所有輸入資料都應為浮點型別，以便此函式工作。

如果使用 stereoRectify 的投影矩陣，則返回的點表示在第一個相機的整流座標系中。

另請參閱

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 進行調節。您可以使用 getOptimalNewCameraMatrix 根據您的要求計算合適的 newCameraMatrix。

相機矩陣和畸變引數可以使用 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/空，則假定畸變係數為零。
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{僅當P被指定時執行：} \\ 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/空，則假定畸變係數為零。
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	成本,
		int	minDisparity,
		int	numberOfDisparities,
		int	disp12MaxDisp = 1 )

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

#include <opencv2/calib3d.hpp>

使用左右檢查（left-right check）驗證視差。矩陣“cost”應由雙目匹配演算法計算得出。