几何图像变换

详细说明

本节中的函数执行二维图像的各种几何变换。它们不改变图像内容，而是使像素网格变形并将此变形后的网格映射到目标图像。实际上，为了避免采样伪影，映射以相反的顺序进行，从目标到源。也就是说，对于目标图像的每个像素 \((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`，需要解决上述公式的两个主要问题

• 非现有像素的外推。类似于上一节中描述的滤波函数，对于某些 \((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[])
	通过三对对应点计算仿射变换矩阵。
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)
	通过四对对应点计算透视变换矩阵。
void	cv::getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
	以亚像素精度从图像中提取像素矩形。
Mat	cv::getRotationMatrix2D (Point2f center, double angle, double scale)
	计算二维旋转的仿射矩阵。
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)
	将图像重映射到极坐标或对数极坐标空间。

枚举类型文档 (Enumeration Type Documentation)

InterpolationFlags

枚举 cv::InterpolationFlags

#include <opencv2/imgproc.hpp>

插值算法

枚举值 (Enumerator)
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

枚举 cv::InterpolationMasks

#include <opencv2/imgproc.hpp>

枚举值 (Enumerator)
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

枚举 cv::WarpPolarMode

#include <opencv2/imgproc.hpp>

指定极坐标映射模式。

另请参阅

warpPolar

枚举值 (Enumerator)
WARP_POLAR_LINEAR  Python: cv.WARP_POLAR_LINEAR	将图像重新映射到/从极坐标空间。
WARP_POLAR_LOG  Python: cv.WARP_POLAR_LOG	将图像重新映射到/从半对数极坐标空间。

函数文档 (Function Documentation)

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）转换为更紧凑、更快的定点表示。第一个输出数组包含四舍五入的坐标，第二个数组（仅当 `nninterpolation=false` 时创建）包含插值表中的索引。
• \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。与上面相同，但原始映射存储在一个双通道矩阵中。
• 反向转换。显然，重建的浮点映射不会与原始映射完全相同。

参数

map1	类型为 CV_16SC2、CV_32FC1 或 CV_32FC2 的第一个输入映射。
map2	类型为 CV_16UC1、CV_32FC1 或无（如果 `map1` 为空矩阵）的第二个输入映射。
dstmap1	类型为 `dstmap1type` 且大小与 `src` 相同的第一个输出映射。
dstmap2	第二个输出映射。
dstmap1type	第一个输出映射的类型，应为 CV_16SC2、CV_32FC1 或 CV_32FC2。
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>

通过三对对应点计算仿射变换矩阵。

该函数计算仿射变换的 \(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>

通过四对对应点计算透视变换矩阵。

该函数计算透视变换的 \(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	图像,
		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)\]

其中非整数坐标处的像素值使用双线性插值检索。多通道图像的每个通道独立处理。图像应为单通道或三通道图像。虽然矩形的中心必须在图像内部，但矩形的部分可能在图像外部。

参数

图像	源图像。
patchSize	提取的补丁大小。
center	源图像中提取矩形中心的浮点坐标。中心必须在图像内部。
patch	提取的补丁，其大小为 `patchSize`，通道数与 `src` 相同。
patchType	提取像素的深度。默认情况下，它们与 `src` 具有相同的深度。

另请参阅

warpAffine, warpPerspective

getRotationMatrix2D()

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

内联

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

#include <opencv2/imgproc.hpp>

计算二维旋转的仿射矩阵。

该函数计算以下矩阵

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

将图像重映射到极坐标空间。

已弃用

此函数产生与 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>

将图像重映射到对数极坐标空间。

已弃用

此函数产生与 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 值，类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。有关将浮点表示转换为定点以提高速度的详细信息，请参阅 convertMaps。
map2	y 值的第二个映射，类型为 CV_16UC1、CV_32FC1 或无（如果 `map1` 是 (x,y) 点，则为空映射）。
interpolation	插值方法（参见 InterpolationFlags）。此函数不支持 INTER_AREA、INTER_LINEAR_EXACT 和 INTER_NEAREST_EXACT 方法。可以将额外标志 WARP_RELATIVE_MAP 与插值方法进行或运算（例如 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 派生的。如果您想调整 `src` 的大小以使其适合预先创建的 `dst`，您可以按如下方式调用函数

// 明确指定 dsize=dst.size()；fx 和 fy 将由此计算。
resize(src, dst, dst.size(), 0, 0, interpolation);

如果您想在每个方向上将图像缩小 2 倍，您可以按以下方式调用函数

// 指定 fx 和 fy，让函数计算目标图像大小。
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>

对图像应用仿射变换。

当设置了 WARP_INVERSE_MAP 标志时，函数 `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})\]

否则，转换首先使用 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>

对图像应用透视变换。

当设置了 WARP_INVERSE_MAP 标志时，函数 `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 )\]

否则，转换首先使用 `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} \]

线性与半对数映射

极坐标映射可以是线性的或半对数的。将 WarpPolarMode 之一添加到 flags 以指定极坐标映射模式。

线性是默认模式。

半对数映射模拟了人类的“中央凹”视觉，允许在视线（中央视觉）上具有非常高的视力，而外围视觉的视力较差。

dsize 选项

• 如果 dsize <= 0 中的两个值都为零（默认值），则目标图像将具有（几乎）与源边界圆相同的面积

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

• 如果只有 dsize.height <= 0，则目标图像面积将与边界圆面积成比例，但按 Kx * Kx 缩放

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

• 如果 dsize > 0 中的两个值都大于零，则目标图像将具有给定大小，因此边界圆的面积将缩放到 dsize。

反向映射

您可以将 WARP_INVERSE_MAP 添加到 flags 以获取反向映射

        // 直接变换
        warpPolar(src, lin_polar_img, Size(),center, maxRadius, flags); // 线性极坐标
        warpPolar(src, log_polar_img, Size(),center, maxRadius, flags + WARP_POLAR_LOG); // 半对数极坐标
        // 逆变换
        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 到 360 度，精度约为 0.3 度。
• 此函数使用 remap。由于当前的实现限制，输入和输出图像的大小应小于 32767x32767。

另请参阅

cv::remap