OpenCV 4.5.3(日本語機械翻訳)
モジュール | クラス | 型定義 | 列挙型 | 関数 | 変数
Camera Calibration and 3D Reconstruction

モジュール
Fisheye camera model
C API

クラス
struct cv::UsacParams
class cv::LMSolver
struct cv::CirclesGridFinderParameters
class cv::StereoMatcher
ステレオ対応点探索アルゴリズムの基底クラスです．[【詳解】（英語］
class cv::StereoBM
K. KonoligeによってOpenCVに導入・貢献された，ブロックマッチングアルゴリズムを用いたステレオ対応点計算のクラス．[【詳解】（英語］
class cv::StereoSGBM
このクラスは，修正されたH. Hirschmullerアルゴリズムを実装しています[HH08]を実装しています．を実装しており，オリジナルのアルゴリズムとは以下のように異なります．[【詳解】（英語］

型定義
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::SolvePnPMethod {
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 , cv::SOLVEPNP_MAX_COUNT
}
enum {
CALIB_CB_ADAPTIVE_THRESH = 1 , CALIB_CB_NORMALIZE_IMAGE = 2 , CALIB_CB_FILTER_QUADS = 4 , CALIB_CB_FAST_CHECK = 8 ,
CALIB_CB_EXHAUSTIVE = 16 , CALIB_CB_ACCURACY = 32 , CALIB_CB_LARGER = 64 , CALIB_CB_MARKER = 128
}
enum { CALIB_CB_SYMMETRIC_GRID = 1 , CALIB_CB_ASYMMETRIC_GRID = 2 , CALIB_CB_CLUSTERING = 4 }
enum {
CALIB_NINTRINSIC = 18 , CALIB_USE_INTRINSIC_GUESS = 0x00001 , CALIB_FIX_ASPECT_RATIO = 0x00002 , CALIB_FIX_PRINCIPAL_POINT = 0x00004 ,
CALIB_ZERO_TANGENT_DIST = 0x00008 , CALIB_FIX_FOCAL_LENGTH = 0x00010 , CALIB_FIX_K1 = 0x00020 , CALIB_FIX_K2 = 0x00040 ,
CALIB_FIX_K3 = 0x00080 , CALIB_FIX_K4 = 0x00800 , CALIB_FIX_K5 = 0x01000 , CALIB_FIX_K6 = 0x02000 ,
CALIB_RATIONAL_MODEL = 0x04000 , CALIB_THIN_PRISM_MODEL = 0x08000 , CALIB_FIX_S1_S2_S3_S4 = 0x10000 , CALIB_TILTED_MODEL = 0x40000 ,
CALIB_FIX_TAUX_TAUY = 0x80000 , cv::CALIB_USE_QR = 0x100000 , CALIB_FIX_TANGENT_DIST = 0x200000 , CALIB_FIX_INTRINSIC = 0x00100 ,
CALIB_SAME_FOCAL_LENGTH = 0x00200 , 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::RobotWorldHandEyeCalibrationMethod { cv::CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0 , cv::CALIB_ROBOT_WORLD_HAND_EYE_LI = 1 }
enum SamplingMethod { SAMPLING_UNIFORM , SAMPLING_PROGRESSIVE_NAPSAC , SAMPLING_NAPSAC , SAMPLING_PROSAC }
enum LocalOptimMethod {
LOCAL_OPTIM_NULL , LOCAL_OPTIM_INNER_LO , LOCAL_OPTIM_INNER_AND_ITER_LO , LOCAL_OPTIM_GC ,
LOCAL_OPTIM_SIGMA
}
enum ScoreMethod { SCORE_METHOD_RANSAC , SCORE_METHOD_MSAC , SCORE_METHOD_MAGSAC , SCORE_METHOD_LMEDS }
enum NeighborSearchMethod { NEIGH_FLANN_KNN , NEIGH_GRID , NEIGH_FLANN_RADIUS }
enum cv::UndistortTypes { PROJ_SPHERICAL_ORTHO = 0 , PROJ_SPHERICAL_EQRECT = 1 }
cv::undistortモード

関数
CV_EXPORTS_W void cv::Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray())
回転行列を回転ベクトルに変換したり，逆に回転行列を回転ベクトルに変換したりします．[【詳解】（英語］
CV_EXPORTS_W Mat cv::findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray(), const int maxIters=2000, const double confidence=0.995)
2つの平面間の透視変換を求めます．[【詳解】（英語］
CV_EXPORTS Mat cv::findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3)
CV_EXPORTS_W Mat cv::findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, const UsacParams &params)
CV_EXPORTS_W Vec3d cv::RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
3x3 行列の RQ 分解を計算します。[【詳解】（英語］
CV_EXPORTS_W void cv::decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray())
射影行列を，回転行列とカメラ固有の行列に分解します．[【詳解】（英語］
CV_EXPORTS_W void cv::matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
乗算された各行列について，行列積の偏導関数を求めます．[【詳解】（英語］
CV_EXPORTS_W void cv::composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray())
2つの回転とシフトの変換を組み合わせます。[【詳解】（英語］
CV_EXPORTS_W void cv::projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0)
3次元点を画像平面に投影します．[【詳解】（英語］
CV_EXPORTS_W bool cv::solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=SOLVEPNP_ITERATIVE)
3次元と2次元の点の対応関係から，物体の姿勢を求めます．この関数は，物体座標フレームで表現された3次元点をカメラ座標フレームに変換する回転ベクトルと並進ベクトルを，異なる手法で返します．[【詳解】（英語］
CV_EXPORTS_W 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 点の対応関係から物体のポーズを求めます．[【詳解】（英語］
CV_EXPORTS_W bool cv::solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputOutputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, OutputArray inliers, const UsacParams &params=UsacParams())
CV_EXPORTS_W int cv::solveP3P (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags)
3 つの 3D-2D 点の対応関係から，物体の姿勢を求めます．[【詳解】（英語］
CV_EXPORTS_W 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点をカメラ座標フレームに変換する移動と回転）を絞り込む。[【詳解】（英語］
CV_EXPORTS_W 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点をカメラ座標フレームに変換する移動と回転）を絞り込む。[【詳解】（英語］
CV_EXPORTS_W 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点の対応関係から物体のポーズを見つけます．この関数は，入力点の数と選択された手法に応じて，可能性のあるすべての解のリストを返します（解とは，<回転ベクトル，並進ベクトル>のカップルです）．[【詳解】（英語］
CV_EXPORTS_W Mat cv::initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0)
3D-2D の点の対応関係から初期のカメラ固有マトリックスを求めます．[【詳解】（英語］
CV_EXPORTS_W bool cv::findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
チェスボードの内側の角の位置を求めます。[【詳解】（英語］
CV_EXPORTS_W bool cv::checkChessboard (InputArray img, Size size)
bool cv::findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags, OutputArray meta)
セクターベースのアプローチを用いて、チェスボードの内側の角の位置を見つけます。[【詳解】（英語］
CV_EXPORTS_W bool cv::findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags=0)
CV_EXPORTS_W Scalar cv::estimateChessboardSharpness (InputArray image, Size patternSize, InputArray corners, float rise_distance=0.8F, bool vertical=false, OutputArray sharpness=noArray())
検出されたチェスボードのシャープネスを推定します。[【詳解】（英語］
CV_EXPORTS_W bool cv::find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size)
チェスボードのコーナーのサブピクセル精度の位置を求めます．
CV_EXPORTS_W void cv::drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
検出されたチェスボードのコーナーをレンダリングします．[【詳解】（英語］
CV_EXPORTS_W void cv::drawFrameAxes (InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3)
ポーズ推定によるワールド/オブジェクト座標系の軸を描画します．[【詳解】（英語］
CV_EXPORTS_W bool cv::findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters &parameters)
グリッド上の円の中心を検出します。[【詳解】（英語］
CV_EXPORTS_W bool cv::findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=SimpleBlobDetector::create())
cv::CV_EXPORTS_AS (calibrateCameraExtended) double calibrateCamera(InputArrayOfArrays objectPoints
キャリブレーションパターンの複数のビューから，カメラの内部および外部のパラメータを求めます．[【詳解】（英語］
CV_EXPORTS_W 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))
cv::CV_EXPORTS_AS (calibrateCameraROExtended) double calibrateCameraRO(InputArrayOfArrays objectPoints
キャリブレーションパターンの複数のビューから，カメラの内部および外部のパラメータを求めます．[【詳解】（英語］
CV_EXPORTS_W 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))
CV_EXPORTS_W void cv::calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, CV_OUT double &fovx, CV_OUT double &fovy, CV_OUT double &focalLength, CV_OUT Point2d &principalPoint, CV_OUT double &aspectRatio)
カメラ固有の行列から有用なカメラ特性を計算します。[【詳解】（英語］
cv::CV_EXPORTS_AS (stereoCalibrateExtended) double stereoCalibrate(InputArrayOfArrays objectPoints
ステレオカメラセットを校正します。この関数は、2 台のカメラそれぞれの固有パラメータと、2 台のカメラ間の外部パラメータを求めます。[【詳解】（英語］
CV_EXPORTS_W 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))
これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。
CV_EXPORTS_W 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(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0)
キャリブレーションされたステレオカメラの各ヘッドに対して，平行化変換を計算します．[【詳解】（英語］
CV_EXPORTS_W bool cv::stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
キャリブレーションされていないステレオカメラに対して，平行化変換を計算します．[【詳解】（英語］
CV_EXPORTS_W 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, CV_OUT Rect *roi1, CV_OUT Rect *roi2, int flags)
すべてのヘッドが同一線上にある3ヘッドカメラに対する平行化変換を計算します．
CV_EXPORTS_W Mat cv::getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0, bool centerPrincipalPoint=false)
フリースケーリングパラメータに基づく，新しいカメラ固有の行列を返します．[【詳解】（英語］
CV_EXPORTS_W 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$ [【詳解】（英語］
CV_EXPORTS_W 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)
Robot-World/Hand-Eyeキャリブレーションを計算します。$_{}^{w}\textrm{T}_b$および$_{}^{c}\textrm{T}_g$ [【詳解】（英語］
CV_EXPORTS_W void cv::convertPointsToHomogeneous (InputArray src, OutputArray dst)
点をユークリッド空間から同次座標に変換します。[【詳解】（英語］
CV_EXPORTS_W void cv::convertPointsFromHomogeneous (InputArray src, OutputArray dst)
点を同次空間からユークリッド空間に変換します。[【詳解】（英語］
CV_EXPORTS void cv::convertPointsHomogeneous (InputArray src, OutputArray dst)
点を同次座標に，あるいは同次座標から変換します．[【詳解】（英語］
CV_EXPORTS_W Mat cv::findFundamentalMat (InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
2つの画像の対応する点から，基本行列を求めます．[【詳解】（英語］
CV_EXPORTS_W Mat cv::findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99, OutputArray mask=noArray())
CV_EXPORTS Mat cv::findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99)
CV_EXPORTS_W Mat cv::findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, const UsacParams &params)
CV_EXPORTS_W Mat cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
2つの画像中の対応する点から，本質的な行列を求めます．[【詳解】（英語］
CV_EXPORTS Mat cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method, double prob, double threshold, OutputArray mask)
CV_EXPORTS_W 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())
CV_EXPORTS Mat cv::findEssentialMat (InputArray points1, InputArray points2, double focal, Point2d pp, int method, double prob, double threshold, OutputArray mask)
CV_EXPORTS_W Mat cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, int method=RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray())
2台の異なるカメラで撮影された2つの画像の対応点から，本質的な行列を求めます．[【詳解】（英語］
CV_EXPORTS_W Mat cv::findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray cameraMatrix2, InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask, const UsacParams &params)
CV_EXPORTS_W void cv::decomposeEssentialMat (InputArray E, OutputArray R1, OutputArray R2, OutputArray t)
必須行列を，可能な回転と平行移動に分解します．[【詳解】（英語］
CV_EXPORTS_W int cv::recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray())
推定された本質的な行列と2つの画像中の対応する点から，カメラの相対的な回転と並進をcheirality checkを用いて復元します．チェックに合格したインライアの数を返します。[【詳解】（英語］
CV_EXPORTS_W 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())
CV_EXPORTS_W int cv::recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, double distanceThresh, InputOutputArray mask=noArray(), OutputArray triangulatedPoints=noArray())
CV_EXPORTS_W void cv::computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines)
ステレオペアの画像中の点に対して，もう片方の画像中の対応するエピラインを計算します．[【詳解】（英語］
CV_EXPORTS_W void cv::triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D)
この関数は，ステレオカメラによる観測結果を用いて，3 次元の点（同次座標）を再構成します．[【詳解】（英語］
CV_EXPORTS_W void cv::correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
対応する点の座標をリファインします。[【詳解】（英語］
CV_EXPORTS_W void cv::filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
視差マップに含まれる小さなノイズの塊（スペックル）をフィルターで除去する[【詳解】（英語］
CV_EXPORTS_W Rect cv::getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
整形された画像の有効なROIから，有効な視差ROIを計算します（以下のコマンドで返されます）．stereoRectify)
CV_EXPORTS_W void cv::validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
は，左右のチェックを用いて視差を検証します．行列の「コスト」は，ステレオ対応点探索アルゴリズムによって計算されるべきです．
CV_EXPORTS_W void cv::reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
視差画像を3次元空間に再投影します．[【詳解】（英語］
CV_EXPORTS_W double cv::sampsonDistance (InputArray pt1, InputArray pt2, InputArray F)
2点間のSampson距離を計算します．[【詳解】（英語］
CV_EXPORTS_W int cv::estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
2つの3Dポイントセット間の最適なアフィン変換を計算します。[【詳解】（英語］
CV_EXPORTS_W cv::Mat cv::estimateAffine3D (InputArray src, InputArray dst, CV_OUT double *scale=nullptr, bool force_rotation=true)
2つの3Dポイントセット間の最適なアフィン変換を計算します。[【詳解】（英語］
CV_EXPORTS_W int cv::estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
2つの3Dポイントセット間の最適な平行移動を計算する。[【詳解】（英語］
CV_EXPORTS_W cv::Mat cv::estimateAffine2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
2つの2Dポイントセット間の最適なアフィン変換を計算します。[【詳解】（英語］
CV_EXPORTS_W cv::Mat cv::estimateAffine2D (InputArray pts1, InputArray pts2, OutputArray inliers, const UsacParams &params)
CV_EXPORTS_W cv::Mat cv::estimateAffinePartial2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
2つの2次元点集合の間で，4つの自由度を持つ最適な限定アフィン変換を計算します．[【詳解】（英語］
CV_EXPORTS_W int cv::decomposeHomographyMat (InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
ホモグラフィ行列を回転（複数），平行移動（複数），平面法線（複数）に分解します．[【詳解】（英語］
CV_EXPORTS_W void cv::filterHomographyDecompByVisibleRefpoints (InputArrayOfArrays rotations, InputArrayOfArrays normals, InputArray beforePoints, InputArray afterPoints, OutputArray possibleSolutions, InputArray pointsMask=noArray())
追加情報に基づいて，ホモグラフィー分解をフィルタリングします．[【詳解】（英語］
CV_EXPORTS_W void cv::undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
レンズの歪みを補正するために，画像を変換します．[【詳解】（英語］
CV_EXPORTS_W void cv::initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
歪み補正・平行化変換マップを求めます．[【詳解】（英語］
CV_EXPORTS_W void cv::initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)
投影および逆補正の変換マップを計算します．要するに，これはinitUndistortRectifyMapの逆数であり，プロジェクタとカメラのペアにおけるプロジェクタ（「逆カメラ」）のステレオ補正に対応しています．[【詳解】（英語］
CV_EXPORTS 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)
CV_EXPORTS_W Mat cv::getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
デフォルトの新しいカメラ行列を返します．[【詳解】（英語］
CV_EXPORTS_W void cv::undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
観測された点の座標から，理想的な点の座標を計算します．[【詳解】（英語］
void cv::undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray P, TermCriteria criteria)

変数
InputArrayOfArrays cv::imagePoints
InputArrayOfArrays Size cv::imageSize
InputArrayOfArrays Size InputOutputArray cv::cameraMatrix
InputArrayOfArrays Size InputOutputArray InputOutputArray cv::distCoeffs
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays cv::rvecs
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays cv::tvecs
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray cv::stdDeviationsIntrinsics
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray cv::stdDeviationsExtrinsics
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray cv::perViewErrors
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray int cv::flags = 0
InputArrayOfArrays Size InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray int TermCriteria cv::criteria
InputArrayOfArrays Size int cv::iFixedPoint
InputArrayOfArrays Size int InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray cv::newObjPoints
InputArrayOfArrays Size int InputOutputArray InputOutputArray OutputArrayOfArrays OutputArrayOfArrays OutputArray OutputArray OutputArray OutputArray cv::stdDeviationsObjPoints
InputArrayOfArrays cv::imagePoints1
InputArrayOfArrays InputArrayOfArrays cv::imagePoints2
InputArrayOfArrays InputArrayOfArrays InputOutputArray cv::cameraMatrix1
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray cv::distCoeffs1
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray cv::cameraMatrix2
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray cv::distCoeffs2
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray cv::R
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray cv::T
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray OutputArray cv::E
InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray OutputArray OutputArray cv::F

詳解

The functions in this section use a so-called pinhole camera model. The view of a scene is obtained by projecting a scene's 3D point $P_w$ into the image plane using a perspective transformation which forms the corresponding pixel $p$. Both $P_w$ and $p$ are represented in homogeneous coordinates, i.e. as 3D and 2D homogeneous vector respectively. You will find a brief introduction to projective geometry, homogeneous vectors and homogeneous transformations at the end of this section's introduction. For more succinct notation, we often drop the 'homogeneous' and say vector instead of homogeneous vector.

The distortion-free projective transformation given by a pinhole camera model is shown below.

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

where $P_w$ is a 3D point expressed with respect to the world coordinate system, $p$ is a 2D pixel in the image plane, $A$ is the camera intrinsic matrix, $R$ and $t$ are the rotation and translation that describe the change of coordinates from world to camera coordinate systems (or camera frame) and $s$ is the projective transformation's arbitrary scaling and not part of the camera model.

The camera intrinsic matrix $A$ (notation used as in [Zhang2000] and also generally notated as $K$) projects 3D points given in the camera coordinate system to 2D pixel coordinates, i.e.

\[p = A P_c.\]

The camera intrinsic matrix $A$ is composed of the focal lengths $f_x$ and $f_y$, which are expressed in pixel units, and the principal point $(c_x, c_y)$, that is usually close to the image center:

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

and thus

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

The matrix of intrinsic parameters does not depend on the scene viewed. So, once estimated, it can be re-used as long as the focal length is fixed (in case of a zoom lens). Thus, if an image from the camera is scaled by a factor, all of these parameters need to be scaled (multiplied/divided, respectively) by the same factor.

The joint rotation-translation matrix $[R|t]$ is the matrix product of a projective transformation and a homogeneous transformation. The 3-by-4 projective transformation maps 3D points represented in camera coordinates to 2D points in the image plane and represented in normalized camera coordinates $x' = X_c / Z_c$ and $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}.\]

The homogeneous transformation is encoded by the extrinsic parameters $R$ and $t$ and represents the change of basis from world coordinate system $w$ to the camera coordinate sytem $c$. Thus, given the representation of the point $P$ in world coordinates, $P_w$, we obtain $P$'s representation in the camera coordinate system, $P_c$, by

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

This homogeneous transformation is composed out of $R$, a 3-by-3 rotation matrix, and $t$, a 3-by-1 translation vector:

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

and therefore

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

Combining the projective transformation and the homogeneous transformation, we obtain the projective transformation that maps 3D points in world coordinates into 2D points in the image plane and in normalized camera coordinates:

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

with $x' = X_c / Z_c$ and $y' = Y_c / Z_c$. Putting the equations for instrincs and extrinsics together, we can write out $s \; p = A \begin{bmatrix} R|t \end{bmatrix} P_w$ as

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

If $Z_c \ne 0$, the transformation above is equivalent to the following,

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

with

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

The following figure illustrates the pinhole camera model.

Pinhole camera model

Real lenses usually have some distortion, mostly radial distortion, and slight tangential distortion. So, the above model is extended as:

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

where

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

with

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

and

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

if $Z_c \ne 0$.

The distortion parameters are the radial coefficients $k_1$, $k_2$, $k_3$, $k_4$, $k_5$, and $k_6$ , $p_1$ and $p_2$ are the tangential distortion coefficients, and $s_1$, $s_2$, $s_3$, and $s_4$, are the thin prism distortion coefficients. Higher-order coefficients are not considered in OpenCV.

The next figures show two common types of radial distortion: barrel distortion ( $ 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 $ monotonically decreasing) and pincushion distortion ( $ 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 $ monotonically increasing). Radial distortion is always monotonic for real lenses, and if the estimator produces a non-monotonic result, this should be considered a calibration failure. More generally, radial distortion must be monotonic and the distortion function must be bijective. A failed estimation result may look deceptively good near the image center but will work poorly in e.g. AR/SFM applications. The optimization method used in OpenCV camera calibration does not include these constraints as the framework does not support the required integer programming and polynomial inequalities. See issue #15992 for additional information.

In some cases, the image sensor may be tilted in order to focus an oblique plane in front of the camera (Scheimpflug principle). This can be useful for particle image velocimetry (PIV) or triangulation with a laser fan. The tilt causes a perspective distortion of $x''$ and $y''$. This distortion can be modeled in the following way, see e.g. [Louhichi07].

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

where

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

and the matrix $R(\tau_x, \tau_y)$ is defined by two rotations with angular parameter $\tau_x$ and $\tau_y$, respectively,

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

In the functions below the coefficients are passed or returned as

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

vector. That is, if the vector contains four elements, it means that $k_3=0$ . The distortion coefficients do not depend on the scene viewed. Thus, they also belong to the intrinsic camera parameters. And they remain the same regardless of the captured image resolution. If, for example, a camera has been calibrated on images of 320 x 240 resolution, absolutely the same distortion coefficients can be used for 640 x 480 images from the same camera while $f_x$, $f_y$, $c_x$, and $c_y$ need to be scaled appropriately.

The functions below use the above model to do the following:

Homogeneous Coordinates
Homogeneous Coordinates are a system of coordinates that are used in projective geometry. Their use allows to represent points at infinity by finite coordinates and simplifies formulas when compared to the cartesian counterparts, e.g. they have the advantage that affine transformations can be expressed as linear homogeneous transformation.

One obtains the homogeneous vector $P_h$ by appending a 1 along an n-dimensional cartesian vector $P$ e.g. for a 3D cartesian vector the mapping $P \rightarrow P_h$ is:

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

For the inverse mapping $P_h \rightarrow P$, one divides all elements of the homogeneous vector by its last element, e.g. for a 3D homogeneous vector one gets its 2D cartesian counterpart by:

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

if $W \ne 0$.

Due to this mapping, all multiples $k P_h$, for $k \ne 0$, of a homogeneous point represent the same point $P_h$. An intuitive understanding of this property is that under a projective transformation, all multiples of $P_h$ are mapped to the same point. This is the physical observation one does for pinhole cameras, as all points along a ray through the camera's pinhole are projected to the same image point, e.g. all points along the red ray in the image of the pinhole camera model above would be mapped to the same image coordinate. This property is also the source for the scale ambiguity s in the equation of the pinhole camera model.

As mentioned, by using homogeneous coordinates we can express any change of basis parameterized by $R$ and $t$ as a linear transformation, e.g. for the change of basis from coordinate system 0 to coordinate system 1 becomes:

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

覚え書き
  • Many functions in this module take a camera intrinsic matrix as an input parameter. Although all functions assume the same structure of this parameter, they may name it differently. The parameter's description, however, will be clear in that a camera intrinsic matrix with the structure shown above is required.
  • A calibration sample for 3 cameras in a horizontal position can be found at opencv_source_code/samples/cpp/3calibration.cpp
  • A calibration sample based on a sequence of images can be found at opencv_source_code/samples/cpp/calibration.cpp
  • A calibration sample in order to do 3D reconstruction can be found at opencv_source_code/samples/cpp/build3dmodel.cpp
  • A calibration example on stereo calibration can be found at opencv_source_code/samples/cpp/stereo_calib.cpp
  • A calibration example on stereo matching can be found at opencv_source_code/samples/cpp/stereo_match.cpp
  • (Python) A camera calibration sample can be found at opencv_source_code/samples/python/calibrate.py

列挙型詳解

◆ anonymous enum

anonymous enum

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

列挙値
LMEDS

最小公倍数法アルゴリズム
RANSAC

RANSACアルゴリズム
RHO

RHOアルゴリズム
USAC_DEFAULT

USACアルゴリズム、デフォルト設定
USAC_PARALLEL

USAC、パラレルバージョン
USAC_FM_8PTS

USAC、基本マトリックス8点
USAC_FAST

USAC、高速設定
USAC_ACCURATE

USAC、正確な設定
USAC_PROSAC

USAC、ソートされたポイント、PROSACの実行
USAC_MAGSAC

USAC、MAGSAC++の実行

◆ anonymous enum

anonymous enum
列挙値
CALIB_USE_QR

解答に分解ではなくQRを使用します。SVD解くために分解の代わりにQRを使用します。高速ですが、精度が落ちる可能性があります。
CALIB_USE_LU

分解の代わりにLUを使います。SVD解くのに分解の代わりにLUを使います。
calib_use_extrinsic_guess

stereoCalibrate用

◆ anonymous enum

anonymous enum

基本行列を見つけるためのアルゴリズム

列挙値
FM_7POINT

7ポイントアルゴリズム
FM_8POINT

8-point アルゴリズム
FM_LMEDS

最小公倍数アルゴリズム 7-point アルゴリズムを使用します。
FM_RANSAC

RANSACアルゴリズム。最低でも15点が必要です。7ポイントのアルゴリズムを使用。

◆ HandEyeCalibrationMethod

enum cv::HandEyeCalibrationMethod
列挙値
calib_手と目のキャリブレーション

完全に自律的で効率的な3次元ロボットの手と目のキャリブレーションのための新しい手法[Tsai89]を参照してください。

calib_hand_eye_park

ロボットのセンサーキャリブレーション。ユークリッド群上でAX=XBを解く[Park94]を参照してください。

カリブ_手のひら_目_ホロー

手と目のキャリブレーション[Horaud95]を参照してください。

calib_hand_eye_andreff

オンラインでの手のひらサイズの目のキャリブレーション[Andreff99］

calib_hand_eye_daniilidis

デュアルクォータニオンを用いた手のひらの目のキャリブレーション[Daniilidis98]を参照してください。

◆ RobotWorldHandEyeCalibrationMethod

enum cv::RobotWorldHandEyeCalibrationMethod
列挙値
カリブ_ロボット世界_手の目_シャア

クロネッカー積を用いたロボット世界／手の目のキャリブレーション問題の解決[Shah2013SolvingTR]を参照してください。

カリブ_ロボットワールド_ハンド_アイ_リー

二重四元数とクロネッカー積を用いたロボット世界と手の目の同時較正[Li2010SimultaneousRA].

◆ SolvePnPMethod

enum cv::SolvePnPMethod
列挙値
SOLVEPNP_EPNP

EPnP: Efficient Perspective-n-Point Camera Pose Estimation[LEPPIT2009EPNP］

SOLVEPNP_P3P

パースペクティブ3点問題の完全解分類[gao2003complete]を参照してください。

SOLVEPNP_DLS

壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
PnPに対する直接最小二乗法(DLS)の提案[hesch2011direct]を参照してください。

SOLVEPNP_UPNP

壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
ロバストなカメラの姿勢と焦点距離推定のための網羅的線形化[penate2013exhaustive］

SOLVEPNP_AP3P

パースペクティブ・スリーポイント問題に対する効率的な代数的解法[Ke17].

SOLVEPNP_IPPE

無限小の平面に基づくポーズの推定[Collins14]を参照してください。
オブジェクトポイントはコプラナーである必要があります。
SOLVEPNP_IPPE_SQUARE

無限小の平面に基づくポーズの推定[Collins14]を参照してください。
これは、マーカーのポーズ推定に適した特殊なケースです。
4つのコプラナなオブジェクトポイントを以下の順番で定義する必要がある。

  • 点0: [-squareLength / 2, squareLength / 2, 0]。
  • point 1: [ squareLength / 2, squareLength / 2, 0]である。
  • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
  • 点3：［-squareLength / 2, -squareLength / 2, 0］。
SOLVEPNP_SQPNP

SQPnP: A Consistently Fast and Globally OptimalSolution to the Perspective-n-Point Problem (SQPnP: A Consistently Fast and Globally OptimalSolution to the Perspective-n-Point Problem)[Tarzakis20]を参照してください。

SOLVEPNP_MAX_COUNT

カウントに使用

関数詳解

◆ calibrateCamera()

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ calibrateCameraRO()

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ calibrateHandEye()

CV_EXPORTS_W 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$

引数
[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 実装されているHand-Eyeキャリブレーション手法の1つ．cv::HandEyeCalibrationMethod

この関数は，さまざまな手法を用いて手のひらサイズの目のキャリブレーションを行います．1つの手法は，回転と並進を同時に推定するもので（分離可能解），以下の手法が実装されています．

  • R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration[Tsai89]を参照してください。
  • F. Park, B. Martin Robot Sensor Calibration: ユークリッド群上でのAX = XBの解法[Park94]を参照してください。
  • R. Horaud, F. Dornaika 手と目のキャリブレーション[Horaud95]を参照してください。

もう一つの方法は、回転と平行移動を同時に推定する方法（同時解法）で、以下のような実装方法があります。

  • N. N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration[Andreff99］
  • K. Daniilidis Hand-Eye Calibration Using Dual Quaternions[Daniilidis98]を参照してください。

次の図は、ロボット・グリッパー（「ハンド」）に取り付けられたカメラ（「アイ」）の間の変換を推定しなければならないという、ハンドアイのキャリブレーション問題を説明しています。この構成はeye-in-handと呼ばれています。

Eye-to-Handは、ロボットのエンドエフェクタに取り付けられた校正パターンを観察する静的なカメラで構成されています。カメラからロボットのベースフレームへの変換は、後述の関数に適切な変換を入力することで推定できます。

キャリブレーションの手順は以下の通りです。

  • ターゲットフレームとカメラフレームの間の変換を推定するために、静的なキャリブレーションパターンを使用する
  • ロボットのグリッパーを動かして，複数のポーズを取得する
  • 各ポーズについて、グリッパー・フレームとロボット・ベース・フレームの間の同次変換を、例えばロボット・キネマティクスを用いて記録する。

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

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

Robot-World/Hand-Eyeキャリブレーションを計算します。$_{}^{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 実装されている Robot-World/Hand-Eye キャリブレーション手法の1つ．cv::RobotWorldHandEyeCalibrationMethod

この関数は，さまざまな方法で Robot-World/Hand-Eye のキャリブレーションを行います．1つの手法は，回転と並進を同時に推定するものです（分離可能解）．

  • M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product[Shah2013SolvingTR]を参照してください。

もう一つの方法は、回転と並進を同時に推定する方法（同時解法）で、以下のような方法が実装されています。

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

次の図は、ロボットとワールドフレームの間の変換、およびロボットのグリッパー（"手"）とロボットのエンドエフェクタに取り付けられたカメラ（"目"）の間の変換を推定しなければならない、ロボット-ワールド/ハンドアイキャリブレーション問題を説明しています。

キャリブレーションの手順は以下の通りです。

  • ターゲットフレームとカメラフレームの間の変換を推定するために、静的なキャリブレーションパターンを使用する
  • ロボットのグリッパーを動かして，複数のポーズを取得する
  • 各ポーズについて、グリッパー・フレームとロボット・ベース・フレームの間の同次変換を、例えばロボット・キネマティクスを用いて記録する。

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

Robot-World/Hand-Eyeキャリブレーション手順では、以下の同次変換が返されます。

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

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

カメラ固有の行列から有用なカメラ特性を計算します。

引数
cameraMatrix 以下の方法で推定される入力カメラ固有の行列。calibrateCameraまたはstereoCalibrate.
imageSize 入力画像サイズ（ピクセル）。
apertureWidth センサーの物理的な幅（mm）。
apertureHeight センサーの物理的な高さ（単位：mm
fovx 水平方向のセンサー軸に沿った出力視野角（度
fovy 垂直方向のセンサー軸に沿った角度での出力視野。
focalLength レンズの焦点距離（mm）。
principalPoint 主点（単位：mm
aspectRatio $f_y/f_x$

この関数は，あらかじめ推定されたカメラ行列から，様々な有用なカメラ特性を算出します．

覚え書き
なお，統一された尺度である「mm」は，チェスボードのピッチを表す任意の単位を表しています（つまり，任意の値になります）．

◆ composeRT()

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

2つの回転とシフトの変換を組み合わせます。

引数
rvec1 最初の回転ベクトル。
tvec1 第1の並進ベクトル。
rvec2 2つ目の回転ベクトル。
tvec2 第2の並進ベクトル
rvec3 重ね合わせの出力回転ベクトル。
tvec3 重ね合わせた部分の並進ベクトルを出力
dr3dr1 rvec1に対するrvec3の任意出力微分
dr3dt1 tvec1 に対する rvec3 の出力導関数（オプション）．
dr3dr2 rvec2 に対する rvec3 の出力導関数（オプション）．
dr3dt2 tvec2に関するrvec3の出力導関数（オプション
dt3dr1 rvec1に関するtvec3の出力導関数（オプション
dt3dt1 tvec1に関するtvec3の出力導関数（オプション
dt3dr2 rvec2に関するtvec3の出力導関数（オプション
dt3dt2 tvec2に対するtvec3の出力微分（オプション

関数 compute:

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

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

ステレオペアの画像中の点に対して，もう片方の画像中の対応するエピラインを計算します．

引数
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)$.

この関数は，ステレオペアの2つの画像のうち，一方の画像内の各点に対して，もう一方の画像内の対応するエピポーラ線の方程式を求めます．

基本的な行列の定義から（参照findFundamentalMatを参照），線$l^{(2)}_i$は，1枚目の画像の点$p^{(1)}_i$は，基本的な行列の定義（参照）から，1枚目の画像の点

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

また，その逆に，whichImage=2 の場合は$l^{(1)}_i$から計算されます。$p^{(2)}_i$となります。

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

ライン係数は，あるスケールまで定義されます。それらは以下のように正規化されます。$a_i^2+b_i^2=1$.

◆ convertPointsFromHomogeneous()

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

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

引数
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()

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

点を同次座標に，あるいは同次座標から変換します．

引数
src 2次元，3次元，または4次元の点の配列またはベクトルを入力します．
dst 2次元，3次元，または4次元の点の出力ベクトル．

この関数は，2次元または3次元の点を，同次座標との間で変換します．convertPointsToHomogeneousまたはconvertPointsFromHomogeneous.

覚え書き
この関数は廃止されました。代わりに，前の2つの関数のいずれかを使用してください。

◆ convertPointsToHomogeneous()

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

点をユークリッド空間から同次座標に変換します。

引数
src N次元点の入力ベクトル。
dst N+1次元の点のベクトルを出力します。

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

◆ correctMatches()

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

対応する点の座標をリファインします。

引数
F 3x3 基本行列。
points1 1 番目の点のセットを含む 1xN の配列。
points2 2 番目の点のセットを含む 1xN 配列。
newPoints1 最適化された点1。
newPoints2 最適化された点2．

この関数は，最適化三角測量法を実装しています（詳細は，「多視点幾何学」を参照してください）．与えられた各点の対応点 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 * F * newPoints1 = 0$.

◆ CV_EXPORTS_AS() [1/3]

cv::CV_EXPORTS_AS ( calibrateCameraExtended )

キャリブレーションパターンの複数のビューから，カメラの内部および外部のパラメータを求めます．

引数
objectPoints 新しいインターフェースでは，キャリブレーションパターン座標空間におけるキャリブレーションパターンポイントのベクトル（std::vector<std::vector<cv::Vec3f>など）のベクトルとなります．外側のベクトルには、パターンビューの数だけの要素が含まれる。各ビューに同じキャリブレーションパターンが表示され、それが完全に見える場合、すべてのベクターは同じになります。しかし、部分的にオックルされたパターンや、異なるビューに異なるパターンを使用することも可能です。そうすると、ベクターは異なります。ポイントは3Dですが、使用するキャリブレーションパターンが平面リグの場合、ポイントはすべてキャリブレーションパターンのXY座標平面上に位置します（つまりZ座標は0）。従来のインターフェースでは、異なるビューからのオブジェクトポイントのすべてのベクトルが連結されていました。
imagePoints 新しいインターフェースでは，キャリブレーションパターンポイントの投影のベクトル（std::vector<std::vector<cv::Vec2f>>など）のベクトルです． imagePoints.size() と objectPoints.size() ，および各 i に対する imagePoints[i].size() と objectPoints[i].size() は，それぞれ等しくなければいけません．古いインターフェースでは，異なるビューからのオブジェクトポイントのすべてのベクトルが連結されます．
imageSize 画像のサイズは，カメラ固有の行列を初期化するためにのみ利用されます．
cameraMatrix 入出力 3x3 浮動小数点型カメラ固有マトリクス$\cameramatrix{A}$. CALIB_USE_INTRINSIC_GUESS および/または CALIB_FIX_ASPECT_RATIO, CALIB_FIX_PRINCIPAL_POINT または CALIB_FIX_FOCAL_LENGTH が指定された場合，関数を呼び出す前に fx, fy, cx, cy の一部または全部を初期化する必要があります。
distCoeffs 歪曲係数の入出力ベクトル$\distcoeffs$.
rvecs 回転ベクトルの出力ベクトル(Rodrigues) を，各パターンビューに対して推定します（例えば，std::vector<cv::Mat>>）．つまり，各 i 番目の回転ベクトルは，対応する i 番目の並進ベクトル（次の出力パラメータの説明を参照）と共に，キャリブレーションパターンを（オブジェクトポイントが指定されている）オブジェクト座標空間からカメラ座標空間へと導きます．より専門的に言えば，i番目の回転ベクトルと並進ベクトルのタプルは，物体座標空間からカメラ座標空間への基底の変更を行うものである．このタプルは、その双対性により、カメラ座標空間に対するキャリブレーションパターンの位置に相当します。
tvecs パターンビューごとに推定された並進ベクトルの出力ベクトル（上記パラメータの説明を参照）。
stdDeviationsIntrinsics 固有パラメータについて推定された標準偏差の出力ベクトル．偏差値の順序。$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)$パラメータの1つが推定されない場合、その偏差はゼロとなる。
stdDeviationsExtrinsics 外部パラメータのために推定された標準偏差の出力ベクトル。偏差値の順序。$(R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})$ここで，M はパターンビューの数である．$R_i, T_i$は、連結された 1x3 ベクトルである。
perViewErrors 各パターンビューに対して推定されたRMS再投影エラーの出力ベクトル。
flags 0または以下の値の組み合わせとなる異なるフラグ。
  • CALIB_USE_INTRINSIC_GUESS cameraMatrix が，さらに最適化された有効な初期値 fx, fy, cx, cy を含んでいる場合．それ以外の場合は，(cx, cy) が画像の中心に初期設定され（imageSize が使用される），最小二乗法で焦点距離が計算されます．なお，内部パラメータが既知であれば，外部パラメータを推定するためだけにこの関数を利用する必要はありません．使用方法solvePnP代わりに
  • CALIB_FIX_PRINCIPAL_POINT 主点はグローバル最適化の間、変更されません。中心に留まるか、CALIB_USE_INTRINSIC_GUESSで指定された別の場所に留まります。
  • CALIB_FIX_ASPECT_RATIO この関数は自由パラメータとして fy のみを考慮します。比 fx/fy は，入力 cameraMatrix と同じになります．CALIB_USE_INTRINSIC_GUESS が設定されていない場合，fx とfy の実際の入力値は無視され，それらの比のみが計算され，さらに利用されます．
  • CALIB_ZERO_TANGENT_DIST 接線方向の歪み係数$(p_1, p_2)$はゼロに設定され、ゼロのままです。
  • 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再投影誤差．

この関数は，カメラの内部パラメータと，各ビューの外部パラメータを推定します．このアルゴリズムは，以下に基づいています[Zhang2000] 。および[BouguetMCT] を利用しています．. 各ビューにおける，3次元物体の点の座標と，それに対応する2次元投影を指定する必要があります．そのためには，形状が既知であり，特徴点を容易に検出できる物体を使用する必要があります．このようなオブジェクトは，キャリブレーションリグまたはキャリブレーションパターンと呼ばれ，OpenCV はキャリブレーションリグとしてチェスボードをビルトインでサポートしています（以下を参照してください）．findChessboardCorners). 現在のところ，内部パラメータの初期化（CALIB_USE_INTRINSIC_GUESS がセットされていない場合）は，平面的なキャリブレーションパターン（オブジェクトの点のZ座標がすべて0でなければならない）に対してのみ実装されています．初期のcameraMatrixが提供されている限り、3Dキャリブレーションリグも使用できます。

このアルゴリズムは、以下のステップを実行します。

  • 初期固有パラメータを計算する（平面キャリブレーションパターンでのみ利用可能なオプション）、または入力パラメータから読み取る。CALIB_FIX_K? の一部が指定されない限り，歪み係数はすべて初期状態でゼロに設定されます．
  • 固有のパラメータがすでに知られているかのように、初期のカメラポーズを推定する。これは以下の方法で行います。solvePnP.
  • グローバルLevenberg-Marquardt最適化アルゴリズムを実行し，再投影誤差，つまり，観測された特徴点 imagePoints と，（カメラ・パラメータとポーズの現在の推定値を用いて）投影されたオブジェクト点 objectPoints との間の二乗距離の総和を最小化します．参照projectPointsを参照してください。
覚え書き
正方形ではない（つまりN×Nではない）グリッドを使いfindChessboardCornersを用いてキャリブレーションを行った場合でcalibrateCameraは，悪い値（歪み係数がゼロ。$c_x$および$c_y$画像の中心から非常に離れていたり、画像間の差が大きかったりする場合$f_x$および$f_y$(の比が 10:1 以上）），おそらく patternSize=cvSize(rows,cols) を使用する代わりにfindChessboardCorners.
参照
calibrateCameraRO,findChessboardCorners,solvePnP,initCameraMatrix2D,stereoCalibrate,undistort

◆ CV_EXPORTS_AS() [2/3]

cv::CV_EXPORTS_AS ( calibrateCameraROExtended )

キャリブレーションパターンの複数のビューから，カメラの内部および外部のパラメータを求めます．

この関数は、以下を拡張したものです。calibrateCameraで提案されたオブジェクトを解放する方法で[strobl2011iccv]で提案された. この方法は，不正確で測定されていない，ほぼ平面のターゲット（キャリブレーションプレート）を用いる多くの一般的なケースにおいて，推定されるカメラパラメータの精度を劇的に向上させることができます．この関数は，物体放出法と標準法の両方をサポートしています．パラメータはiFixedPointを使用して，手法を選択します．内部実装ではcalibrateCameraは，この関数のラッパーである。

引数
objectPoints キャリブレーションパターンの座標空間におけるキャリブレーションパターンの点のベクトル。詳細はcalibrateCameraを参照してください。オブジェクトを解放する方法を利用する場合，各ビューで同一のキャリブレーションボードを使用し，それが完全に見える必要があります．また，すべての objectPoints[i] は同一でなければならず，すべてのポイントは平面にほぼ近いものでなければなりません．キャリブレーションターゲットは剛体でなければならず、また、画像をつかむために（キャリブレーションターゲットではなく）カメラを移動させる場合は、少なくとも静止していなければなりません。
imagePoints キャリブレーションパターンの点を投影したベクトルのベクトル。参照calibrateCameraを参照してください。
imageSize 固有のカメラ行列を初期化するためだけに使われる画像のサイズ．
iFixedPoint 固定する objectPoints[0] の 3D オブジェクトポイントのインデックスです。また、キャリブレーション方法選択のスイッチとしても機能します。オブジェクト解放法を使用する場合は、[1, objectPoints[0].size()-2]の範囲でパラメータを渡し、それ以外の場合は、この範囲外の値を渡すと標準的なキャリブレーション法が選択されます。通常、オブジェクトリリース法を使用する場合は、キャリブレーションボードのグリッドの右上の点を固定することが推奨されます。によると[strobl2011iccv]で提案されたによると、他の2点も固定されています。本実施例では、objectPoints[0].front および objectPoints[0].back.z を使用する。オブジェクト解放法では、この3つの固定点の座標が十分に正確である場合にのみ、正確な rvecs、tvecs、newObjPoints が可能になります。
cameraMatrix 3x3浮動小数点カメラ行列を出力します．見るcalibrateCameraを参照してください。
distCoeffs 歪み係数のベクトルを出力します。参照calibrateCameraを参照してください。
rvecs 各パターンビューに対して推定された回転ベクトルを出力する。参照calibrateCameraを参照してください。
tvecs パターンビューごとに推定された並進ベクトルの出力ベクトル．
newObjPoints キャリブレーションパターンのポイントの更新された出力ベクトル。座標は、3つの固定点に基づいてスケーリングされることがあります。返される座標は、上記の3つの固定点が正確である場合にのみ正確である。必要ない場合は、noArray()を渡すことができる。このパラメータは、標準的なキャリブレーション方法では無視される。
stdDeviationsIntrinsics 固有パラメータの推定標準偏差の出力ベクトル。参照calibrateCameraを参照してください。
stdDeviationsExtrinsics 外部パラメータのために推定された標準偏差の出力ベクトル。参照calibrateCameraを参照してください。
stdDeviationsObjPoints キャリブレーションパターンのポイントの洗練された座標に対して推定された標準偏差の出力ベクトル。objectPoints[0]ベクトルと同じサイズとオーダーです。このパラメータは，標準的なキャリブレーション方法では無視されます．
perViewErrors 各パターンビューに対して推定されたRMS再投影エラーの出力ベクトル。
flags ゼロまたはいくつかの定義済みの値の組み合わせである可能性がある異なるフラグ。詳細はcalibrateCameraを参照してください。オブジェクトを解放する方法を使用した場合、キャリブレーション時間が大幅に長くなる可能性があります。CALIB_USE_QRまたはCALIB_USE_LUを使用することで、より迅速なキャリブレーションが可能になりますが、まれに精度や安定性が低下することがあります。
criteria 反復最適化アルゴリズムの終了基準．
戻り値
全体のRMS再投影誤差．

この関数は，カメラの内部パラメータと，各ビューの外部パラメータを推定します．このアルゴリズムは，以下に基づいています[Zhang2000] 。,[BouguetMCT] を利用しています．および[strobl2011iccv]で提案された. 参照calibrateCameraその他の詳しい説明はこちらをご覧ください。

参照
calibrateCamera,findChessboardCorners,solvePnP,initCameraMatrix2D,stereoCalibrate,undistort

◆ CV_EXPORTS_AS() [3/3]

cv::CV_EXPORTS_AS ( stereoCalibrateExtended )

ステレオカメラセットを校正します。この関数は、2 台のカメラそれぞれの固有パラメータと、2 台のカメラ間の外部パラメータを求めます。

引数
objectPoints キャリブレーションパターンポイントのベクトル。と同じ構造です。calibrateCamera. 各パターンビューでは，両方のカメラが同じオブジェクトポイントを見る必要があります．したがって，objectPoints.size(), imagePoints1.size(), imagePoints2.size() は等しくなければならないし，objectPoints[i].size(), imagePoints1[i].size(), imagePoints2[i].size() も各 i について等しくなければならない．
imagePoints1 1台目のカメラで観測されたキャリブレーションパターンの点を投影したベクトルのベクトル．と同じ構造です．calibrateCamera.
imagePoints2 2 台目のカメラで観測されたキャリブレーションパターン点の投影結果のベクトル．と同様の構造です。calibrateCamera.
cameraMatrix1 第1カメラの入出力カメラ固有マトリクス，と同じ．calibrateCamera. さらに，ステレオの場合には，追加のフラグを使用することができるが，以下を参照されたい．
distCoeffs1 入力／出力 歪み係数のベクトル．calibrateCamera.
cameraMatrix2 入力／出力 第2カメラの固有マトリクス．cameraMatrix1 の説明を参照してください。
distCoeffs2 入力／出力 2 番目のカメラのレンズ歪み係数．distCoeffs1 の説明を参照してください．
imageSize カメラ固有の行列を初期化するためにのみ使用される画像のサイズ．
R 出力回転行列．並進ベクトル T と共に，この行列は，1 台目のカメラの座標系で与えられた点を 2 台目のカメラの座標系で与えられた点に変換します．より専門的に言えば、RとTのタプルは、第1のカメラの座標系から第2のカメラの座標系への基底の変更を行うものである。このタプルは、その双対性により、第2のカメラ座標系に対する第1のカメラの位置に相当します。
T 並進ベクトルの出力（上の説明を参照
E 出力必須行列。
F 基本行列を出力します。
perViewErrors 各パターンビューに対して推定されたRMS再投影エラーの出力ベクトル。
flags 0または以下の値の組み合わせとなる異なるフラグ。
  • CALIB_FIX_INTRINSIC R, T, E, F の各行列のみが推定されるように cameraMatrix? と distCoeffs?
  • CALIB_USE_INTRINSIC_GUESS 指定されたフラグにしたがって、一部または全部の固有パラメータを最適化する。初期値はユーザが提供します。
  • CALIB_USE_EXTRINSIC_GUESSRとTは有効な初期値を含み、さらに最適化されます。それ以外の場合、RとTはパターンビューの中央値に初期化されます（各次元ごと）。
  • CALIB_FIX_PRINCIPAL_POINT 最適化の際の主点を固定します。
  • CALIB_FIX_FOCAL_LENGTH 固定$f^{(j)}_x$および$f^{(j)}_y$.
  • CALIB_FIX_ASPECT_RATIO 最適化します。$f^{(j)}_y$. 比率を固定する$f^{(j)}_x/f^{(j)}_y$
  • CALIB_SAME_FOCAL_LENGTH 施行$f^{(0)}_x=f^{(1)}_x$および$f^{(0)}_y=f^{(1)}_y$.
  • CALIB_ZERO_TANGENT_DIST 各カメラの接線方向の歪み係数をゼロに設定し、そこに固定します。
  • CALIB_FIX_K1,..., CALIB_FIX_K6 最適化の間，対応する半径方向の歪み係数を変更しません。CALIB_USE_INTRINSIC_GUESS が設定されている場合，与えられた distCoeffs 行列からの係数が使われます。それ以外の場合は，0に設定されます。
  • CALIB_RATIONAL_MODEL 係数 k4, k5, および k6 を有効にします。下位互換性を提供するために、キャリブレーション関数が有理モデルを使用し、8つの係数を返すようにするには、この追加フラグを明示的に指定する必要がある。このフラグが設定されていない場合、この関数は5つの歪み係数のみを計算して返します。
  • CALIB_THIN_PRISM_MODEL 係数s1、s2、s3、s4が有効になります。下位互換性を提供するために、キャリブレーション関数が薄いプリズム・モデルを使用し、12個の係数を返すようにするために、この追加フラグを明示的に指定する必要があります。このフラグが設定されていない場合、この関数は5つの歪み係数のみを計算して返します。
  • CALIB_FIX_S1_S2_S3_S4 薄いプリズムの歪み係数は最適化中には変更されません。CALIB_USE_INTRINSIC_GUESS が設定されている場合、与えられた distCoeffs 行列からの係数が使用されます。それ以外の場合は、0に設定されます。
  • CALIB_TILTED_MODEL 係数 tauX および tauY が有効になる。後方互換性を確保するために，キャリブレーション関数が傾いたセンサモデルを使用し，14個の係数を返すようにするには，この追加フラグを明示的に指定する必要がある．このフラグが設定されていない場合，この関数は5つの歪み係数のみを計算して返します．
  • CALIB_FIX_TAUX_TAUY 傾いたセンサモデルの係数は最適化中には変更されない。CALIB_USE_INTRINSIC_GUESS が設定されている場合は、与えられた distCoeffs 行列からの係数が使用されます。それ以外の場合は，0に設定されます．
criteria 反復最適化アルゴリズムの終了基準．

この関数は，ステレオペアを構成する2つのカメラ間の変換を推定します．第1のカメラと第2のカメラに対する物体の姿勢を計算すると，($R_1$,$T_1$) と ($R_2$,$T_2$) を計算すると，それらのポーズは確実に互いに関連している。つまり、2台のカメラの相対的な位置と向き($R$,$T$)がわかっていれば、2台のカメラの相対的な位置と向きがわかっている場合には、($R_2$,$T_2$)が与えられれば、($R_1$,$T_1$) が与えられれば、( ) を計算することができます。これが，この関数の役割です．この関数は，次のように($R$,$T$)を計算します．

\[R_2=R R_1\]

\[T_2=R T_1 + T.\]

したがって，第1のカメラの座標系における点の座標表現が与えられた場合，第2のカメラの座標系における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}\]

この関数は，ステレオ関連の情報に加えて，2台のカメラそれぞれについて完全なキャリブレーションを行うこともできます．しかし，パラメータ空間の次元が高いことと，入力データに含まれるノイズのために，この関数は正しい解から乖離する可能性があります．各カメラについて個別に固有パラメータを高精度に推定できる場合（例えばcalibrateCameraを使って），そうすることをお勧めします．そして，計算された内部パラメータとともに，CALIB_FIX_INTRINSIC フラグを関数に渡してください．そうでなければ，すべてのパラメータが一度に推定されるのであれば，いくつかのパラメータを制限することに意味があります．例えば，CALIB_SAME_FOCAL_LENGTH フラグと CALIB_ZERO_TANGENT_DIST フラグを渡すことは，通常，合理的な仮定と言えます．

と同様にcalibrateCameraと同様に，この関数は，両方のカメラから得られるすべてのビューのすべての点に対する，合計再投影誤差を最小化します．この関数は，再投影誤差の最終的な値を返します．

◆ decomposeEssentialMat()

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

必須行列を，可能な回転と平行移動に分解します．

引数
E 入力となる必須行列．
R1 1つの可能な回転行列．
R2 もう1つの可能な回転行列。
t 1つの可能な並進。

この関数は、本質的な行列 E を svd 分解を用いて分解します。[HartleyZ00].. 一般に、E の分解には 4 つの可能なポーズがあります。$[R_1, t]$,$[R_1, -t]$,$[R_2, t]$,$[R_2, -t]$.

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

◆ decomposeHomographyMat()

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

ホモグラフィ行列を回転（複数），平行移動（複数），平面法線（複数）に分解します．

引数
H 2つの画像間の入力ホモグラフィ行列．
K 入力されたカメラ固有の行列．
rotations 回転行列の配列．
translations 並進行列の配列．
normals 平面法線マトリクスの配列．

この関数は，平面状の物体の2つのビュー間の相対的なカメラの動きを抽出し，回転，並進，平面法線の最大4つの数学的解のタプルを返します．ホモグラフィ行列 H の分解については，以下の文献で詳しく説明されています．[Malis]を参照してください。.

平面によって誘導されたホモグラフィHが，ソース画像の点に制約を与える場合

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

ソース画像の点$p_i$とデスティネーション画像の点$p'_i$であり，回転[k]と並進[k]のタプルは，ソースカメラの座標系からデスティネーションカメラの座標系への基底の変更である．しかし，Hを分解することで，シーンの（通常は未知の）深度で正規化された平行移動，つまり，その方向ではあるが正規化された長さしか得られない．

点の対応が得られる場合，正の深度制約，つまり，すべての点がカメラの前になければならないという制約を適用することで，少なくとも2つの解が無効になる可能性があります．

◆ decomposeProjectionMatrix()

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

射影行列を，回転行列とカメラ固有の行列に分解します．

引数
projMatrix 3x4 入力プロジェクション行列 P.
cameraMatrix 出力 3x3 カメラ固有マトリクス$\cameramatrix{A}$.
rotMatrix 3x3 外部回転行列 R を出力．
transVect 4x1 の並進ベクトル T を出力．
rotMatrixX オプションで，3x3 の X 軸周りの回転行列を作成します．
rotMatrixY 3x3 の y 軸周りの回転行列（オプション
rotMatrixZ オプションで，3x3 の z 軸周りの回転行列を作成します．
eulerAngles 3つのオイラー回転角（度）を含む3要素のベクトル（オプション）．

この関数は，射影行列をキャリブレーション行列と回転行列に分解し，カメラの位置を求めます．

また，オプションとして，各軸に1つずつ，計3つの回転行列と，OpenGLで利用可能な3つのオイラー角を返します．なお，オブジェクトの向きが同じになるような3つの主軸を中心とした回転のシーケンスは，常に1つ以上存在します．[スラボー】を参照してください。］. 返された木の回転行列とそれに対応する3つのオイラー角は、可能な解決策の1つに過ぎません。

この関数は， RQDecomp3x3 に基づいています．

◆ drawChessboardCorners()

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

検出されたチェスボードのコーナーをレンダリングします．

引数
image レンダリング先の画像．8ビットのカラー画像である必要があります．
patternSize チェスボードの行と列毎の内側コーナーの数（ patternSize = cv::Size(points_per_row,points_per_column) ）．
corners 検出されたコーナーの配列，の出力．findChessboardCorners.
patternWasFound 完全なボードが見つかったかどうかを示すパラメータ．の戻り値がここに渡されます．findChessboardCornersの戻り値をここに渡す必要があります。

この関数は，検出された個々のチェスボードのコーナーを，ボードが見つからなかった場合は赤丸で，ボードが見つかった場合は色付きのコーナーが線で結ばれた形で描画します．

◆ drawFrameAxes()

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

ポーズ推定によるワールド/オブジェクト座標系の軸を描画します．

参照
solvePnP
引数
image 入力/出力画像。1チャンネルまたは3チャンネルを持つ必要があります。チャンネル数は変更されません。
cameraMatrix カメラの固有パラメータの入力3x3浮動小数点行列。$\cameramatrix{A}$
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. ベクトルが空の場合は，歪み係数がゼロであると見なされます．
rvec 回転ベクトル（参考Rodriguestvecと一緒に、モデル座標系からカメラ座標系へと点を移動させる。
tvec 並進ベクトル．
length 塗り分け軸の長さをtvecと同じ単位（通常はメートル）で表したものです。
thickness 描画軸の線の太さ

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

◆ estimateAffine2D()

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

2つの2Dポイントセット間の最適なアフィン変換を計算します。

計算方法は以下の通りです。

\[ \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 1つ目の入力2Dポイントセット$(X,Y)$.
to 2つ目の入力2Dポイントセット$(x,y)$.
inliers どの点がインライアであるかを示す出力ベクトル（1-インライア、0-アウトライア）。
method 変換の計算にはロバストな方法が用いられます。以下の方法が考えられる．
  • RANSAC- RANSACベースのロバスト手法
  • LMEDS- Least-Median ロバスト手法 RANSAC がデフォルトの手法です．
ransacReprojThreshold ある点をインライアとみなすための，RANSACアルゴリズムにおける最大再投影誤差．RANSACにのみ適用されます。
maxIters ロバスト手法の反復回数の最大値です。
confidence 推定変換の信頼度（0から1の間）。通常は0.95から0.99の間であれば十分です。1に近すぎる値は、推定が著しく遅くなります。0.8-0.9よりも低い値は、正しくない推定変換をもたらすことがあります。
refineIters 洗練されたアルゴリズム（Levenberg-Marquardt）の最大反復数。0を渡すと精密化が無効になるので、出力行列はロバスト法の出力になります。
戻り値
2次元アフィン変換行列の出力$2 \times 3$または，変換が推定できなかった場合は空の行列。返される行列は，次のような形をしています．

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

この関数は，選択されたロバストアルゴリズムを用いて，2つの2次元点群間の最適な2次元アフィン変換を推定します．

計算された変換は，Levenberg-Marquardt 法を用いて（インライアのみを利用して）さらに精密化され，再投影誤差がさらに低減されます．

覚え書き
RANSAC法は、実際にはどのような比率の外れ値も扱うことができますが、外れ値とインライアを区別するための閾値が必要です。LMeDS法は，閾値を必要としませんが，インライアが50%以上の場合にのみ正しく動作します．
参照
estimateAffinePartial2D,getAffineTransform

◆ estimateAffine3D() [1/2]

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

2つの3Dポイントセット間の最適なアフィン変換を計算します。

計算方法は以下の通りです。$R,s,t$最小化$\sum{i} dst_i - c \cdot R \cdot src_i $ここで$R$は，3x3 の回転行列です．$t$は 3x1 の並進ベクトル，そして$s$は，スカラサイズの値です．これは，Umeyamaによるアルゴリズムの実装である。[umeyama1991least].. 推定されたアフィン変換は，7つの自由度を持つアフィン変換のサブクラスである同次尺度を持ちます．ペアとなる点セットは，それぞれ少なくとも3点からなる必要があります．

引数
src 1つ目の入力3Dポイントセット。
dst 2つ目の入力3Dポイントセット
scale nullが渡された場合、スケールパラメータcは1.0であるとみなされます。それ以外の場合は、指定された変数に最適なスケールが設定されます。
force_rotation trueの場合、返される回転は決して反射ではありません。これは、例えば、右手と左手の座標系の間の変換を最適化する場合など、望ましくない場合があります。
戻り値
3次元アフィン変換行列$3 \times 4$形式の

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

◆ estimateAffine3D() [2/2]

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

2つの3Dポイントセット間の最適なアフィン変換を計算します。

計算方法は以下の通りです。

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

引数
src 最初の入力3Dポイントセット$(X,Y,Z)$.
dst を含む2番目の入力3Dポイントセット$(x,y,z)$.
out 出力3次元アフィン変換行列$3 \times 4$形式の

\[ \begin{bmatrix} a_{11} & a_{12} & a_{13} & b_1\\ a_{21} & a_{22} & a_{23} & b_2\\ a_{31} & a_{32} & a_{33} & b_3\\ \end{bmatrix} \]

inliers どの点がインライアであるかを示す出力ベクトル（1-インライア、0-アウトライア）。
ransacThreshold 点をインライアと見なすための，RANSACアルゴリズムにおける最大再投影誤差．
confidence 推定変換の信頼度（0から1の間）。通常は0.95から0.99の間であれば十分です。1に近すぎる値は、推定が著しく遅くなります。0.8-0.9よりも低い値は、正しくない推定変換をもたらすことがあります。

この関数は，RANSACアルゴリズムを用いて，2つの3次元点集合間の最適な3次元アフィン変換を推定します．

◆ estimateAffinePartial2D()

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

2つの2次元点集合の間で，4つの自由度を持つ最適な限定アフィン変換を計算します．

引数
from 最初の入力2次元点集合
to 2番目の入力2Dポイントセット
inliers どの点がインライアであるかを示す出力ベクトル。
method 変換の計算にはロバストな方法が用いられます。以下の方法が考えられる．
  • RANSAC- RANSACベースのロバスト手法
  • LMEDS- Least-Median ロバスト手法 RANSAC がデフォルトの手法です．
ransacReprojThreshold ある点をインライアとみなすための，RANSACアルゴリズムにおける最大再投影誤差．RANSACにのみ適用されます。
maxIters ロバスト手法の反復回数の最大値です。
confidence 推定変換の信頼度（0から1の間）。通常は0.95から0.99の間であれば十分です。1に近すぎる値は、推定が著しく遅くなります。0.8-0.9よりも低い値は、正しくない推定変換をもたらすことがあります。
refineIters 洗練されたアルゴリズム（Levenberg-Marquardt）の最大反復数。0を渡すと精密化が無効になるので、出力行列はロバスト法の出力になります。
戻り値
出力 2D アフィン変換（4自由度）行列$2 \times 3$または，変換が推定できなかった場合は空の行列．

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

計算された変換は，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()

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

検出されたチェスボードのシャープネスを推定します。

画像のシャープネスは、明るさと同様に、正確なカメラキャリブレーションに不可欠なパラメータです。問題のあるキャリブレーション画像を除外するためにこれらのパラメータにアクセスするために、このメソッドは、黒から白のチェスボードのセルセンターへの移動によってエッジプロファイルを計算します。これをもとに、黒から白に移行するのに必要なピクセル数を算出します。この移行領域の幅は、チェスボードがどれだけシャープに撮影されているかを示す良い指標であり、～3.0ピクセル以下であることが望ましい。

引数
image チェスボードのコーナーを探すのに使われたグレー画像
patternSize 見つかったチェスボードのパターンの大きさ
corners 見つかったコーナーfindChessboardCornersSB
rise_distance 立ち上がり距離0.8は、10% ...を意味します。最終的な信号強度の90
vertical デフォルトでは、水平線のエッジレスポンスが計算される
sharpness オプションの出力配列には，計算されたエッジ・レスポンスに対するシャープネス値が入ります（説明を参照してください）．

オプションのシャープネス配列は，CV_32FC1 型であり，計算された各プロファイルに対して，以下の5つのエントリを持つ1つの行を持ちます．0 = 画像内の基礎となるエッジの x 座標 1 = 画像内の基礎となるエッジの y 座標 2 = 遷移領域の幅（シャープネス） 3 = 黒いセル内の信号強度（輝度の最小値） 4 = 白いセル内の信号強度（輝度の最大値）．

戻り値
Scalar(平均シャープネス, 平均最小輝度, 平均最大輝度,0)

◆ estimateTranslation3D()

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

2つの3Dポイントセット間の最適な平行移動を計算する。

計算方法は以下の通りです。

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

引数
src 最初の入力3Dポイントセット$(X,Y,Z)$.
dst を含む2番目の入力3Dポイントセット$(x,y,z)$.
out 出力される3次元平行移動ベクトル$3 \times 1$形式の

\[ \begin{bmatrix} b_1 \\ b_2 \\ b_3 \\ \end{bmatrix} \]

inliers どの点がインライアであるかを示す出力ベクトル（1-インライア、0-アウトライア）。
ransacThreshold 点をインライアと見なすための，RANSACアルゴリズムにおける最大再投影誤差．
confidence 推定変換の信頼度（0から1の間）。通常は0.95から0.99の間であれば十分です。1に近すぎる値は、推定が著しく遅くなります。0.8-0.9よりも低い値は、正しくない推定変換をもたらすことがあります。

この関数は，RANSACアルゴリズムを用いて，2つの3次元点群間の最適な3次元移動量を推定します．

◆ filterHomographyDecompByVisibleRefpoints()

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

追加情報に基づいて，ホモグラフィー分解をフィルタリングします．

引数
rotations 回転行列のベクトル
normals 平面法線マトリクスのベクトル
beforePoints ホモグラフィーを適用する前の（平行化された）可視参照点のベクトル
afterPoints ホモグラフィー適用後の（平行化された）可視参照点のベクトル
possibleSolutions フィルタリング後の実行可能なソリューションセットを表すintのインデックスのベクトル
pointsMask で与えられるインライアのマスクを表す，8u型の任意の Mat/Vector．findHomography関数

この関数は，関数の出力をフィルタリングするためのものです．decomposeHomographyMatに記述された追加情報に基づいて[Malis]を参照してください。. 手法の概要：関数decomposeHomographyMat関数は，2つのユニークな解とその「反対」の解，合計4つの解を返します．もし，ホモグラフィー変換の前後でカメラフレーム内に見える点のセットにアクセスできるならば，どのホモグラフィーが，すべての可視参照点がカメラの前にあることと矛盾しないかを検証することで，どれが真の潜在的な解で，どれが反対の解であるかを決定することができます．入力は変更されません。フィルタリングされた解集合は、既存の解集合へのインデックスとして返されます。

◆ filterSpeckles()

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

視差マップに含まれる小さなノイズの塊（スペックル）をフィルターで除去する

引数
img 入力された16ビット符号付き視差画像
newVal スペックルを除去するために使われる視差の値
maxSpeckleSize スペックルとみなすための最大スペックルサイズ。大きなblobはアルゴリズムの影響を受けません
maxDiff 隣接する視差画素を同じblobに入れるための，最大差。なお、以下のようにStereoBM,StereoSGBMやその他のアルゴリズムでは、固定小数点の視差マップを返すため、視差の値が16倍になるので、このパラメータ値を指定する際には、このスケールファクターを考慮する必要があります。
buf 関数内でのメモリ割り当てを回避するための，任意の一時バッファ．

◆ findChessboardCorners()

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

チェスボードの内側の角の位置を求めます。

引数
image ソースとなるチェスボードのビュー。8ビットのグレースケールまたはカラー画像である必要があります。
patternSize チェスボードの行と列毎の内側コーナーの数 ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ) ．
corners 検出されたコーナーの出力配列．
flags 0または以下の値の組み合わせになる，様々な操作フラグ．
  • CALIB_CB_ADAPTIVE_THRESH 画像を白黒に変換する際に，（画像の平均的な明るさから計算される）固定の閾値ではなく，適応的な閾値を利用します．
  • CALIB_CB_NORMALIZE_IMAGE 固定または適応型しきい値を適用する前に equalizeHist で画像のガンマを正規化します。
  • CALIB_CB_FILTER_QUADS 輪郭検索段階で抽出された偽の四角形をフィルタリングするために、追加の基準（輪郭の面積、周囲、四角形のような形など）を使用します。
  • CALIB_CB_FAST_CHECK チェスボードの角を探す高速チェックを画像上で実行し、角が見つからない場合は呼び出しをショートカットします。これにより、チェスボードが観察されない退化した状態での呼び出しを大幅に高速化することができます。

この関数は，入力画像がチェスボードパターンを表しているかどうかを判定し，内部のチェスボードコーナーの位置を特定しようとします．この関数は，すべてのコーナーが見つかり，それらが一定の順序（行ごとに，左から右へ）で配置されていれば，0ではない値を返します．そうでない場合，この関数がすべてのコーナーを見つけることができなかったり，並べ替えることができなかったりすると，0を返します．例えば，通常のチェスボードは，8×8の正方形と7×7の内部コーナー，つまり，黒い正方形が互いに接触するポイントを持っています．検出された座標は近似値であり，その位置をより正確に決定するために，この関数は cornerSubPix を呼び出します．また，返された座標が十分に正確でない場合は，関数 cornerSubPix を別のパラメータで使用することもできます．

チェスボードのコーナーを検出して描画するサンプルの使い方： :

Size patternsize(8,6); //interior number of corners
Mat gray = ....; //source image
vector<Point2f> corners; //this will be filled by the detected corners
//CALIB_CB_FAST_CHECK saves a lot of time on images
//that do not contain any chessboard corners
bool patternfound = findChessboardCorners(gray, patternsize, corners,
CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
+ CALIB_CB_FAST_CHECK);
if(patternfound)
cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::findChessboardCorners
CV_EXPORTS_W bool findChessboardCorners(InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
Finds the positions of internal corners of the chessboard.
cv::drawChessboardCorners
CV_EXPORTS_W void drawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
Renders the detected chessboard corners.
cv::cornerSubPix
CV_EXPORTS_W void cornerSubPix(InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)
Refines the corner locations.
覚え書き
この関数は，様々な環境下での検出をより確実なものにするために，チェスボードの周囲に余白（正方形の厚さの境界線のようなもの，広ければ広いほど良い）を必要とします．そうしないと，境界線がなく背景が暗い場合，外側の黒い正方形が適切にセグメント化されないため，正方形のグループ化と順序付けのアルゴリズムが失敗します．

◆ findChessboardCornersSB() [1/2]

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

セクターベースのアプローチを用いて、チェスボードの内側の角の位置を見つけます。

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

この関数はfindChessboardCornersに似ていますが，ボックスフィルタで近似された局所的なラドン変換を利用しており，あらゆる種類のノイズに対してより頑健で，大きな画像に対しても高速で，チェスボード内部のコーナーのサブピクセル位置を直接返すことができます．この手法は、次の論文に基づいています。[duda2018]を参照しています。 "Accurate Detection and Localization of Checkerboard Corners for Calibration" demonstrating that the returned sub-pixel positions are more accurate than the one returned by cornerSubPix allowing a precise camera calibration for demanding applications.

CALIB_CB_LARGER または CALIB_CB_MARKER フラグが指定された場合，その結果はオプションの meta 配列から取得できます．これらのフラグは、カメラの視野を超えるキャリブレーションパターンを使用する際に役立ちます。このような大規模なパターンでは、画像の境界にできるだけ近いコーナーを利用できるため、より正確なキャリブレーションが可能になります。すべての画像で一貫した座標系を実現するために、オプションのマーカー（下の画像参照）を使用して、ボードの原点を黒丸の位置に移動させることができます。

覚え書き
この機能では、様々な環境下での検出を向上させるために、ボード全体の周囲に市松模様のフィールドの1つとほぼ同じ幅の白いボーダーを必要とします。また、局所的なラドン変換を行うため、ボードの外側に位置するフィールドの角には丸い角を使用することが有効です。次の図は、検出に最適なチェッカーボードの例です。ただし、他のチェッカーボードを使用することもできます。Checkerboard

◆ findChessboardCornersSB() [2/2]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findCirclesGrid() [1/2]

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

グリッド上の円の中心を検出します。

引数
image 入力された円のグリッドビュー。8ビットのグレースケールまたはカラー画像である必要があります。
patternSize 行と列ごとの円の数 ( patternSize = Size(points_per_row, points_per_colum) ) 。
centers 検出された中心の出力配列．
flags 以下の値のいずれかを取ることができる様々な操作フラグ。
  • CALIB_CB_SYMMETRIC_GRID は、円の対称的なパターンを使用します。
  • CALIB_CB_ASYMMETRIC_GRID 非対称な円のパターンを使用する。
  • CALIB_CB_CLUSTERING はグリッド検出に特別なアルゴリズムを使用します。視点の歪みにはより強いですが、背景の乱雑さにはより敏感です。
blobDetector 明るい背景上の暗い円のようなblobを検出する特徴検出器。もしblobDetectorがNULLの場合はimageは，候補の Point2f 配列を表します．
parameters グリッドパターン内の円を見つけるための構造体．

この関数は，入力画像に格子状の円が含まれているかどうかを調べます．この関数は，入力画像に格子状の円が含まれているかどうかを判定し，含まれている場合は，その円の中心を探します．この関数は，すべての中心が見つかり，それらが一定の順序（行ごとに，左から右へ）で配置されていれば，0ではない値を返します．そうでない場合，この関数がすべての角を見つけることができなかったり，並べ替えることができなかったりすると，0 を返します．

円の中心を検出して描画する使い方のサンプル。:

Size patternsize(7,7); //number of centers
Mat gray = ...; //source image
vector<Point2f> centers; //this will be filled by the detected centers
bool patternfound = findCirclesGrid(gray, patternsize, centers);
drawChessboardCorners(img, patternsize, Mat(centers), patternfound);
cv::findCirclesGrid
CV_EXPORTS_W bool findCirclesGrid(InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters &parameters)
Finds centers in the grid of circles.
覚え書き
この関数は，様々な環境下での検出をより確実なものにするために，ボードの周囲にホワイトスペース（正方形の厚さの境界線のようなもの，広ければ広いほど良い）を必要とします．

◆ findCirclesGrid() [2/2]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findEssentialMat() [1/5]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findEssentialMat() [2/5]

CV_EXPORTS_W 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()
)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数
points1 1枚目の画像から得られる，N (N >= 5) 個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
focal カメラの焦点距離．なお，この関数は， points1 と points2 が，同じ焦点距離と主点を持つカメラから得られた特徴点であることを仮定しています．
pp カメラの主点。
method 基本行列の計算方法．
  • RANSACRANSACアルゴリズム用．
  • LMEDSLMedS アルゴリズムのためのパラメータ．
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/5]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findEssentialMat() [4/5]

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

2つの画像中の対応する点から，本質的な行列を求めます．

引数
points1 1枚目の画像から得られる，N (N >= 5) 個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
cameraMatrix カメラ固有の行列$\cameramatrix{A}$. この関数は，point1 と point2 が，同じカメラ固有の行列を持つカメラの特徴点であることを仮定していることに注意してください．この仮定が成り立たない場合は，両方のカメラにundistortPointsを用いたP = cv::NoArray()を使用して，画像ポイントを正規化された画像座標に変換します．これは，カメラ固有の行列が同一の場合に有効です．これらの座標を渡す際には，このパラメータに恒等行列を渡します．
method 固有マトリクスを計算する方法．
  • RANSACRANSACアルゴリズム用．
  • LMEDSLMedS アルゴリズムのためのパラメータ．
prob RANSAC法またはLMedS法のみで使用されるパラメータ。推定された行列が正しいことを示す，望ましい信頼度（確率）を指定します．
threshold RANSACに使用されるパラメータ．点からエピポーラ線までの最大距離（ピクセル単位）で，これを超えるとその点は外れ値とみなされ，最終的な基本行列の計算には利用されません．この値は，点のローカライズの精度，画像の解像度，および画像のノイズに応じて，1〜3程度に設定できます．
mask N 個の要素からなる出力配列．この配列の各要素は，はずれ値に対しては 0，その他の点に対しては 1 に設定されます．この配列は，RANSAC 法と LMedS 法でのみ計算されます．
maxIters ロバスト手法の反復回数の最大値です。

この関数は，[Nister03] の5点アルゴリズムソルバーに基づいて，必須行列を推定します．[Nister03]..[SteweniusCFS］も関連しています．エピポーラ幾何学は，次の式で表されます．

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

ここで$E$は本質的な行列です。$p_1$および$p_2$は，それぞれ第1画像と第2画像の対応する点です．この関数の結果は，さらにdecomposeEssentialMatまたはrecoverPoseに渡すことで，カメラ間の相対的な姿勢を復元することができます．

◆ findEssentialMat() [5/5]

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

2台の異なるカメラで撮影された2つの画像の対応点から，本質的な行列を求めます．

引数
points1 1枚目の画像から得られる，N (N >= 5) 個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
cameraMatrix1 カメラ行列$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$. この関数は，point1 と points2 が，同じカメラ行列を持つカメラからの特徴点であることを仮定していることに注意してください．もし，この仮定が成り立たない場合は，両方のカメラに対してundistortPointsを用いたP = cv::NoArray()を使用して，画像ポイントを正規化された画像座標に変換します．これは，同一のカメラ行列に対して有効です．これらの座標を渡す際には，このパラメータに同一の行列を渡します．
cameraMatrix2 カメラ行列$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$. この関数は，point1 と points2 が，同じカメラ行列を持つカメラからの特徴点であることを仮定していることに注意してください．もし，この仮定が成り立たない場合は，両方のカメラに対してundistortPointsを用いたP = cv::NoArray()を使用して，画像ポイントを正規化された画像座標に変換します．これは，同一のカメラ行列に対して有効です．これらの座標を渡す際には，このパラメータに同一の行列を渡します．
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/空の場合は，歪み係数が 0 であると見なされます．
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/空の場合は，歪み係数が 0 であると見なされます．
method 固有マトリクスを計算する方法．
  • RANSACRANSACアルゴリズム用．
  • LMEDSLMedS アルゴリズムのためのパラメータ．
prob RANSAC法またはLMedS法のみで使用されるパラメータ。推定された行列が正しいことを示す，望ましい信頼度（確率）を指定します．
threshold RANSACに使用されるパラメータ．点からエピポーラ線までの最大距離（ピクセル単位）で，これを超えるとその点は外れ値とみなされ，最終的な基本行列の計算には利用されません．この値は，点のローカライズの精度，画像の解像度，および画像のノイズに応じて，1〜3程度に設定できます．
mask N 個の要素からなる出力配列．この配列の各要素は，はずれ値に対しては 0，その他の点に対しては 1 に設定されます．この配列は，RANSAC 法と LMedS 法でのみ計算されます．

この関数は，[Nister03] の5点アルゴリズムソルバーに基づいて，必須行列を推定します．[Nister03]..[SteweniusCFS］も関連しています．エピポーラ幾何学は，次の式で表されます．

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

ここで$E$は本質的な行列です。$p_1$および$p_2$は，それぞれ第1画像と第2画像の対応する点です．この関数の結果は，さらにdecomposeEssentialMatまたはrecoverPoseに渡すことで，カメラ間の相対的な姿勢を復元することができます．

◆ findFundamentalMat() [1/3]

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

2つの画像の対応する点から，基本行列を求めます．

引数
points1 1枚目の画像から得られるN個の点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければいけません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
method 基本行列の計算方法．
  • FM_7POINT7-point algorithmの場合。$N = 7$
  • FM_8POINT8-point アルゴリズムの場合．$N \ge 8$
  • FM_RANSACRANSACアルゴリズム用．$N \ge 8$
  • FM_LMEDSLMedS アルゴリズムのためのパラメータ．$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$は，それぞれ第1画像と第2画像の対応する点です．

この関数は，上述の4つの手法のうちの1つを用いて基本行列を計算し，求められた基本行列を返します．通常は，1つの行列だけが求められます．しかし，7-point アルゴリズムの場合，この関数は最大3つの解を返すことがあります ($9 \times 3$は，3 つの行列をすべて順に格納する行列です)．

求められた基本行列は，指定された点に対応するエピポーラ線を求める computeCorrespondEpilines に渡すことができます．また，この行列はstereoRectifyUncalibratedに渡して，平行化変換を求めることもできます．

// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
Mat fundamental_matrix =
findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
cv::findFundamentalMat
CV_EXPORTS_W Mat findFundamentalMat(InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
Calculates a fundamental matrix from the corresponding points in two images.
cv::FM_RANSAC
@ FM_RANSAC
RANSAC algorithm. It needs at least 15 points. 7-point algorithm is used.
Definition: calib3d.hpp:527

◆ findFundamentalMat() [2/3]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findFundamentalMat() [3/3]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ findHomography() [1/2]

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

2つの平面間の透視変換を求めます．

引数
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} * \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\]

であれば，その点$i$を外れ値として扱います．srcPoints と dstPoints がピクセル単位で計測される場合，通常，このパラメータを 1 から 10 の範囲で設定するのが良いでしょう．
mask ロバスト手法（RANSAC や LMeDS ）で設定される出力マスク（オプション）．ただし，入力マスクの値は無視されます．
maxIters RANSACの最大反復回数．
confidence 0から1の間の信頼度．

この関数は，入力面と出力面の間の透視変換を求め，それを返します．$H$を見つけて返します．

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

逆投影誤差

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

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

しかし，すべての点のペア($srcPoints_i$,$dstPoints_i$)が剛体透視変換に適合しない場合（つまり，はずれ値がある場合），この初期推定値は悪くなります．このような場合、3つのロバストな手法のうちの1つを使用することができます。RANSAC、LMeDS、RHOの各手法は、対応する点のペアの多くの異なるランダムなサブセット（各4ペア、共線ペアは破棄される）を試し、このサブセットと単純な最小二乗アルゴリズムを使用してホモグラフィ行列を推定し、計算されたホモグラフィの品質/良さ（RANSACの場合は外れ値の数、LMeDSの場合は再投影誤差の最小中央値）を計算します。そして、最適なサブセットを用いて、ホモグラフィ行列の初期推定値とインライア/アウトライアのマスクを作成します。

ロバスト法か否かに関わらず，計算されたホモグラフィ行列は，Levenberg-Marquardt法を用いて（ロバスト法の場合はインライアのみを使用して）さらに精密化され，再投影誤差がさらに低減されます．

RANSAC法とRHO法は，実際にはどのような比率のインライアも扱うことができますが，インライアとアウトライアを区別するための閾値が必要です．LMeDSは閾値を必要としませんが、インライアが50％以上の場合にのみ正しく動作します。最後に，はずれ値がなく，ノイズがかなり小さい場合は，デフォルトの手法（method=0）を利用します．

この関数は，初期のイントリンシック行列とエクストリンシック行列を求めるために利用されます．ホモグラフィー行列は，ある尺度まで決定されます．したがって，以下のように正規化されます$h_{33}=1$. なお，ある$H$行列が推定できない場合は，空の行列が返されることに注意してください．

参照
getAffineTransform,estimateAffine2D,estimateAffinePartial2D,getPerspectiveTransform,warpPerspective,perspectiveTransform

◆ findHomography() [2/2]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ getDefaultNewCameraMatrix()

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

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

この関数は，入力された 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$は$(0,0)$および$(1,1)$それぞれ cameraMatrix の要素となります。

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

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

◆ getOptimalNewCameraMatrix()

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

フリースケーリングパラメータに基づく，新しいカメラ固有の行列を返します．

引数
cameraMatrix 入力カメラ固有の行列．
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
imageSize 元の画像サイズ．
alpha 0（歪んでいない画像のすべてのピクセルが有効な場合）と1（元画像のすべてのピクセルが歪んでいない画像に保持される場合）の間のフリースケーリングパラメータ．参照stereoRectifyを参照してください。
newImgSize 整形後の画像サイズ。デフォルトでは， imageSize に設定されています．
validPixROI 歪んでいない画像の中の，すべての良いピクセルの領域を囲む出力矩形（オプション）．の roi1, roi2 の説明を参照してください．stereoRectify.
centerPrincipalPoint 新しいカメラの内部行列において，主点を画像の中心に置くべきかどうかを示すオプションのフラグ．デフォルトでは，ソース画像のサブセット（アルファ値で決まる）が補正後の画像に最もフィットするように主点が選択されます．
戻り値
new_camera_matrix 新しいカメラ固有の行列を出力します．

この関数は，フリースケーリングパラメータに基づいて，最適な新しいカメラ固有の行列を計算し，それを返します．このパラメータを変化させることで，意味のあるピクセルだけを取得することができます． alpha=0 ，コーナーに貴重な情報がある場合は元の画像のピクセルをすべて残し， alpha=1 ，またはその中間の値を取得することができます．alpha>0の場合，歪みのない結果には，キャプチャされた歪んだ画像の外側にある「仮想」ピクセルに対応するいくつかの黒いピクセルが含まれる可能性があります．元のカメラの内部行列，歪み係数，計算された新しいカメラの内部行列，そして newImageSize をinitUndistortRectifyMapのマップを生成するためにremap.

◆ initCameraMatrix2D()

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

3D-2D の点の対応関係から初期のカメラ固有マトリックスを求めます．

引数
objectPoints キャリブレーションパターン座標空間におけるキャリブレーションパターンポイントのベクター。旧インターフェースでは，すべてのビューごとのベクトルが連結されています．参照calibrateCameraを参照してください。
imagePoints キャリブレーションパターンの点の投影のベクトルのベクトル。旧インターフェースでは、すべてのビューごとのベクトルが連結されています。
imageSize 主点の初期化に使用されるピクセル単位の画像サイズ。
aspectRatio この値がゼロまたは負の場合、両方の$f_x$および$f_y$は独立して推定されます。そうでない場合は$f_x = f_y * \texttt{aspectRatio}$.

この関数は，カメラキャリブレーション処理のために，初期のカメラ固有マトリクスを推定して返します．現在のところ，この関数は平面的なキャリブレーションパターンのみをサポートしています．これは，各オブジェクトポイントの z-座標が 0 であるパターンです．

◆ initInverseRectificationMap()

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

投影および逆補正の変換マップを計算します．要するに，これはinitUndistortRectifyMapの逆数であり，プロジェクタとカメラのペアにおけるプロジェクタ（「逆カメラ」）のステレオ補正に対応しています．

この関数は，投影と逆平行化の変換を合同で計算し，その結果を次のようなマップの形で表しますremap. 投影された画像は，元の画像を歪めたもののように見えますが，これをプロジェクターで投影すると，元の画像と見た目が一致するはずです．単眼カメラの場合，newCameraMatrix は通常 cameraMatrix と等しいですが，スケーリングをより適切に制御するためにgetOptimalNewCameraMatrixで計算することもできます．これは，スケーリングをより適切に制御するためです．プロジェクターとカメラのペアの場合，newCameraMatrix は通常，次の式で求められる P1 または P2 に設定されますstereoRectify.

プロジェクターとカメラのペアの場合、これはステレオを作成するために（カメラの場合と同じ方法で）プロジェクターを整列させるのに役立ちます（Rに従って）。initUndistortRectifyMapカメラの場合と同じ方法で）プロジェクターを調整し、ステレオ補正されたペアを作ることができます。これにより，両方の画像のエピポーラ線が水平になり，同じY座標を持つようになります（水平に配置されたプロジェクタとカメラのペアの場合）．

この関数は，以下で使用される逆マッピングアルゴリズム用のマップを作成します．remap. つまり，デスティネーションの各ピクセル$(u, v)$つまり，投影・逆補正された出力画像の各ピクセルに対して，入力画像（つまり，元のデジタル画像）における対応する座標を求めます．以下のような処理を行います．

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

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

プロジェクターとカメラのペアがステレオ補正されている場合，この関数はプロジェクターに対して呼ばれ，一方でinitUndistortRectifyMapはカメラヘッドに対して呼び出されます。この処理はstereoRectifyの後に呼び出され，さらにそれはstereoCalibrate. プロジェクターとカメラのペアがキャリブレーションされていない場合でも、次のようにして、基本行列から直接、平行化変換を計算することができます。stereoRectifyUncalibrated. プロジェクターとカメラに対して，この関数は，3D空間の回転行列Rではなく，ピクセル領域の平行化変換としてホモグラフィHを求めます．R は，H から次のように計算されます

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

ここで cameraMatrix は，任意に選択できます．

引数
cameraMatrix 入力カメラ行列$A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$.
distCoeffs 入力 歪み係数のベクトル$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])$の4、5、8、12、14個の要素を持つ。ベクトルが NULL/空の場合は，歪み係数が 0 であると見なされます．
R オプションである，物体空間における平行化変換（3x3 の行列）．で計算された R1 または R2 をここに渡すことができます．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 2番目の出力マップremap.

◆ initUndistortRectifyMap()

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

歪み補正・平行化変換マップを求めます．

この関数は，歪みと平行化の変換を合同で計算し，その結果を以下のようなマップの形で表しますremap. 歪みのない画像は，カメラ行列 =newCameraMatrix を用いたカメラで撮影されたかのように，元の画像と同じように見え，歪みは0になります．単眼カメラの場合，newCameraMatrix は通常 cameraMatrix と等しいですが，スケーリングをより正確に制御するために，次式で計算することもできますgetOptimalNewCameraMatrixによって計算することもできます．これは，スケーリングをより正確に制御するためです．ステレオカメラの場合，newCameraMatrix は通常，次式で求められる P1 または P2 に設定されます．stereoRectify.

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

この関数は，逆マッピングアルゴリズムのためのマップを作成します．remap. つまり，デスティネーションの各ピクセル$(u, v)$この関数は，補正・平行化されたデスティネーション画像において，ソース画像（つまり，カメラから出力されたオリジナル画像）の対応する座標を計算します．以下のような処理が行われます．

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

ここで$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])$は，歪み係数です．

ステレオカメラの場合，この関数は2回呼ばれます：各カメラヘッドに対して1回，後にstereoRectifyの後に呼び出され，さらにその次はstereoCalibrate. しかし，ステレオカメラのキャリブレーションが行われていない場合でも，次のようにして，基本行列から直接，平行化変換を計算することができます。stereoRectifyUncalibrated. この関数は，各カメラに対して，3次元空間の回転行列 R ではなく，ピクセル領域の平行化変換としてホモグラフィ H を求めます．R は，H から次のようにして求められます

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

ここで cameraMatrix は，任意に選択できます．

引数
cameraMatrix 入力カメラ行列$A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$.
distCoeffs 入力 歪み係数のベクトル$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])$の4、5、8、12、14個の要素を持つ。ベクトルが NULL/空の場合は，歪み係数が 0 であると見なされます．
R オブジェクト空間における任意の平行化変換（3x3 の行列）．で計算された R1 または R2 をここに渡すことができます．stereoRectifyをここに渡すことができます．この行列が空の場合は，恒等変換が仮定されます．cvInitUndistortMap では，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 第1の出力マップ．
map2 2番目の出力マップ．

◆ matMulDeriv()

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

乗算された各行列について，行列積の偏導関数を求めます．

引数
A 1 番目に乗算された行列．
B 2 番目に乗算された行列．
dABdA 大きさの1番目の出力導関数行列 d(A*B)/dA$\texttt{A.rows*B.cols} \times {A.rows*A.cols}$.
dABdB 2 番目に出力される微分行列 d(A*B)/ddB（サイズ$\texttt{A.rows*B.cols} \times {B.rows*B.cols}$.

この関数は，行列の積の要素の，各要素に関する偏微分を求めます．$A*B$この関数は，2つの入力行列のそれぞれの要素に関する，行列積の要素の偏微分を求めます．この関数は，次のような行列のヤコビアン行列を計算するために利用されます．stereoCalibrateのヤコビ行列を計算するために利用されていますが，他の類似した最適化関数でも利用することができます．

◆ projectPoints()

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

3次元点を画像平面に投影します．

引数
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$)が固定されていると仮定し，それに応じてヤコビアン行列を調整します．

この関数は，カメラの内部および外部パラメータが与えられた場合に，3次元点の画像平面への2次元投影を求めます．オプションとして，この関数は，（すべての入力パラメータの関数としての）画像点座標の偏微分のヤコビアン行列を，特定のパラメータ（内部および外部）に関して求めます．このヤコビアンは，以下のグローバル最適化処理で利用されます．calibrateCamera,solvePnPを満たす。stereoCalibrate. また，この関数自体も，現在の内在・外在パラメータが与えられた場合の再投影誤差を求めるために利用できます．

覚え書き
rvec = tvec = を設定することで$[0, 0, 0]$と設定したり，cameraMatrix を 3x3 の単位行列に設定したり，歪み係数を 0 にしたりすることで，この関数の様々な有用な部分例を得ることができます．つまり，理想的なゼロディストーションの設定で，疎な点群に対する歪んだ座標を計算したり，透視変換を適用したり（そして，その微分を計算したり）することができるのです．

◆ recoverPose() [1/3]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数
E 入力となる必須行列．
points1 1枚目の画像から得られたN個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1...と同じサイズ，同じ形式の，2枚目の画像の点の配列．
cameraMatrix カメラ固有の行列$\cameramatrix{A}$. この関数は， points1 と points2 が，同じカメラ固有の行列を持つカメラから得られた特徴点であることを仮定していることに注意してください．
R 出力される回転行列．この行列は，並進ベクトルとともに，第1のカメラの座標系から第2のカメラの座標系への基底変更を行うタプルを構成する．一般的に、このタプルにtは使用できないことに注意してください、下記のパラメータの説明を参照してください。
t 出力並進ベクトル．このベクトルは次の式で得られます．decomposeEssentialMatつまり，t は並進ベクトルの方向であり，単位長さを持っています．
distanceThresh 遠くの点（すなわち無限の点）をフィルタリングするために使用される閾値距離。
mask point1とpoint2のインライアに対する入出力マスク。これが空でない場合，与えられた必須行列Eに対して，point1とpoint2のインライアをマークします．これらのインライアのみが，ポーズの復元に使用されます．出力マスクには、キラリティ・チェックに合格したインライアのみが表示されます。
triangulatedPoints 三角測量によって再構成された3Dポイント。

この関数は，上記の関数とは異なり，不正性チェックに使用された三角測量された3Dポイントを出力します．

◆ recoverPose() [2/3]

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

推定された本質的な行列と2つの画像中の対応する点から，カメラの相対的な回転と並進をcheirality checkを用いて復元します．チェックに合格したインライアの数を返します。

引数
E 入力となる必須行列．
points1 1枚目の画像から得られたN個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
cameraMatrix カメラ固有の行列$\cameramatrix{A}$. この関数は， points1 と points2 が，同じカメラ固有の行列を持つカメラから得られた特徴点であることを仮定していることに注意してください．
R 回転行列を出力します．この行列は，並進ベクトルと一緒に，1番目のカメラの座標系から2番目のカメラの座標系への基底変更を行うタプルを構成します．なお，一般に，このタプルには t を使うことはできませんが，後述のパラメータを参照してください．
t 出力並進ベクトル．このベクトルは次の式で得られます．decomposeEssentialMatつまり，t は並進ベクトルの方向であり，単位長さを持っています．
mask point1とpoint2のインライアに対する入出力マスク。これが空でない場合，与えられた必須行列Eに対して，point1とpoint2のインライアをマークします．これらのインライアのみが，ポーズの復元に使用されます．出力マスクには、キラリティ・チェックに合格したインライアのみが表示されます。

この関数は，以下を用いて本質的な行列を分解しdecomposeEssentialMatを用いて本質的な行列を分解した後，cheirality checkを行って，可能なポーズ仮説を検証します．cheirality checkとは，三角測量された3次元点が正の深度を持つことを意味します．詳細は以下を参照してください．[Nister03]..

この関数は，次のような出力Eとマスクの処理に利用できます．findEssentialMat. このシナリオでは，point1 と points2 は，次のような同じ入力です．findEssentialMat:

// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
// cametra matrix with both focal lengths = 1, and principal point = (0, 0)
Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
Mat E, R, t, mask;
E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask);
recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
cv::Mat::eye
static MatExpr eye(int rows, int cols, int type)
Returns an identity matrix of the specified size and type.
cv::findEssentialMat
CV_EXPORTS_W Mat findEssentialMat(InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
Calculates an essential matrix from the corresponding points in two images.
cv::recoverPose
CV_EXPORTS_W int recoverPose(InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray())
Recovers the relative camera rotation and the translation from an estimated essential matrix and the ...
cv::RANSAC
@ RANSAC
RANSAC algorithm
Definition: calib3d.hpp:445

◆ recoverPose() [3/3]

CV_EXPORTS_W 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()
)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数
E 入力となる必須行列．
points1 1枚目の画像から得られたN個の2次元点の配列．点の座標は，浮動小数点（単精度または倍精度）でなければなりません．
points2 points1 と同じサイズと形式の，2 番目の画像の点の配列．
R 出力される回転行列．この行列は，並進ベクトルとともに，第1のカメラの座標系から第2のカメラの座標系への基底変更を行うタプルを構成する．一般的に、このタプルにtは使用できないことに注意してください、下記のパラメータの説明を参照してください。
t 出力並進ベクトル．このベクトルは次の式で得られます．decomposeEssentialMatつまり，t は並進ベクトルの方向であり，単位長さを持っています．
focal カメラの焦点距離．なお，この関数は，点1と点2が，同じ焦点距離と主点を持つカメラから得られた特徴点であることを仮定しています．
pp カメラの主点。
mask point1とpoint2のインライアに対する入出力マスク。これが空でない場合，与えられた必須行列Eに対して，point1とpoint2のインライアをマークします．これらのインライアのみが，ポーズの復元に使用されます．出力マスクには、キラリティ・チェックに合格したインライアのみが表示されます。

この関数は，上述のものとは異なり，焦点距離と主点からカメラの内部行列を求めます．

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

◆ reprojectImageTo3D()

CV_EXPORTS_W void cv::reprojectImageTo3D ( InputArray disparity,
OutputArray _3dImage,
InputArray Q,
bool handleMissingValues = false,
int ddepth = -1
)

視差画像を3次元空間に再投影します．

引数
disparity 入力 シングルチャンネルの，8ビット符号なし，16ビット符号あり，32ビット符号あり，または32ビット浮動小数点の視差画像．8bit / 16bit 符号付きフォーマットの値は，小数ビットを持たないと仮定されます。で計算された16ビット符号付きフォーマットの視差であれば，それはStereoBMまたはStereoSGBMやその他のアルゴリズムで計算された16ビット符号付き視差の場合，ここで使用する前に，16で割って（floatにスケーリングして）おく必要があります．
_3dImage 視差と同じサイズの，3チャンネル浮動小数点型画像を出力します．_3dImage(x,y) の各要素には，視差マップから計算された点 (x,y) の3次元座標が入ります．で得られたQを利用する場合はstereoRectifyで得られるQを用いると，返される点は1台目のカメラの平行移動座標系で表されます．
Q $4 \times 4$で得られる透視変換行列．stereoRectify.
handleMissingValues この関数が，欠損値（つまり，視差が計算されなかった点）を扱うべきかどうかを示します．handleMissingValues=true の場合，外れ値に対応する最小の視差を持つピクセル（seeStereoMatcher::computeを参照してください）は，非常に大きなZ値（現在は10000に設定されています）を持つ3次元点に変換されます．
ddepth オプションである出力配列の depth を指定します．これが -1 の場合，出力画像の深度は CV_32F になります． ddepth は， CV_16S, CV_32S, CV_32F に設定することもできます．

この関数は，シングルチャンネルの視差マップを，3次元表面を表す3チャンネルの画像に変換します．つまり，各ピクセル (x,y) と，それに対応する視差 d=disparity(x,y) に対して，次のような計算を行います．

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

参照
疎な点の集合 {(x,y,d),...} を3次元空間に再投影するためにはperspectiveTransform.

◆ Rodrigues()

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

回転行列を回転ベクトルに変換したり，逆に回転行列を回転ベクトルに変換したりします．

引数
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.

覚え書き
3次元回転行列の指数座標に対する導関数の計算についての詳細は、以下を参照してください。
  • A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi[Gallego2014ACF】を参照してください。］
SE(3)とリー群に関する有用な情報は以下にあります。
  • A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco[blanco2010tutorial].
  • Lie Groups for 2D and 3D Transformation, Ethan Eade[Eade17] （英語
  • A micro Lie theory for state estimation in robotics, Joan Solà, Jérémie Deray, Dinesh Atchuthan[Sol2018AML]を参照してください。

◆ RQDecomp3x3()

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

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

引数
src 3x3の入力行列。
mtxR 出力 3x3 上三角行列。
mtxQ 出力 3x3 直交行列。
Qx オプションで、3x3 の x 軸周りの回転行列を出力します。
Qy オプションで出力される 3x3 の y 軸周りの回転行列
Qz オプションで，3x3 の z-軸周りの回転行列を出力します．

この関数は，与えられた回転を用いて RQ 分解を行います．この関数はdecomposeProjectionMatrixで使用され，射影行列の左3x3部分行列をカメラ行列と回転行列に分解します．

また，オプションとして，各軸ごとに1つずつ，計3つの回転行列と，OpenGLで利用可能な3つのオイラー角を（戻り値として）返します．なお、オブジェクトの向きが同じになるような3つの主軸を中心とした回転のシーケンスは、常に1つ以上存在します。[スラボー】を参照してください。］. 返された木の回転行列とそれに対応する3つのオイラー角は、可能な解決策の1つに過ぎません。

◆ sampsonDistance()

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

2点間の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関数を用いて計算できます．詳細は[HartleyZ00].11.4.3 を参照してください．

引数
pt1 第1の同次2次元点
pt2 第2同次2次元点
F 基本行列
戻り値
計算されたサンプソン距離。

◆ solveP3P()

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

3 つの 3D-2D 点の対応関係から，物体の姿勢を求めます．

引数
objectPoints 3x3 1-channel または 1x3/3x1 3-channel の，物体座標空間における物体点の配列．
imagePoints 3x2 1ch または 1x3/3x1 2ch の，対応する画像上の点の配列．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvecs 出力される回転ベクトル（参考Rodriguesを参照してください）を出力します．これは，tvecsと一緒に，点をモデル座標系からカメラ座標系に移動させます．P3P問題は最大で4つの解を持ちます。
tvecs 並進ベクトルの出力。
flags P3P問題の解法。
  • SOLVEPNP_P3Pこの方法は、X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang "Complete Solution Classification for the Perspective-Three-Point Problem" ([gao2003complete]を参照してください。).
  • SOLVEPNP_AP3P方法は、T. KeとS. Roumeliotisの論文に基づいています。"An Efficient Algebraic Solution to the Perspective-Three-Point Problem" ([Ke17].).

この関数は，3つの物体点と，それらに対応する画像投影，さらにカメラの固有行列と歪み係数が与えられた場合に，物体の姿勢を推定します．

覚え書き
解答は，再投影誤差が小さいものから大きいものへとソートされます．

◆ solvePnP()

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

3次元と2次元の点の対応関係から，物体の姿勢を求めます．この関数は，物体座標フレームで表現された3次元点をカメラ座標フレームに変換する回転ベクトルと並進ベクトルを，異なる手法で返します．

  • P3Pメソッド(SOLVEPNP_P3P,SOLVEPNP_AP3P): 一意の解を返すためには，4つの入力点が必要です．
  • SOLVEPNP_IPPE入力点は≧4でなければならず，物体点は同一平面上になければならない．
  • SOLVEPNP_IPPE_SQUAREマーカのポーズ推定に適した特殊なケース。入力点の数は4でなければならない。オブジェクトポイントは、以下の順序で定義する必要があります。
    • 点0: [-squareLength / 2, squareLength / 2, 0]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。
  • その他のフラグの場合、入力点の数は >= 4 でなければならず、オブジェクトポイントはどのような構成でもよい。
引数
objectPoints オブジェクト座標空間におけるオブジェクトポイントの配列，Nx3 1ch または 1xN/Nx1 3ch，ここで N はポイント数を表す．
imagePoints 対応する画像上の点の配列，Nx2 1ch または 1xN/Nx1 2ch，ここで N は点の数を表します．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvec 出力される回転ベクトル（以下のRodriguestvecと一緒に、モデル座標系からカメラ座標系へと点を移動させる。
tvec 並進ベクトルを出力します．
useExtrinsicGuess SOLVEPNP_ITERATIVEに使われるパラメータです。true (1) の場合、この関数は与えられた rvec と tvec の値をそれぞれ回転ベクトルと並進ベクトルの初期近似値として使用し、さらにそれらを最適化します。
flags PnP問題の解法。
  • SOLVEPNP_ITERATIVE 反復法は，Levenberg-Marquardt 最適化に基づいています。この場合，この関数は，再投影誤差を最小にするようなポーズを見つけます．これは，観測された投影物 imagePoints と，（使用して）投影された objectPoints との間の二乗距離の合計です．projectPoints) objectPoints .
  • SOLVEPNP_P3Pこの方法は、X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang "Complete Solution Classification for the Perspective-Three-Point Problem" ([gao2003complete]を参照してください。). この場合，この関数は，ちょうど4つのオブジェクトポイントと画像ポイントを必要とします．
  • SOLVEPNP_AP3Pこの方法は，T. Ke, S. Roumeliotisの論文 "An Efficient Algebraic Solution to the Perspective-Three-Point Problem"（邦題：パースペクティブ3点問題の効率的な代数的解決法）に基づいています．[Ke17].). この場合，この関数は，ちょうど4つのオブジェクトポイントと画像ポイントを必要とします．
  • SOLVEPNP_EPNPこの手法は、F. Moreno-Noguer, V. Lepetit, P. Fua による論文 "EPnP: Efficient Perspective-n-Point Camera Pose Estimation" ([LEPPIT2009EPNP］).
  • SOLVEPNP_DLS 壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
    この手法は、J. Hesch and S. Roumeliotisの論文に基づいています。"A Direct Least-Squares (DLS) Method for PnP" ([hesch2011direct]を参照してください。).
  • SOLVEPNP_UPNP 壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
    Method is based on the paper of A. Penate-Sanchez, J. Andrade-Cetto, F. Moreno-Noguer. "Exhaustive Linearization for Robust Camera Pose and Focal Length Estimation" ([penate2013exhaustive］). この場合，この関数は，パラメータ$f_x$および$f_y$を推定します．そして，推定された焦点距離で cameraMatrix が更新されます．
  • SOLVEPNP_IPPEこの方法は，T. Collins と A. Bartoli の論文に基づいています．"Infinitesimal Plane-Based Pose Estimation" ([Collins14]を参照してください。). この方法では、コプラナーなオブジェクトポイントが必要です。
  • SOLVEPNP_IPPE_SQUAREこの方法は、Toby CollinsとAdrien Bartoliの論文に基づいています。"Infinitesimal Plane-Based Pose Estimation（無限小平面ベースのポーズ推定）" ([Collins14]を参照してください。). この手法は、マーカーのポーズ推定に適しています。以下の順序で定義された4つのコプラナーオブジェクトポイントを必要とします。
    • 点0: [-squareLength / 2, squareLength / 2, 0]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。
  • SOLVEPNP_SQPNP Method is based on the paper "A Consistently Fast and Globally Optimal Solution to the Perspective-n-Point Problem" by G. Terzakis and M.Lourakis ([Tarzakis20]を参照してください。). 3つ以上の点を必要とします．

この関数は，物体の点の集合と，それに対応する画像投影，さらにカメラの固有行列と歪み係数が与えられた場合に，物体の姿勢を推定します（より正確には，カメラフレームのX軸が右向き，Y軸が下向き，Z軸が前向き）．

ワールドフレームで表現された点$ \bf{X}_w $ワールドフレームで表現された点は、透視投影モデルを用いて、画像平面に$ \left[ u, v \right] $透視投影モデル$ \Pi $とカメラ固有のパラメータ行列$ \bf{A} $:

\[ \begin{align*} \begin{bmatrix} u \\ v \\ 1 \end{bmatrix} &= \bf{A} \hspace{0.1em} \Pi \hspace{0.2em} ^{c}\bf{T}_w \begin{bmatrix} X_{w} \\ Y_{w} \\ Z_{w} \\ 1 \end{bmatrix} \\ \begin{bmatrix} u \\ v \\ 1 \end{bmatrix} &= \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \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} \end{align*} \]

これにより、推定されたポーズは、回転(rvec) および並進 (tvec)ベクトルであり，ワールドフレームで表現された3次元点をカメラフレームに変換することができる．

\[ \begin{align*} \begin{bmatrix} X_c \\ Y_c \\ Z_c \\ 1 \end{bmatrix} &= \hspace{0.2em} ^{c}\bf{T}_w \begin{bmatrix} X_{w} \\ Y_{w} \\ Z_{w} \\ 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} \end{align*} \]

覚え書き
  • 平面型拡張現実感に対する solvePnP の使用例は、opencv_source_code/samples/python/plane_ar.py にあります。
  • Pythonを使用している場合。
    • Numpy 配列スライスは入力として機能しません。なぜなら、solvePnP は連続した配列を必要とするからです。cv::Mat::checkVector()modules/calib3d/src/solvepnp.cpp version 2.4.9の55行目あたりで行われています。）
    • P3Pアルゴリズムでは、画像点が形状(N,1,2)の配列になっている必要があります。undistortPoints(modules/calib3d/src/solvepnp.cpp version 2.4.9の75行目付近)を呼び出すことで、2チャンネルの情報を必要とします。
    • したがって，あるデータ D = np.array(...) (D.shape = (N,M)) が与えられた場合，そのサブセットを例えば imagePoints として使用するためには，それを新しい配列にコピーする必要があります．
  • このメソッドはSOLVEPNP_DLSおよびSOLVEPNP_UPNPは，現在の実装が不安定で，ときにはまったく間違った結果を与えることがあるので，使用できません．この2つのフラグのどちらかを渡した場合SOLVEPNP_EPNPメソッドが代わりに使用されます。
  • 一般的なケースでは，最小のポイント数は4です．の場合はSOLVEPNP_P3PおよびSOLVEPNP_AP3Pメソッドの場合、正確に4点を使用する必要があります（最初の3点は、P3P問題のすべての解を推定するために使用され、最後の1点は、再投影誤差を最小にする最良の解を保持するために使用されます）。
  • SOLVEPNP_ITERATIVEメソッドとuseExtrinsicGuess=trueを使用した場合，最小点数は3である（ポーズを計算するには3点で十分だが，最大4つの解がある）．収束させるためには、初期解をグローバル解に近づける必要があります。
  • またSOLVEPNP_IPPEの場合，入力点は >= 4 でなければならず，物体点は同一平面上になければなりません．
  • またSOLVEPNP_IPPE_SQUAREこれは、マーカーのポーズ推定に適した特殊なケースです。入力点の数は4でなければならない。物体点は以下の順序で定義しなければならない。
    • 点0: [-squareLength / 2, squareLength / 2, 0]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。

◆ solvePnPGeneric()

CV_EXPORTS_W 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点の対応関係から物体のポーズを見つけます．この関数は，入力点の数と選択された手法に応じて，可能性のあるすべての解のリストを返します（解とは，<回転ベクトル，並進ベクトル>のカップルです）．

  • 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]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。
  • 他のすべてのフラグの場合，入力点の数は >= 4 でなければならず，オブジェクトポイントはどのような構成でもよい．1つの解のみが返されます．
引数
objectPoints オブジェクト座標空間におけるオブジェクトポイントの配列，Nx3 1ch または 1xN/Nx1 3ch，ここで N はポイント数を表す．
imagePoints 対応する画像上の点の配列，Nx2 1ch または 1xN/Nx1 2ch，ここで N は点の数を表します．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvecs 出力回転ベクトルのベクトル（参照Rodriguesを参照）．これは， tvecs と共に，点をモデル座標系からカメラ座標系に移動させるものである．
tvecs 並進ベクトルの出力ベクトル．
useExtrinsicGuess SOLVEPNP_ITERATIVEに使われるパラメータです。true (1) の場合、この関数は与えられた rvec と tvec の値をそれぞれ回転ベクトルと並進ベクトルの初期近似値として使用し、さらにそれらを最適化します。
flags PnP問題の解法。
  • SOLVEPNP_ITERATIVE 反復法は，Levenberg-Marquardt 最適化に基づいています。この場合，この関数は，再投影誤差を最小にするようなポーズを見つけます．これは，観測された投影物 imagePoints と，（使用して）投影された objectPoints との間の二乗距離の合計です．projectPoints) objectPoints .
  • SOLVEPNP_P3Pこの方法は、X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang "Complete Solution Classification for the Perspective-Three-Point Problem" ([gao2003complete]を参照してください。). この場合，この関数は，ちょうど4つのオブジェクトポイントと画像ポイントを必要とします．
  • SOLVEPNP_AP3Pこの方法は，T. Ke, S. Roumeliotisの論文 "An Efficient Algebraic Solution to the Perspective-Three-Point Problem"（邦題：パースペクティブ3点問題の効率的な代数的解決法）に基づいています．[Ke17].). この場合，この関数は，ちょうど4つのオブジェクトポイントと画像ポイントを必要とします．
  • SOLVEPNP_EPNPこの手法は、F.Moreno-Noguer, V.Lepetit, P.Fuaの論文 "EPnP: Efficient Perspective-n-Point Camera Pose Estimation "で紹介されている([LEPPIT2009EPNP］).
  • SOLVEPNP_DLS 壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
    この方法は、Joel A. Hesch and Stergios I. Roumeliotisの論文に基づいています。Roumeliotis. 「A Direct Least-Squares (DLS) Method for PnP」([hesch2011direct]を参照してください。).
  • SOLVEPNP_UPNP 壊れた実装。このフラグを使用すると、EPnPにフォールバックします。
    Method is based on the paper of A.Penate-Sanchez, J.Andrade-Cetto, F.Moreno-Noguer. "Exhaustive Linearization for Robust Camera Pose and Focal Length Estimation" ([penate2013exhaustive］). この場合，この関数は，パラメータ$f_x$および$f_y$を推定します．そして，推定された焦点距離で cameraMatrix が更新されます．
  • SOLVEPNP_IPPEこの方法は，T. Collins と A. Bartoli の論文に基づいています．"Infinitesimal Plane-Based Pose Estimation" ([Collins14]を参照してください。). この方法では、コプラナーなオブジェクトポイントが必要です。
  • SOLVEPNP_IPPE_SQUAREこの方法は、Toby CollinsとAdrien Bartoliの論文に基づいています。"Infinitesimal Plane-Based Pose Estimation（無限小平面ベースのポーズ推定）" ([Collins14]を参照してください。). この手法は、マーカーのポーズ推定に適しています。以下の順序で定義された4つのコプラナーオブジェクトポイントを必要とします。
    • 点0: [-squareLength / 2, squareLength / 2, 0]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。
rvec flag が SOLVEPNP_ITERATIVE で useExtrinsicGuess が true に設定されている場合に、反復 PnP 精製アルゴリズムを初期化するために使用される回転ベクトル。
tvec flag が SOLVEPNP_ITERATIVE で useExtrinsicGuess が true に設定されている場合に、 反復 PnP 精製アルゴリズムの初期化に使用される Translation ベクトル。
reprojectionError オプションで，再投影誤差のベクトルを指定します．$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $) であり，これは，入力画像の点と，推定された姿勢で投影された3次元物体の点との間のRMS誤差(

この関数は，物体の点の集合と，それに対応する画像投影，さらにカメラの固有行列と歪み係数が与えられた場合に，物体の姿勢を推定します（より正確には，カメラフレームのX軸が右向き，Y軸が下向き，Z軸が前向き）．

ワールドフレームで表現された点$ \bf{X}_w $ワールドフレームで表現された点は、透視投影モデルを用いて、画像平面に$ \left[ u, v \right] $透視投影モデル$ \Pi $とカメラ固有のパラメータ行列$ \bf{A} $:

\[ \begin{align*} \begin{bmatrix} u \\ v \\ 1 \end{bmatrix} &= \bf{A} \hspace{0.1em} \Pi \hspace{0.2em} ^{c}\bf{T}_w \begin{bmatrix} X_{w} \\ Y_{w} \\ Z_{w} \\ 1 \end{bmatrix} \\ \begin{bmatrix} u \\ v \\ 1 \end{bmatrix} &= \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \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} \end{align*} \]

これにより、推定されたポーズは、回転(rvec) および並進 (tvec)ベクトルであり，ワールドフレームで表現された3次元点をカメラフレームに変換することができる．

\[ \begin{align*} \begin{bmatrix} X_c \\ Y_c \\ Z_c \\ 1 \end{bmatrix} &= \hspace{0.2em} ^{c}\bf{T}_w \begin{bmatrix} X_{w} \\ Y_{w} \\ Z_{w} \\ 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} \end{align*} \]

覚え書き
  • 平面型拡張現実感に対する solvePnP の使用例は、opencv_source_code/samples/python/plane_ar.py にあります。
  • Pythonを使用している場合。
    • Numpy 配列スライスは入力として機能しません。なぜなら、solvePnP は連続した配列を必要とするからです。cv::Mat::checkVector()modules/calib3d/src/solvepnp.cpp version 2.4.9の55行目あたりで行われています。）
    • P3Pアルゴリズムでは、画像点が形状(N,1,2)の配列になっている必要があります。undistortPoints(modules/calib3d/src/solvepnp.cpp version 2.4.9の75行目付近)を呼び出すことで、2チャンネルの情報を必要とします。
    • したがって，あるデータ D = np.array(...) (D.shape = (N,M)) が与えられた場合，そのサブセットを例えば imagePoints として使用するためには，それを新しい配列にコピーする必要があります．
  • このメソッドはSOLVEPNP_DLSおよびSOLVEPNP_UPNPは，現在の実装が不安定で，ときにはまったく間違った結果を与えることがあるので，使用できません．この2つのフラグのどちらかを渡した場合SOLVEPNP_EPNPメソッドが代わりに使用されます。
  • 一般的なケースでは，最小のポイント数は4です．の場合はSOLVEPNP_P3PおよびSOLVEPNP_AP3Pメソッドの場合、正確に4点を使用する必要があります（最初の3点は、P3P問題のすべての解を推定するために使用され、最後の1点は、再投影誤差を最小にする最良の解を保持するために使用されます）。
  • SOLVEPNP_ITERATIVEメソッドとuseExtrinsicGuess=trueを使用した場合，最小点数は3である（ポーズを計算するには3点で十分だが，最大4つの解がある）．収束させるためには、初期解をグローバル解に近づける必要があります。
  • またSOLVEPNP_IPPEの場合，入力点は >= 4 でなければならず，物体点は同一平面上になければなりません．
  • またSOLVEPNP_IPPE_SQUAREこれは、マーカーのポーズ推定に適した特殊なケースです。入力点の数は4でなければならない。物体点は以下の順序で定義しなければならない。
    • 点0: [-squareLength / 2, squareLength / 2, 0]。
    • point 1: [ squareLength / 2, squareLength / 2, 0]である。
    • ポイント2：[ squareLength / 2, -squareLength / 2, 0]の順になります。
    • 点3：［-squareLength / 2, -squareLength / 2, 0］。

◆ solvePnPRansac()

CV_EXPORTS_W 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 点の対応関係から物体のポーズを求めます．

引数
objectPoints オブジェクト座標空間におけるオブジェクトポイントの配列，Nx3 1ch または 1xN/Nx1 3ch，ここで N はポイント数を表す．
imagePoints 対応する画像上の点の配列，Nx2 1ch または 1xN/Nx1 2ch，ここで N は点の数を表します．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvec 出力される回転ベクトル（以下のRodriguestvecと一緒に、モデル座標系からカメラ座標系へと点を移動させる。
tvec 並進ベクトルを出力します．
useExtrinsicGuess SOLVEPNP_ITERATIVE で利用されるパラメータ．真（1）の場合，この関数は，与えられた rvec と tvec の値を，それぞれ回転ベクトルと並進ベクトルの初期近似値として利用し，さらにそれらを最適化します．
iterationsCount イタレーションの回数．
reprojectionError RANSAC手順で使用されるインライアの閾値．このパラメータ値は，観測された点の投影と計算された点の投影の間で，それをインライアとみなすために許容される最大の距離です．
confidence アルゴリズムが有用な結果を生成する確率．
inliers objectPoints と imagePoints に含まれるインライアのインデックスを含む出力ベクトル．
flags PnP問題を解くための手法（参照solvePnP).

この関数は，オブジェクトポイントの集合と，それに対応する画像投影，さらにカメラの固有行列と歪み係数が与えられた場合に，オブジェクトのポーズを推定します．この関数は，再投影誤差，つまり，観測された投影像 imagePoints と，投影された（次の方法で）objectPoints との間の二乗距離の総和を最小にするようなポーズを求めます．projectPointsを用いて）投影されたobjectPoints間の二乗距離の合計です．RANSAC を用いることで，この関数は外れ値に強くなります．

覚え書き
  • オブジェクト検出のための solvePNPRansac の使用例は， opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/ にあります．
  • Minimal Sample Sets ステップでカメラのポーズを推定するために使用されるデフォルトの方法はSOLVEPNP_EPNP. 例外があります。
    • を選択した場合SOLVEPNP_P3PまたはSOLVEPNP_AP3Pを選択した場合、これらの方法が使用されます。
    • を選択した場合は、入力点の数が4に等しい場合に使用されます。SOLVEPNP_P3Pが使われます。
  • に等しくない限り，すべてのインライアを用いてカメラの姿勢を推定するために用いられる手法は，フラグパラメータによって定義されます．SOLVEPNP_P3PまたはSOLVEPNP_AP3P. この場合は，代わりにメソッドSOLVEPNP_EPNPが代わりに使用されます。

◆ solvePnPRefineLM()

CV_EXPORTS_W 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点をカメラ座標フレームに変換する移動と回転）を絞り込む。

引数
objectPoints オブジェクト座標空間におけるオブジェクトポイントの配列，Nx3 1ch または 1xN/Nx1 3ch（Nはポイント数）．
imagePoints 対応する画像上の点の配列，Nx2 1ch または 1xN/Nx1 2ch （N は点の数）．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvec 入出力される回転ベクトル（参照Rodrigues)は，tvecと一緒に，点をモデル座標系からカメラ座標系に移動させます．入力値は、初期解として使用されます。
tvec 入力/出力の並進ベクトル。入力値は初期解として使用されます。
criteria Levenberg-Marquard 反復アルゴリズムをいつ停止するかの基準．

この関数は，少なくとも3つの物体点と，それらに対応する画像投影点，回転ベクトルと並進ベクトルの初期解，そしてカメラの固有行列と歪み係数が与えられた場合に，物体の姿勢を修正します．この関数は，Levenberg-Marquardtの反復最小化法に従って，回転ベクトルと並進ベクトルに対する投影誤差を最小化します．[Madsen04] 。 [Eade13] 。プロセスを用いています。

◆ solvePnPRefineVVS()

CV_EXPORTS_W 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点をカメラ座標フレームに変換する移動と回転）を絞り込む。

引数
objectPoints オブジェクト座標空間におけるオブジェクトポイントの配列，Nx3 1ch または 1xN/Nx1 3ch（Nはポイント数）．
imagePoints 対応する画像上の点の配列，Nx2 1ch または 1xN/Nx1 2ch （N は点の数）．
cameraMatrix 入力されるカメラ固有の行列$\cameramatrix{A}$.
distCoeffs 入力 歪み係数のベクトル$\distcoeffs$. このベクトルが NULL/空の場合，歪み係数が 0 であると仮定されます．
rvec 入出力される回転ベクトル（参照Rodrigues)は，tvecと一緒に，点をモデル座標系からカメラ座標系に移動させます．入力値は、初期解として使用されます。
tvec 入力/出力の並進ベクトル。入力値は初期解として使用されます。
criteria Levenberg-Marquard 反復アルゴリズムをいつ停止するかの基準．
VVSlambda 仮想視覚サーボ制御則のゲイン。$\alpha$Damped Gauss-Newton 方式のゲインに相当します．

この関数は，少なくとも3つの物体点と，それらに対応する画像投影，回転ベクトルと並進ベクトルの初期解，さらにカメラの固有行列と歪み係数が与えられた場合に，物体の姿勢を修正します．この関数は，仮想ビジュアルサーボ（VVS）を用いて，回転ベクトルと並進ベクトルに対する投影誤差を最小化します．[Chaumette06] 。 [Marchand16］スキームを利用しています．

◆ stereoRectify()

CV_EXPORTS_W 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(),
CV_OUT Rect * validPixROI1 = 0,
CV_OUT Rect * validPixROI2 = 0
)

キャリブレーションされたステレオカメラの各ヘッドに対して，平行化変換を計算します．

引数
cameraMatrix1 1台目のカメラの固有マトリクス．
distCoeffs1 第1カメラの歪みパラメータ．
cameraMatrix2 第2カメラの固有マトリクス．
distCoeffs2 第二カメラの歪みパラメータ
imageSize ステレオキャリブレーションに使われる画像のサイズ．
R 第一カメラの座標系から第二カメラへの回転行列（参照stereoCalibrate.
T 1 台目のカメラの座標系から 2 台目のカメラへの並進ベクトル（参照stereoCalibrate.
R1 1台目のカメラに対する3x3の平行化変換（回転行列）を出力。この行列は，補正されていない第1のカメラの座標系で与えられた点を，補正された第1のカメラの座標系で与えられた点に変換するものである．専門的に言えば、修正されていない第1カメラの座標系から修正された第1カメラの座標系への基底変更を行います。
R2 2台目のカメラに対する3x3の平行化変換（回転行列）を出力．この行列は、補正されていない2台目のカメラの座標系で与えられた点を、補正された2台目のカメラの座標系の点にするものです。専門的に言えば、修正されていない2台目のカメラの座標系から、修正された2台目のカメラの座標系への基底変更を行います。
P1 1台目のカメラの新しい（平行化された）座標系に3x4の射影行列を出力する。つまり、平行化された1台目のカメラの座標系で与えられた点を、平行化された1台目のカメラの画像に投影する。
P2 2台目のカメラの新しい（平行化された）座標系に3x4の射影行列を出力．すなわち，平行化された1台目のカメラの座標系で与えられた点を平行化された2台目のカメラの画像に射影する．
Q 出力$4 \times 4$視差-深度マッピング行列（以下を参照してください）．reprojectImageTo3D).
flags 操作フラグには，0または CALIB_ZERO_DISPARITY が指定されます．このフラグがセットされている場合，この関数は，各カメラの主点が，平行化されたビューにおいて同じピクセル座標になるようにします．また，このフラグが設定されていない場合でも，有用な画像領域を最大化するために，（エピポーララインの向きに応じて）水平または垂直方向に画像を移動させることができます．
alpha フリースケーリングパラメータ．これが-1または存在しない場合，この関数はデフォルトのスケーリングを行います．alpha=0 は，有効なピクセルのみが見えるように，平行化された画像がズームおよびシフトされることを意味します（平行化後に黒い部分がない）． alpha=1 は，カメラからのオリジナル画像のすべてのピクセルが平行化された画像に保持されるように，平行化された画像がデシメーションおよびシフトされることを意味します（ソース画像のピクセルは失われません）．中間的な値を設定すると、これら2つの極端なケースの中間的な結果が得られます。
newImageSize 整形後の新しい画像の解像度。には，同じサイズを渡す必要があります．initUndistortRectifyMap(には，同じサイズを渡す必要があります（OpenCV samples ディレクトリにある stereo_calib.cpp サンプルを参照してください）．(0,0) が渡された場合（デフォルト），それは元の imageSize に設定されます．より大きな値を設定することで，特に大きな放射状の歪みがある場合に，元の画像の詳細を保持することができます．
validPixROI1 オプションで，平行化された画像の内側に，すべてのピクセルが有効な矩形を出力します．alpha=0 の場合，ROI は画像全体をカバーします．そうでない場合は，より小さな領域となります（下図を参照してください）．
validPixROI2 オプションで，平行化された画像の内側に，すべてのピクセルが有効な矩形を出力します．alpha=0 の場合，ROI は画像全体をカバーします．そうでない場合は，より小さな領域となります（下図を参照してください）．

この関数は，各カメラの回転行列を計算し，両カメラの画像平面を（仮想的に）同一平面にします．その結果，すべてのエピポーラ線が平行になり，密なステレオ対応関係の問題が簡単になります．この関数は，次式で求められた行列を入力としますstereoCalibrateによって計算された行列を入力とします．出力として，2つの回転行列と，新しい座標への2つの投影行列が与えられます．この関数は，以下の2つのケースを区別します．

  • 水平ステレオ：1番目と2番目のカメラのビューが，主にX軸に沿って相対的に移動します（わずかな垂直方向の移動もあり得ます）．整形された画像では，左右のカメラの対応するエピポーラ線は水平で，同じ y 座標を持ちます．P1とP2は次のようになります。

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

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

    ここで$T_x$はカメラ間の水平方向のずれであり$cx_1=cx_2$CALIB_ZERO_DISPARITY が設定されている場合は、次のようになります。

  • 垂直方向のステレオ1台目のカメラと2台目のカメラの映像が、主に垂直方向に（おそらく水平方向にも少し）相対的にずれている場合。整形された画像のエピポーララインは垂直で，同じ x 座標を持ちます．P1とP2は次のようになります。

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

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

    ここで$T_y$は、カメラ間の垂直方向のずれと$cy_1=cy_2$CALIB_ZERO_DISPARITY が設定されている場合は、次のようになります。

ご覧のように、P1とP2の最初の3列は、事実上、新しい「平行化された」カメラ行列となります。この行列は，R1 と R2 と共にinitUndistortRectifyMapに渡し、各カメラの平行化マップを初期化します。

下の図は，stereo_calib.cpp のサンプルのスクリーンショットです．いくつかの赤い水平線が，対応する画像領域を通過しています．これは，画像がよく平行化されていることを意味しており，ほとんどのステレオ対応付けアルゴリズムがこれに依存しています．緑色の四角形は， roi1 と roi2 です．これらの内部は，すべて有効なピクセルであることがわかります．

image

◆ stereoRectifyUncalibrated()

CV_EXPORTS_W bool cv::stereoRectifyUncalibrated ( InputArray points1,
InputArray points2,
InputArray F,
Size imgSize,
OutputArray H1,
OutputArray H2,
double threshold = 5
)

キャリブレーションされていないステレオカメラに対して，平行化変換を計算します．

引数
points1 1枚目の画像における特徴点の配列．
points2 2枚目の画像における対応する点の配列．と同じフォーマットがサポートされています．findFundamentalMatと同じ形式がサポートされています．
F 入力基本行列．を使って，同じ点のペアのセットから計算することができます．findFundamentalMat.
imgSize 画像のサイズ．
H1 1枚目の画像に対する平行化ホモグラフィ行列の出力．
H2 2番目の画像に対する平行化ホモグラフィ行列の出力．
threshold 外れ値を除外するために用いられるオプションの閾値．このパラメータが0よりも大きい場合，エピポーラ幾何学に従わないすべての点のペア（つまり，次のような点）は，計算前に拒否されます．$|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}$を持つ点）は，ホモグラフィの計算に先立って除外されます．それ以外の場合は，すべての点がインライアであると見なされます．

この関数は，カメラの固有のパラメータや空間内の相対的な位置を知らずに，平行化変換を計算するため，"uncalibrated "という接尾辞が付きます．との関連したもう1つの違いは，この関数が出力するのはstereoRectifyとのもう1つの違いは，この関数が物体（3次元）空間における平行化変換ではなく，ホモグラフィ行列 H1 と H2 によって符号化された平面透視変換を出力することです．この関数は，以下のアルゴリズムを実装しています[Hartley99]を参照してください．.

覚え書き
このアルゴリズムは，カメラの本質的なパラメータを知る必要はありませんが，エピポーラ幾何学に大きく依存しています．したがって，カメラのレンズに大きな歪みがある場合は，基本行列を計算してこの関数を呼び出す前に，その歪みを補正した方が良いでしょう．例えば，ステレオカメラの各ヘッドの歪み係数は，次のようにして個別に推定することができます．calibrateCamera. を使って，画像を補正することができます．undistortを使って画像を補正したり，あるいは，点座標だけをundistortPoints.

◆ triangulatePoints()

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

この関数は，ステレオカメラによる観測結果を用いて，3 次元の点（同次座標）を再構成します．

引数
projMatr1 1台目のカメラの3x4投影行列．つまり，この行列は，世界座標系で与えられた3次元点を1枚目の画像に投影します．
projMatr2 2 台目のカメラの 3x4 投影行列．すなわち，この行列は，世界の座標系で与えられた 3D 点を 2 番目の画像に投影する．
projPoints1 1枚目の画像における特徴点の2xN配列．c++ バージョンの場合は，特徴点のベクトルや，サイズが 1xN または Nx1 の 2 チャンネル行列を指定することもできます．
projPoints2 2枚目の画像に含まれる特徴点の2xN配列．c++版の場合は，特徴点のベクトルや，サイズが1xNまたはNx1の2チャンネルの行列でもよい．
points4D 同次座標系で再構成された点の 4xN 個の配列．これらの点は，世界の座標系で返されます．
覚え書き
この関数が動作するためには，すべての入力データが float 型でなければならないことに注意してください．
の投影行列を用いた場合，返される点はstereoRectifyの射影行列が使われた場合，返される点は，最初のカメラの平行化された座標系で表されます．
参照
reprojectImageTo3D

◆ undistort()

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

レンズの歪みを補正するために，画像を変換します．

この関数は，半径方向と接線方向のレンズ歪みを補正するために，画像を変換します．

この関数は，単純に以下の組み合わせです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/空の場合は，歪み係数が 0 であると見なされます．
newCameraMatrix 歪み補正された画像のカメラ行列．デフォルトでは， cameraMatrix と同じですが，別の行列を利用して，結果を追加でスケーリングやシフトすることもできます．

◆ undistortPoints() [1/2]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

覚え書き
のデフォルトバージョンはundistortPointsのデフォルトバージョンは，歪んでいない点を計算するために，5回の繰り返しを行います．

◆ undistortPoints() [2/2]

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

観測された点の座標から，理想的な点の座標を計算します．

この関数は，以下のものと似ています．undistortおよびinitUndistortRectifyMapと似ていますが，ラスタ画像ではなく，疎な点の集合を操作します．また，この関数は，次のような逆変換を行いますprojectPoints. 3次元物体の場合は，その3次元座標を再構成しませんが，平面物体の場合は，適切なRが指定されていれば，平行移動ベクトルまで再構成します．

観測された各点の座標$(u, v)$この関数は，次のように計算します．

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

ここでアンディストートは，正規化された歪んだ点座標から，正規化された元の点座標を推定する近似的な反復アルゴリズムです（「正規化」とは，座標がカメラ行列に依存しないことを意味します）．

この関数は，ステレオカメラヘッドでも単眼カメラでも使用できます（R が空の場合）．

引数
src 観測された点座標，2xN/Nx2 1チャンネル または 1xN/Nx1 2チャンネル (CV_32FC2 または CV_64FC2) (または vector<Point2f> )．
dst 歪み補正と逆透視変換を行った理想的な点座標（1xN/Nx1 2ch または vector<Point2f> ）を出力します．行列 P が恒等式または省略された場合，dst には正規化された点座標が格納されます．
cameraMatrix カメラ行列$\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$.
distCoeffs 入力 歪み係数のベクトル$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])$の4、5、8、12、14個の要素を持つ。ベクトルが NULL/空の場合は，歪み係数が 0 であると見なされます．
R 物体空間における平行化変換（3x3 の行列）．で計算された R1 または R2 をここに渡すことができます．stereoRectifyをここに渡すことができます．行列が空の場合は，恒等変換が用いられます．
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}$. で計算された P1 または P2stereoRectifyがここに渡されます．この行列が空の場合は，恒等式の新しいカメラ行列が用いられます．

変数詳解

◆ criteria

InputArrayOfArrays InputArrayOfArrays InputOutputArray InputOutputArray InputOutputArray InputOutputArray Size InputOutputArray InputOutputArray OutputArray OutputArray OutputArray int TermCriteria cv::criteria
初期値．
= TermCriteria(
TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON) )
構築: doxygen 1.9.2