几何图像变换

详细描述

本节中的函数执行 2D 图像的各种几何变换。它们不会改变图像内容，而是对像素网格进行变形，并将此变形网格映射到目标图像。事实上，为了避免采样伪影，映射是以相反的顺序完成的，从目标到源。也就是说，对于目标图像的每个像素 $(x,y)$，函数计算源图像中对应“捐赠者”像素的坐标，并复制像素值

$$\mathtt{\text{dst}}(x,y)=\mathtt{\text{src}}(f_x(x,y),f_y(x,y))$$

当您指定正向映射 $⟨g_x,g_y⟩:\mathtt{\text{src}}\to \mathtt{\text{dst}}$ 时，OpenCV 函数首先计算相应的反向映射 $⟨f_x,f_y⟩:\mathtt{\text{dst}}\to \mathtt{\text{src}}$，然后使用上述公式。

从最通用的重新映射到最简单、最快的调整大小，几何变换的实际实现需要解决上述公式的两个主要问题

• 对不存在的像素进行外推。与上一节中描述的滤波函数类似，对于某些 $(x,y)$，$f_x(x,y)$ 或 $f_y(x,y)$ 之一或两者都可能落在图像之外。在这种情况下，需要使用外推方法。OpenCV 提供与滤波函数相同的各种外推方法选择。此外，它提供了 BORDER_TRANSPARENT 方法。这意味着目标图像中相应的像素将完全不会被修改。
• 像素值的插值。通常 $f_x(x,y)$ 和 $f_y(x,y)$ 是浮点数。这意味着 $⟨f_x,f_y⟩$ 可以是仿射或透视变换，也可以是径向镜头畸变校正等。因此，需要检索分数坐标处的像素值。在最简单的情况下，坐标可以简单地舍入到最接近的整数坐标，并使用相应的像素。这称为最近邻插值。但是，通过使用更复杂的 插值方法，可以获得更好的结果，其中一个多项式函数拟合到计算出的像素 $(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)
	计算 2D 旋转的仿射矩阵。
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 ,\varphi )=src(x,y)$ 标记已设置：$dst(x,y)=src(\rho ,\varphi )$
WARP_RELATIVE_MAP  Python: cv.WARP_RELATIVE_MAP

InterpolationMasks

枚举 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

枚举 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>

将图像变换映射从一种表示转换为另一种表示。

该函数将用于重新映射的一对映射从一种表示转换为另一种表示。支持以下选项（(map1.type(), map2.type()) $\to$ (dstmap1.type(), dstmap2.type())）：

• $\mathtt{\text{(CV\_32FC1, CV\_32FC1)}}\to \mathtt{\text{(CV\_16SC2, CV\_16UC1)}}$。这是最常用的转换操作，其中原始浮点映射（参见 remap）被转换为更紧凑且更快的定点表示。第一个输出数组包含舍入的坐标，第二个数组（仅在 nninterpolation=false 时创建）包含插值表中的索引。
• $\mathtt{\text{(CV\_32FC2)}}\to \mathtt{\text{(CV\_16SC2, CV\_16UC1)}}$。与上面相同，但原始映射存储在一个 2 通道矩阵中。
• 反向转换。显然，重建的浮点映射将不会与原始映射完全相同。

参数

map1	第一个输入映射，类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。
map2	第二个输入映射，类型为 CV_16UC1、CV_32FC1 或无（空矩阵），分别。
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$ 矩阵，以便

$$\left[\begin{array}{c}{x}_i^{\prime }\\ y_i^{\prime }\end{array}\right]=\mathtt{\text{map\_matrix}}\cdot \left[\begin{array}{c}{x}_i\\ y_i\\ 1\end{array}\right]$$

其中

$$dst(i)=(x_i^{\prime },y_i^{\prime }),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$ 矩阵，以便

$$\left[\begin{array}{c}{t}_i{x}_i^{\prime }\\ t_i{y}_i^{\prime }\\ t_i\end{array}\right]=\mathtt{\text{map\_matrix}}\cdot \left[\begin{array}{c}{x}_i\\ y_i\\ 1\end{array}\right]$$

其中

$$dst(i)=(x_i^{\prime },y_i^{\prime }),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>

以亚像素精度从图像中检索像素矩形。

该函数从 src 中提取像素

$$patch(x,y)=src(x+\mathtt{\text{center.x}}-(\mathtt{\text{dst.cols}}-1)\ast 0.5,y+\mathtt{\text{center.y}}-(\mathtt{\text{dst.rows}}-1)\ast 0.5)$$

其中非整数坐标处的像素值使用双线性插值获取。多通道图像的每个通道都独立处理。另外，图像应该是单通道或三通道图像。虽然矩形的中心必须位于图像内部，但矩形的部分可能位于外部。

参数

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>

计算 2D 旋转的仿射矩阵。

该函数计算以下矩阵

$$\left[\begin{array}{ccc}\alpha & \beta & (1-\alpha )\cdot \mathtt{\text{center.x}}-\beta \cdot \mathtt{\text{center.y}}\\ -\beta & \alpha & \beta \cdot \mathtt{\text{center.x}}+(1-\alpha )\cdot \mathtt{\text{center.y}}\end{array}\right]$$

