幾何学的画像変換

詳細説明

このセクションの関数は2D画像に対してさまざまな幾何学的変換を行う。これらは画像の内容を変更しないが、ピクセルグリッドを変形させ、その変形したグリッドをデスティネーション画像にマッピングする。実際には、サンプリングのアーティファクトを避けるため、マッピングは逆順、すなわちデスティネーションからソースへの順で行われる。つまり、デスティネーション画像の各ピクセル \((x, y)\) について、関数はソース画像内の対応する「ドナー」ピクセルの座標を計算し、そのピクセル値をコピーする:

\[\texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))\]

順方向マッピング \(\left<g_x, g_y\right>: \texttt{src} \rightarrow \texttt{dst}\) を指定した場合、OpenCV の関数はまず対応する逆マッピング \(\left<f_x, f_y\right>: \texttt{dst} \rightarrow \texttt{src}\) を計算し、その後で上記の式を使用する。

幾何学的変換の実際の実装は、最も汎用的な remap から最も単純で最も高速な resize まで、上記の式に関する2つの主要な問題を解決する必要がある:

• 存在しないピクセルの外挿。前のセクションで説明したフィルタリング関数と同様に、ある \((x,y)\) について、\(f_x(x,y)\) または \(f_y(x,y)\) のいずれか、あるいはその両方が画像の外に落ちる場合がある。この場合、外挿方法を使用する必要がある。OpenCV はフィルタリング関数と同じ外挿方法の選択肢を提供する。さらに、BORDER_TRANSPARENT という方法も提供する。これはデスティネーション画像の対応するピクセルがまったく変更されないことを意味する。
• ピクセル値の補間。通常 \(f_x(x,y)\) と \(f_y(x,y)\) は浮動小数点数である。これは \(\left<f_x, f_y\right>\) がアフィン変換または透視変換、あるいは放射状のレンズ歪み補正などになりうることを意味する。そのため、小数座標におけるピクセル値を取得する必要がある。最も単純な場合、座標を最も近い整数座標に丸めて、対応するピクセルを使用できる。これは最近傍補間と呼ばれる。しかし、より洗練された 補間方法 を使用することでより良い結果が得られる。この方法では、計算されたピクセル \((f_x(x,y), f_y(x,y))\) のある近傍に多項式関数を当てはめ、\((f_x(x,y), f_y(x,y))\) における多項式の値を補間されたピクセル値とする。OpenCV では複数の補間方法から選択できる。詳細は resize を参照。

覚え書き

幾何学的変換は CV_8S または CV_32S 画像では機能しない。

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

列挙型
enum	cv::InterpolationFlags {   cv::INTER_NEAREST = 0 ,   cv::INTER_LINEAR = 1 ,   cv::INTER_CUBIC = 2 ,   cv::INTER_AREA = 3 ,   cv::INTER_LANCZOS4 = 4 ,   cv::INTER_LINEAR_EXACT = 5 ,   cv::INTER_NEAREST_EXACT = 6 ,   cv::INTER_MAX = 7 ,   cv::WARP_FILL_OUTLIERS = 8 ,   cv::WARP_INVERSE_MAP = 16 ,   cv::WARP_RELATIVE_MAP = 32 }
	補間アルゴリズム 続き...
enum	cv::InterpolationMasks {   cv::INTER_BITS = 5 ,   cv::INTER_BITS2 = INTER_BITS * 2 ,   cv::INTER_TAB_SIZE = 1 << INTER_BITS ,   cv::INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE }
enum	cv::UndistortTypes {   cv::PROJ_SPHERICAL_ORTHO = 0 ,   cv::PROJ_SPHERICAL_EQRECT = 1 }
	cv::undistort モード 続き...
enum	cv::WarpPolarMode {   cv::WARP_POLAR_LINEAR = 0 ,   cv::WARP_POLAR_LOG = 256 }
	極座標マッピングモードを指定する。 続き...

関数
void	cv::convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false)
	画像変換マップをある表現から別の表現に変換する。
void	cv::getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
	画像からサブピクセル精度でピクセル矩形を取得する。
void	cv::initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)
	射影および逆整列変換マップを計算する。本質的には、これはプロジェクタ・カメラ対におけるプロジェクタ（「逆カメラ」）のステレオ整列に対応するための initUndistortRectifyMap の逆変換である。
