幾何学的画像変換

詳細説明

このセクションの関数は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 画像では機能しない。

列挙型
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::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)
	画像変換マップをある表現から別の表現に変換する。
Mat	cv::getAffineTransform (const Point2f src[], const Point2f dst[])
	対応する3組の点からアフィン変換を計算する。
Mat	cv::getAffineTransform (InputArray src, InputArray dst)
Mat	cv::getPerspectiveTransform (const Point2f src[], const Point2f dst[], int solveMethod=DECOMP_LU)
Mat	cv::getPerspectiveTransform (InputArray src, InputArray dst, int solveMethod=DECOMP_LU)
	対応する4組の点から透視変換を計算する。
void	cv::getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
	画像からサブピクセル精度でピクセル矩形を取得する。
Mat	cv::getRotationMatrix2D (Point2f center, double angle, double scale)
	2次元回転のアフィン行列を計算する。
Matx23d	cv::getRotationMatrix2D_ (Point2f center, double angle, double scale)
void	cv::invertAffineTransform (InputArray M, OutputArray iM)
	アフィン変換を反転する。
void	cv::linearPolar (InputArray src, OutputArray dst, Point2f center, double maxRadius, int flags)
	画像を極座標空間へ再マッピングする。
void	cv::logPolar (InputArray src, OutputArray dst, Point2f center, double M, int flags)
	画像を準対数極座標空間へ再マッピングする。
void	cv::remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	画像に汎用的な幾何学的変換を適用する。
void	cv::resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	画像をリサイズする。
void	cv::warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	画像にアフィン変換を適用する。
void	cv::warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	画像に透視変換を適用する。
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	フラグ。逆変換 例えば linearPolar または logPolar 変換の場合: フラグが設定されていない場合: \(dst( \rho , \phi ) = src(x,y)\) フラグが設定されている場合: \(dst(x,y) = src( \rho , \phi )\)
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

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

getAffineTransform() [1/2]

Mat cv::getAffineTransform	(	const Point2f	src[],
		const Point2f	dst[] )

Python:
	cv.getAffineTransform(	src, dst	) ->	retval

#include <opencv2/imgproc.hpp>

対応する3組の点からアフィン変換を計算する。

この関数は次を満たすようにアフィン変換の \(2 \times 3\) 行列を計算する:

\[\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\]

ここで

\[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2\]

引数

src	ソース画像における三角形の頂点座標。
dst	デスティネーション画像における対応する三角形の頂点座標。

参照

warpAffine, transform

getAffineTransform() [2/2]

Mat cv::getAffineTransform	(	InputArray	src,
		InputArray	dst )

Python:
	cv.getAffineTransform(	src, dst	) ->	retval

#include <opencv2/imgproc.hpp>

getPerspectiveTransform() [1/2]

Mat cv::getPerspectiveTransform	(	const Point2f	src[],
		const Point2f	dst[],
		int	solveMethod = DECOMP_LU )

Python:
	cv.getPerspectiveTransform(	src, dst[, solveMethod]	) ->	retval

#include <opencv2/imgproc.hpp>

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

getPerspectiveTransform() [2/2]

Mat cv::getPerspectiveTransform	(	InputArray	src,
		InputArray	dst,
		int	solveMethod = DECOMP_LU )

Python:
	cv.getPerspectiveTransform(	src, dst[, solveMethod]	) ->	retval

#include <opencv2/imgproc.hpp>

対応する4組の点から透視変換を計算する。

この関数は次を満たすように透視変換の \(3 \times 3\) 行列を計算する:

\[\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\]

ここで

\[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\]

引数

src	ソース画像における四角形の頂点座標。
dst	デスティネーション画像における対応する四角形の頂点座標。
solveMethod	cv::solve に渡されるメソッド (DecompTypes)

参照

findHomography, warpPerspective, perspectiveTransform

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

getRotationMatrix2D()

Mat cv::getRotationMatrix2D ( Point2f center, double angle, double scale )

inline

Python:
	cv.getRotationMatrix2D(	center, angle, scale	) ->	retval

#include <opencv2/imgproc.hpp>

2次元回転のアフィン行列を計算する。

この関数は次の行列を計算する:

\[\begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} + (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}\]

ここで

\[\begin{array}{l} \alpha = \texttt{scale} \cdot \cos \texttt{angle} , \\ \beta = \texttt{scale} \cdot \sin \texttt{angle} \end{array}\]

この変換は回転中心をそれ自身に写す。これが目的でない場合は、シフト量を調整する。

引数

center	ソース画像における回転の中心。
angle	回転角度（度単位）。正の値は反時計回りの回転を意味する（座標原点は左上隅にあると仮定する）。
scale	等方的なスケール係数。

参照

getAffineTransform, warpAffine, transform

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

getRotationMatrix2D_()

Matx23d cv::getRotationMatrix2D_	(	Point2f	center,
		double	angle,
		double	scale )

#include <opencv2/imgproc.hpp>

参照

getRotationMatrix2D

invertAffineTransform()

void cv::invertAffineTransform	(	InputArray	M,
		OutputArray	iM )

Python:
	cv.invertAffineTransform(	M[, iM]	) ->	iM

#include <opencv2/imgproc.hpp>

アフィン変換を反転する。

この関数は \(2 \times 3\) 行列 M で表されるアフィン変換の逆変換を計算する:

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

結果も M と同じ型の \(2 \times 3\) 行列である。

引数

M	元のアフィン変換。
iM	出力される逆アフィン変換。

linearPolar()

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

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

#include <opencv2/imgproc.hpp>

画像を極座標空間へリマップする。

非推奨Deprecated

この関数は cv::warpPolar(src, dst, src.size(), center, maxRadius, flags) と同じ結果を生成する

logPolar()

void cv::logPolar	(	InputArray	src,
		OutputArray	dst,
		Point2f	center,
		double	M,
		int	flags )

Python:
	cv.logPolar(	src, center, M, flags[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

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

非推奨Deprecated

この関数は cv::warpPolar(src, dst, src.size(), center, maxRadius, flags+WARP_POLAR_LOG); と同じ結果を生成する

remap()

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

Python:
	cv.remap(	src, map1, map2, interpolation[, dst[, borderMode[, borderValue]]]	) ->	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。

覚え書き

現在の実装上の制約により、入力画像および出力画像のサイズは 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

warpAffine()

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

Python:
	cv.warpAffine(	src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]	) ->	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。

参照

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

Python:
	cv.warpPerspective(	src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]]	) ->	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。

参照

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
 warpPolar(src, lin_polar_img, Size(),center, maxRadius, flags);                     // linear Polar
 warpPolar(src, log_polar_img, Size(),center, maxRadius, flags + WARP_POLAR_LOG);    // semilog Polar
 // 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