其中

$$\begin{array}{l}\alpha =\mathtt{\text{scale}}\cdot \cos \mathtt{\text{angle}},\\ \beta =\mathtt{\text{scale}}\cdot \sin \mathtt{\text{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表示的逆仿射变换

$$\left[\begin{array}{ccc}{a}_{11}& a_{12}& b_1\\ a_{21}& a_{22}& b_2\end{array}\right]$$

结果也是与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>

将通用几何变换应用于图像。

该函数使用指定的映射变换源图像

$$\mathtt{\text{dst}}(x,y)=\mathtt{\text{src}}(ma{p}_x(x,y),ma{p}_y(x,y))$$

$$\mathtt{\text{dst}}(x,y)=\mathtt{\text{src}}(x+ma{p}_x(x,y),y+ma{p}_y(x,y))$$

使用WARP_RELATIVE_MAP

其中具有非整数坐标的像素的值使用可用的插值方法之一计算。$ma{p}_x$和$ma{p}_y$可以分别编码为$ma{p}_1$和$ma{p}_2$中的单独浮点映射，或者交织的$ma{p}_1$中的$(x,y)$浮点映射，或者通过使用convertMaps创建的定点映射。您可能希望从浮点转换为定点映射表示的原因是它们可以产生更快的（2x）重新映射操作。在转换后的情况下，$ma{p}_1$包含对（cvFloor(x), cvFloor(y)），$ma{p}_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），则它被计算为 $$\mathtt{\text{dsize = Size(round(fx*src.cols), round(fy*src.rows))}}$$ dsize或fx和fy必须不为零。
fx	水平轴上的缩放因子；当它等于0时，它被计算为 $$\mathtt{\text{(double)dsize.width/src.cols}}$$
fy	垂直轴上的缩放因子；当它等于0时，它被计算为 $$\mathtt{\text{(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使用指定的矩阵变换源图像

$$\mathtt{\text{dst}}(x,y)=\mathtt{\text{src}}({\mathtt{\text{M}}}_{11}x+{\mathtt{\text{M}}}_{12}y+{\mathtt{\text{M}}}_{13},{\mathtt{\text{M}}}_{21}x+{\mathtt{\text{M}}}_{22}y+{\mathtt{\text{M}}}_{23})$$

当标志WARP_INVERSE_MAP被设置时。否则，变换将首先使用invertAffineTransform进行反转，然后在上面的公式中代替M。该函数不能就地操作。

参数

src	输入图像。
dst	具有大小dsize的输出图像，与src具有相同的类型。
M	$2\times 3$变换矩阵。
dsize	输出图像的大小。
flags	插值方法的组合（参见InterpolationFlags）以及可选标志WARP_INVERSE_MAP，表示M是逆变换（$\mathtt{\text{dst}}\to \mathtt{\text{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使用指定的矩阵变换源图像

$$\mathtt{\text{dst}}(x,y)=\mathtt{\text{src}}(\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}})$$

当标志WARP_INVERSE_MAP被设置时。否则，变换将首先使用invert进行反转，然后在上面的公式中代替M。该函数不能就地操作。

参数

src	输入图像。
dst	具有大小dsize的输出图像，与src具有相同的类型。
M	$3\times 3$变换矩阵。
dsize	输出图像的大小。
flags	插值方法的组合（INTER_LINEAR或INTER_NEAREST）以及可选标志WARP_INVERSE_MAP，它将M设置为逆变换（$\mathtt{\text{dst}}\to \mathtt{\text{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 ,\varphi )=src(x,y)$$

其中

$$\begin{array}{l}\overrightarrow{I}=(x-center.x,y-center.y)\\ \varphi =Kangle\cdot \mathtt{\text{angle}}(\overrightarrow{I})\\ \rho =\{\begin{array}{cc}Klin\cdot \mathtt{\text{magnitude}}(\overrightarrow{I})& default\\ Klog\cdot lo{g}_e(\mathtt{\text{magnitude}}(\overrightarrow{I}))& ifsemilog\end{array}\end{array}$$

和

$$\begin{array}{l}Kangle=dsize.height/2\mathrm{\Pi }\\ Klin=dsize.width/maxRadius\\ Klog=dsize.width/lo{g}_e(maxRadius)\end{array}$$

线性与半对数映射

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

线性是默认模式。

半对数映射模拟人类的“中央凹”视觉，这种视觉在视线（中央视觉）上具有非常高的视敏度，而外围视觉的视敏度则较低。

关于 dsize 的选项

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

  $$\begin{array}{l}dsize.area\leftarrow (maxRadiu{s}^2\cdot \mathrm{\Pi })\\ dsize.width=\mathtt{\text{cvRound}}(maxRadius)\\ dsize.height=\mathtt{\text{cvRound}}(maxRadius\cdot \mathrm{\Pi })\end{array}$$

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

  $$\begin{array}{l}dsize.height=\mathtt{\text{cvRound}}(dsize.width\cdot \mathrm{\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