void	cv::initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
	歪み補正および矯正変換マップを計算する。
float	cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
	広角向けの remap 用マップを初期化する
static float	cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha=0)
void	cv::remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
	画像に汎用的な幾何学的変換を適用する。
void	cv::resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	画像をリサイズする。
void	cv::undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
	レンズ歪みを補正するために画像を変換する。
void	cv::warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
	画像にアフィン変換を適用する。
void	cv::warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
	画像に透視変換を適用する。
void	cv::warpPolar (InputArray src, OutputArray dst, Size dsize, Point2f center, double maxRadius, int flags)
	画像を極座標または準対数極座標空間へ再マッピングする。

列挙型詳解

InterpolationFlags

enum cv::InterpolationFlags

#include <opencv2/imgproc.hpp>

補間アルゴリズム

列挙値
INTER_NEAREST  Python: cv.INTER_NEAREST	最近傍補間
INTER_LINEAR  Python: cv.INTER_LINEAR	双線形補間
INTER_CUBIC  Python: cv.INTER_CUBIC	バイキュービック補間
INTER_AREA  Python: cv.INTER_AREA	ピクセル領域の関係を用いたリサンプリング。モアレのない結果が得られるため、画像の縮小に適した方法である。ただし画像を拡大する場合は INTER_NEAREST 法と同様の結果になる。
INTER_LANCZOS4  Python: cv.INTER_LANCZOS4	8x8 近傍にわたる Lanczos 補間
INTER_LINEAR_EXACT  Python: cv.INTER_LINEAR_EXACT	ビット精度の双線形補間
INTER_NEAREST_EXACT  Python: cv.INTER_NEAREST_EXACT	ビット精度の最近傍補間。これは PIL, scikit-image, Matlab における最近傍法と同じ結果を生成する。
INTER_MAX  Python: cv.INTER_MAX	補間コード用のマスク
WARP_FILL_OUTLIERS  Python: cv.WARP_FILL_OUTLIERS	フラグ。デスティネーション画像のすべてのピクセルを埋める。そのうちのいくつかがソース画像の外れ値に対応する場合、それらはゼロに設定される
WARP_INVERSE_MAP  Python: cv.WARP_INVERSE_MAP	フラグ、逆変換
WARP_RELATIVE_MAP  Python: cv.WARP_RELATIVE_MAP

InterpolationMasks

enum cv::InterpolationMasks

#include <opencv2/imgproc.hpp>

列挙値
INTER_BITS  Python: cv.INTER_BITS
INTER_BITS2  Python: cv.INTER_BITS2
INTER_TAB_SIZE  Python: cv.INTER_TAB_SIZE
INTER_TAB_SIZE2  Python: cv.INTER_TAB_SIZE2

UndistortTypes

enum cv::UndistortTypes

#include <opencv2/imgproc.hpp>

cv::undistort モード

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

WarpPolarMode

enum cv::WarpPolarMode

#include <opencv2/imgproc.hpp>

極座標マッピングモードを指定する。

参照

warpPolar

列挙値
WARP_POLAR_LINEAR  Python: cv.WARP_POLAR_LINEAR	画像を極座標空間との間で再マッピングする。
WARP_POLAR_LOG  Python: cv.WARP_POLAR_LOG	画像を半対数極座標空間との間で再マッピングする。

関数詳解

convertMaps()

void cv::convertMaps	(	InputArray	map1,
		InputArray	map2,
		OutputArray	dstmap1,
		OutputArray	dstmap2,
		int	dstmap1type,
		bool	nninterpolation = false )

Python:
	cv.convertMaps(	map1, map2, dstmap1type[, dstmap1[, dstmap2[, nninterpolation]]]	) ->	dstmap1, dstmap2

#include <opencv2/imgproc.hpp>

画像変換マップをある表現形式から別の表現形式へ変換する。

この関数はremap用のマップのペアをある表現形式から別の表現形式へ変換する。次のオプション ( (map1.type(), map2.type()) \(\rightarrow\) (dstmap1.type(), dstmap2.type()) ) がサポートされている:

• \(\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。これは最も頻繁に使用される変換操作であり、元の浮動小数点マップ(remap を参照)を、よりコンパクトかつはるかに高速な固定小数点表現に変換する。1つ目の出力配列には丸められた座標が格納され、2つ目の配列(nninterpolation=false のときのみ作成される)には補間テーブル内のインデックスが格納される。
• \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。上と同じだが、元のマップが1つの2チャンネル行列に格納されている。
• 逆変換。当然ながら、再構成された浮動小数点マップは元のものと完全に同一にはならない。

引数

map1	型が CV_16SC2, CV_32FC1, または CV_32FC2 の1番目の入力マップ。
map2	それぞれ型が CV_16UC1, CV_32FC1, または none (空の行列) の2番目の入力マップ。
dstmap1	型が dstmap1type で src と同じサイズを持つ1番目の出力マップ。
dstmap2	2つ目の出力マップ。
dstmap1type	CV_16SC2, CV_32FC1, または CV_32FC2 とすべき1番目の出力マップの型。
nninterpolation	固定小数点マップを最近傍補間に用いるか、より複雑な補間に用いるかを示すフラグ。

参照

remap, undistort, initUndistortRectifyMap

getRectSubPix()

void cv::getRectSubPix	(	InputArray	image,
		Size	patchSize,
		Point2f	center,
		OutputArray	patch,
		int	patchType = -1 )

Python:
	cv.getRectSubPix(	image, patchSize, center[, patch[, patchType]]	) ->	patch

#include <opencv2/imgproc.hpp>

サブピクセル精度で画像からピクセルの矩形領域を取得する。

関数 getRectSubPix は src からピクセルを抽出する:

\[patch(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\]

非整数座標におけるピクセル値はバイリニア補間を用いて取得される。マルチチャンネル画像の各チャンネルは独立に処理される。また、画像はシングルチャンネルまたは3チャンネルでなければならない。矩形の中心は画像内になければならないが、矩形の一部は画像の外にあってもよい。

引数

image	入力画像。
patchSize	抽出するパッチのサイズ。
center	ソース画像内で抽出する矩形の中心の浮動小数点座標。中心は画像内になければならない。
patch	サイズが patchSize で src と同じチャンネル数を持つ、抽出されたパッチ。
patchType	抽出されるピクセルのビット深度。デフォルトでは src と同じビット深度を持つ。

参照

warpAffine, warpPerspective

initInverseRectificationMap()

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

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

#include <opencv2/imgproc.hpp>

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

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

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

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

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

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

ステレオ平行化されたプロジェクタ・カメラのペアの場合、この関数はプロジェクタに対して呼び出され、一方カメラのヘッドに対しては initUndistortRectifyMap が呼び出される。これは stereoRectify の後に行われ、その 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	オブジェクト空間における省略可能な平行化(rectification)変換(3x3行列)。stereoRectify で計算された R1 または R2 をここに渡すことができる。行列が空の場合は、恒等変換が仮定される。
newCameraMatrix	新しいカメラ行列 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\)。
size	歪んだ画像のサイズ。
m1type	1つ目の出力マップの型。CV_32FC1, CV_32FC2 または CV_16SC2 のいずれかを指定できる。convertMaps を参照。
map1	remap 用の1つ目の出力マップ。
map2	remap 用の2つ目の出力マップ。

initUndistortRectifyMap()

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

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

#include <opencv2/imgproc.hpp>

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

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

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

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

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

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

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

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

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

引数

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

initWideAngleProjMap() [1/2]

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

#include <opencv2/imgproc.hpp>

広角向けの remap 用マップを初期化する

initWideAngleProjMap() [2/2]

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

inlinestatic

#include <opencv2/imgproc.hpp>

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

remap()

void cv::remap	(	InputArray	src,
		OutputArray	dst,
		InputArray	map1,
		InputArray	map2,
		int	interpolation,
		int	borderMode = BORDER_CONSTANT,
		const Scalar &	borderValue = Scalar(),
		AlgorithmHint	hint = cv::ALGO_HINT_DEFAULT )

Python:
	cv.remap(	src, map1, map2, interpolation[, dst[, borderMode[, borderValue[, hint]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

画像に一般的な幾何変換を適用する。

関数 remap は、指定されたマップを使って元画像を変換する。

\[\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\]

WARP_RELATIVE_MAP フラグを指定した場合 :

\[\texttt{dst} (x,y) = \texttt{src} (x+map_x(x,y),y+map_y(x,y))\]

非整数座標のピクセル値は、利用可能な補間方法のいずれかを用いて計算される。\(map_x\) と \(map_y\) は、それぞれ \(map_1\) と \(map_2\) に別々の浮動小数点マップとして、あるいは \(map_1\) に \((x,y)\) をインターリーブした浮動小数点マップとして、あるいは convertMaps で作成した固定小数点マップとしてエンコードできる。マップの浮動小数点表現を固定小数点表現に変換したい理由は、リマップ操作を大幅に高速化できる(2倍)からである。変換後の場合、\(map_1\) はペア (cvFloor(x), cvFloor(y)) を含み、\(map_2\) は補間係数テーブル内のインデックスを含む。

この関数はインプレースでは動作できない。

引数

src	入力画像。
dst	デスティネーション画像。map1 と同じサイズを持ち、src と同じ型を持つ。
map1	(x,y) 点、または x 値のみの1番目のマップで、型は CV_16SC2 , CV_32FC1, または CV_32FC2。浮動小数点表現を高速化のために固定小数点へ変換する詳細については convertMaps を参照。
map2	y 値の2つ目のマップで、型はそれぞれ CV_16UC1、CV_32FC1、または none（map1 が (x,y) 点の場合は空のマップ）。
interpolation	補間方法 (InterpolationFlags を参照)。INTER_AREA INTER_LINEAR_EXACT および INTER_NEAREST_EXACT の各方法はこの関数ではサポートされていない。補間方法に追加フラグ WARP_RELATIVE_MAP をOR結合できる（例: INTER_LINEAR | WARP_RELATIVE_MAP）。
borderMode	ピクセルの外挿方法 (BorderTypes を参照)。borderMode=BORDER_TRANSPARENT の場合、ソース画像の「外れ値」に対応するデスティネーション画像のピクセルがこの関数によって変更されないことを意味する。
borderValue	定数境界の場合に使われる値。デフォルトは 0。
hint	実装の動作変更フラグ。線形計算をより高速に行うために、FP16精度(利用可能な場合)を使用するには ALGO_HINT_APPROX を設定する。AlgorithmHint を参照。

覚え書き

現在の実装上の制約により、入力画像および出力画像のサイズは 32767x32767 未満でなければならない。

resize()

void cv::resize	(	InputArray	src,
		OutputArray	dst,
		Size	dsize,
		double	fx = 0,
		double	fy = 0,
		int	interpolation = INTER_LINEAR )

Python:
	cv.resize(	src, dsize[, dst[, fx[, fy[, interpolation]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

画像をリサイズする。

関数 resize は画像 src を指定したサイズへ縮小または拡大する。初期の dst の型やサイズは考慮されないことに注意する。代わりに、サイズと型は src,dsize,fx,fy から導出される。あらかじめ作成した dst に収まるように src をリサイズしたい場合は、次のように関数を呼び出せばよい:

// explicitly specify dsize=dst.size(); fx and fy will be computed from that.
resize(src, dst, dst.size(), 0, 0, interpolation);

各方向に係数2で画像を間引きたい場合は、次のように関数を呼び出せばよい。

// specify fx and fy and let the function compute the destination image size.
resize(src, dst, Size(), 0.5, 0.5, interpolation);

画像を縮小する場合は一般に INTER_AREA 補間が最も見栄えがよく、画像を拡大する場合は一般に INTER_CUBIC (低速)または INTER_LINEAR (高速だが見栄えは十分)が最も見栄えがよい。

引数

src	入力画像。
dst	出力画像。サイズは dsize（非ゼロの場合）、または src.size(), fx, fy から計算されたサイズを持つ。dst の型は src と同じである。
dsize	出力画像のサイズ。ゼロ（Pythonでは None）に等しい場合、次のように計算される: \[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\] dsize、または fx と fy の両方のいずれかが非ゼロでなければならない。
fx	水平軸方向のスケール係数。0 の場合は次のように計算される \[\texttt{(double)dsize.width/src.cols}\]
fy	垂直軸方向のスケール係数。0 の場合は次のように計算される \[\texttt{(double)dsize.height/src.rows}\]
interpolation	補間方法。InterpolationFlags を参照

参照

warpAffine, warpPerspective, remap

undistort()

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

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

#include <opencv2/imgproc.hpp>

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

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

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

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

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

カメラ行列と歪み係数は calibrateCamera を用いて決定できる。画像の解像度がキャリブレーション時に使用した解像度と異なる場合は、\(f_x, f_y, c_x\) および \(c_y\) をそれに応じてスケーリングする必要があるが、歪み係数はそのままでよい。

引数

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

warpAffine()

void cv::warpAffine	(	InputArray	src,
		OutputArray	dst,
		InputArray	M,
		Size	dsize,
		int	flags = INTER_LINEAR,
		int	borderMode = BORDER_CONSTANT,
		const Scalar &	borderValue = Scalar(),
		AlgorithmHint	hint = cv::ALGO_HINT_DEFAULT )

Python:
	cv.warpAffine(	src, M, dsize[, dst[, flags[, borderMode[, borderValue[, hint]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

画像にアフィン変換を適用する。

関数 warpAffine は、指定された行列を使って元画像を変換する。

\[\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\]

フラグ WARP_INVERSE_MAP が設定されている場合。そうでない場合、変換はまず invertAffineTransform で反転され、その結果が上記の式中の M の代わりに用いられる。この関数はインプレースで動作できない。

引数

src	入力画像。
dst	サイズが dsize で src と同じ型を持つ出力画像。
M	\(2\times 3\) 変換行列。
dsize	出力画像のサイズ。
flags	補間方法 (InterpolationFlags を参照) と、省略可能なフラグ WARP_INVERSE_MAP の組み合わせ。後者は M が逆変換 ( \(\texttt{dst}\rightarrow\texttt{src}\) ) であることを意味する。
borderMode	ピクセルの外挿方法 (BorderTypes を参照)。borderMode=BORDER_TRANSPARENT の場合、ソース画像の「外れ値」に対応するデスティネーション画像のピクセルがこの関数によって変更されないことを意味する。
borderValue	定数境界の場合に使われる値。デフォルトは 0。
hint	実装の動作変更フラグ。線形計算をより高速に行うために、FP16精度(利用可能な場合)を使用するには ALGO_HINT_APPROX を設定する。AlgorithmHint を参照。

参照

warpPerspective, resize, remap, getRectSubPix, transform

warpPerspective()

void cv::warpPerspective	(	InputArray	src,
		OutputArray	dst,
		InputArray	M,
		Size	dsize,
		int	flags = INTER_LINEAR,
		int	borderMode = BORDER_CONSTANT,
		const Scalar &	borderValue = Scalar(),
		AlgorithmHint	hint = cv::ALGO_HINT_DEFAULT )

Python:
	cv.warpPerspective(	src, M, dsize[, dst[, flags[, borderMode[, borderValue[, hint]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

画像に透視変換を適用する。

関数 warpPerspective は、指定された行列を使って元画像を変換する。

\[\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\]

フラグ WARP_INVERSE_MAP が設定されている場合。そうでない場合、変換はまず invert で反転され、上記の式中の M の代わりに用いられる。この関数はインプレースでは動作できない。

引数

src	入力画像。
dst	サイズが dsize で src と同じ型を持つ出力画像。
M	\(3\times 3\) 変換行列。
dsize	出力画像のサイズ。
flags	補間方法 (INTER_LINEAR または INTER_NEAREST) と、省略可能なフラグ WARP_INVERSE_MAP の組み合わせ。後者は M を逆変換 ( \(\texttt{dst}\rightarrow\texttt{src}\) ) として設定する。
borderMode	ピクセル外挿方法（BORDER_CONSTANT または BORDER_REPLICATE）。
borderValue	定数境界の場合に使われる値。デフォルトは 0。
hint	実装の動作変更フラグ。線形計算をより高速に行うために、FP16精度(利用可能な場合)を使用するには ALGO_HINT_APPROX を設定する。AlgorithmHint を参照。

参照

warpAffine, resize, remap, getRectSubPix, perspectiveTransform

warpPolar()

void cv::warpPolar	(	InputArray	src,
		OutputArray	dst,
		Size	dsize,
		Point2f	center,
		double	maxRadius,
		int	flags )

Python:
	cv.warpPolar(	src, dsize, center, maxRadius, flags[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

画像を極座標またはセミログ極座標空間へリマップする。

次の変換を用いて元画像を変換する:

\[ dst(\rho , \phi ) = src(x,y) \]

ここで

\[ \begin{array}{l} \vec{I} = (x - center.x, \;y - center.y) \\ \phi = Kangle \cdot \texttt{angle} (\vec{I}) \\ \rho = \left\{\begin{matrix} Klin \cdot \texttt{magnitude} (\vec{I}) & default \\ Klog \cdot log_e(\texttt{magnitude} (\vec{I})) & if \; semilog \\ \end{matrix}\right. \end{array} \]

および

\[ \begin{array}{l} Kangle = dsize.height / 2\Pi \\ Klin = dsize.width / maxRadius \\ Klog = dsize.width / log_e(maxRadius) \\ \end{array} \]

Linear vs semilog mapping

極座標マッピングはリニアまたはセミログのいずれかにできる。極座標マッピングのモードを指定するには、WarpPolarMode のいずれかを flags に追加する。

リニアがデフォルトのモードである。

セミログマッピングは人間の「中心窩(fovea)」視覚を模したもので、周辺視野では視力が低いのに対し、視線方向(中心視野)では非常に高い視力が得られる。

Option on dsize:

• if both values in dsize <=0 (default), the destination image will have (almost) same area of source bounding circle:

  \[\begin{array}{l} dsize.area \leftarrow (maxRadius^2 \cdot \Pi) \\ dsize.width = \texttt{cvRound}(maxRadius) \\ dsize.height = \texttt{cvRound}(maxRadius \cdot \Pi) \\ \end{array}\]

• if only dsize.height <= 0, the destination image area will be proportional to the bounding circle area but scaled by Kx * Kx:

  \[\begin{array}{l} dsize.height = \texttt{cvRound}(dsize.width \cdot \Pi) \\ \end{array} \]

• dsize > 0 の両方の値が指定されている場合、出力画像は指定されたサイズになるため、外接円の領域は dsize にスケーリングされる。

Reverse mapping

WARP_INVERSE_MAP を flags に追加すると逆マッピングが得られる

 // direct transform using warpPolar (replacing deprecated functions)
 warpPolar(src, lin_polar_img, Size(),center, maxRadius, flags);                     // Linear-polar transform
 warpPolar(src, log_polar_img, Size(),center, maxRadius, flags + WARP_POLAR_LOG);    // Log-polar transform
 // inverse transform
 warpPolar(lin_polar_img, recovered_lin_polar_img, src.size(), center, maxRadius, flags + WARP_INVERSE_MAP);
 warpPolar(log_polar_img, recovered_log_polar, src.size(), center, maxRadius, flags + WARP_POLAR_LOG + WARP_INVERSE_MAP);

さらに、極座標にマッピングされた座標から元の座標を計算するには \((rho, phi)->(x, y)\):

 double angleRad, magnitude;
 double Kangle = dst.rows / CV_2PI;
        angleRad = phi / Kangle;
 if (flags & WARP_POLAR_LOG)
        {
 double Klog = dst.cols / std::log(maxRadius);
 magnitude = std::exp(rho / Klog);
        }
 else
        {
 double Klin = dst.cols / maxRadius;
 magnitude = rho / Klin;
        }
 int x = cvRound(center.x + magnitude * cos(angleRad));
 int y = cvRound(center.y + magnitude * sin(angleRad));

引数

src	入力画像。
dst	デスティネーション画像。src と同じ型を持つ。
dsize	デスティネーション画像のサイズ（有効なオプションについては説明を参照）。
center	変換の中心。
maxRadius	変換するバウンディング円の半径。これは逆数の倍率スケール引数も決定する。
flags	補間方法と InterpolationFlags + WarpPolarMode の組み合わせ。 線形極座標マッピング（デフォルト）を選択するには WARP_POLAR_LINEAR を追加する 半対数極座標マッピングを選択するには WARP_POLAR_LOG を追加する 逆マッピングには WARP_INVERSE_MAP を追加する。

覚え書き

• この関数はインプレースでは動作できない。
• 大きさと角度を度数で計算するために内部で cartToPolar が使われるため、角度は約0.3度の精度で0から360まで測定される。
• この関数は remap を使用する。現在の実装上の制限により、入力画像と出力画像のサイズは 32767x32767 未満でなければならない。

参照

cv::remap