Opencv图像几何变换

DataWhale 机器视觉组队学习task2

2.1 简介

  该部分将对基本的几何变换进行学习，几何变换的原理大多都是相似，只是变换矩阵不同，因此，我们以最常用的平移和旋转为例进行学习。在深度学习领域，我们常用平移、旋转、镜像等操作进行数据增广；在传统CV领域，由于某些拍摄角度的问题，我们需要对图像进行矫正处理，而几何变换正是这个处理过程的基础，因此了解和学习几何变换也是有必要的。

这次我们带着几个问题进行，以旋转为例：

• 1：变换的形式（公式）是什么？

• 2：旋转中心是什么？毕竟以不同位置为旋转中心得到的结果是不一样的。

• 3：采用前向映射还是反向映射？(反向映射更为有效)

• 4：采用反向映射后，采用何种插值算法？最常用的的是双线性插值，OpenCV也是默认如此。

2.2 学习目标

• 了解几何变换的概念与应用

• 理解平移、旋转的原理

• 掌握在OpenCV框架下实现平移、旋转操作

2.3 内容介绍

1、平移、旋转的原理

2、OpenCV代码实践

3、动手实践并打卡（读者完成）

2.4 算法理论介绍

2.4.1 向前映射与向后映射

前向映射：

  图像的几何变换就是建立一种源图像像素与变换后的图像像素之间的映射关系。也正是通过这种映射关系可以知道原图像任意像素点变换后的坐标，或者是变换后的图像在原图像的坐标位置等。

  用简单的数学公式可以表示为：

$$\begin{gathered} \left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{c}U(u,v)\\ V(u,v)\end{array}\right) \\ f(u,v)=(x,y) \end{gathered}$$

  其中，$x$,$y$代表输出图像像素的坐标，$u$,$v$表示输入图像的像素坐标，而$U$，$V$表示的是两种映射关系，$f$是将点$(u,v)$映射到$(x,y)$的映射关系，需要说明的是，映射关系可以是线性关系，也可以是多项式关系
  从上面的映射关系可以看到，只要给出了图像上任意的像素坐标，都能够通过对应的映射关系获得几何变换后的像素坐标。这种将输入映射到输出的过程我们称之为 “向前映射”。但是在实际应用中，向前映射会出现如下几个问题：

1. 浮点数坐标，如（1，1）映射为（0.5，0.5）,显然这是一个无效的坐标，这时我们需要使用插值算法进行进一步处理。

2. 可能会有多个像素坐标映射到输出图像的同一位置，也可能输出图像的某些位置完全没有相应的输入图像像素与它匹配，也就是没有被映射到，造成有规律的空洞（黑色的蜂窝状）。

什么是有规律的空洞呢？下面举个例子大家就明白了

  可以从上图知道：原图经过前向映射旋转了30度后，输出图像中有规律的空洞（黑色的蜂窝状），那这些空洞是这么来的呢？

  可以看到，旋转三十度后，输出图像两个红色的点被映射到同一个坐标，而没有点被映射到绿色问号处，这就造成了间隙和重叠，导致出现蜂窝状空洞。

向后映射

  为了克服前向映射的这些不足，因此引进了“后向映射”

它的数学表达式为：

$$\begin{gathered} \left(\begin{array}{c}u\\ v\end{array}\right)=\left(\begin{array}{c}{U}^{-1}(x,y)\\ V^{-1}(x,y)\end{array}\right) \\ {f}^{-1}(x,y)=(u,v) \end{gathered}$$

  可以看出，后向映射与前向映射刚好相反，它是由输出图像的像素坐标反过来推算该像素为在源图像中的坐标位置。这样，输出图像的每个像素值都能够通过这个映射关系找到对应的为止。而不会造成上面所提到的映射不完全和映射重叠的现象。在实际处理中基本上都运用向后映射来进行图像的几何变换。但是反向映射也有一个和前向映射一样的问题， 就是映射后会有小数，需通过插值方法决定输出图像该位置的值，OpenCV默认为双线性插值。

  在使用过程中，如果在一些不改变图像大小的几何变换中，向前映射还是十分有效的，向后映射主要运用在图像的旋转的缩放中，因为这些几何变换都会改变图像的大小。

2.4.1 几何变换

  先看第一个问题，变换的形式。在本篇文章里图像的几何变换全部都采用统一的矩阵表示法，形式如下：

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}{a}_0& a_1& a_2\\ a_3& a_4& a_5\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

  这就是向前映射的矩阵表示法，其中$x$，$y$表示输出图像像素的坐标，$x_0$,$y_0$表示输入图像像素的坐标，同理，向后映射的矩阵表示为：

$$\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]=\left[\begin{array}{ccc}{b}_0& b_1& b_2\\ b_3& b_4& b_5\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]$$

  可以证明，向后映射的矩阵的表示正好是向前映射的逆变换。

变换名称	$a_0$	$a_1$	$a_2$	$a_3$	$a_4$	$a_5$
平移	1	0	$△x$	0	1	$△y$
均匀缩放	$s$	0	0	0	$s$	0
不均匀缩放	$s_x$	0	0	0	$s_y$	0
顺时针旋转角度$\theta$	$cos\theta$	$sin\theta$	0	$-sin\theta$	$cos\theta$	0
逆时针旋转角度$\theta$	$cos\theta$	$-sin\theta$	0	$sin\theta$	$cos\theta$	0
垂直偏移变换	1	0	0	h	1	0
水平偏移变换	1	h	0	0	1	0

下面举几个例子
原图：

1. 向上平移一个单位向右平移一个单位

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}1& 0& 1\\ 0& 1& 1\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

2. 放大为原来的两倍

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}2& 0& 0\\ 0& 2& 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

3. 顺时针旋转45度

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}\sqrt{2}/2& \sqrt{2}/2& 0\\ -\sqrt{2}/2& \sqrt{2}/2& 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

4. 水平偏移2个单位

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}1& 2& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

2.4.2坐标系变换

  再看第二个问题，变换中心，对于缩放、平移可以以图像坐标原点（图像左上角为原点）为中心变换，这不用坐标系变换，直接按照一般形式计算即可。而对于旋转和偏移，一般是以图像中心为原点，那么这就涉及坐标系转换了。

  我们都知道，图像坐标的原点在图像左上角，水平向右为 X 轴，垂直向下为 Y 轴。数学课本中常见的坐标系是以图像中心为原点，水平向右为 X 轴，垂直向上为 Y 轴，称为笛卡尔坐标系。看下图:

因此，对于旋转和偏移，就需要3步（3次变换）：

• 将输入原图图像坐标转换为笛卡尔坐标系；
• 进行旋转计算。旋转矩阵前面已经给出了；
• 将旋转后的图像的笛卡尔坐标转回图像坐标。

2.4.3图像坐标系与笛卡尔坐标系转换关系：

先看下图：

  在图像中我们的坐标系通常是AB和AC方向的,原点为A，而笛卡尔直角坐标系是DE和DF方向的，原点为D。
  令图像表示为M×N的矩阵，对于点A而言，两坐标系中的坐标分别是(0，0)和$(-N/2,M/2)$，则图像某像素点$(x^{\prime },y^{\prime })$转换为笛卡尔坐标$（x,y）$转换关系为，$x$为列，$y$为行：

$$x=x^{\prime }-\frac{N}{2}$$

$$y=-y^{\prime }-\frac{M}{2}$$

逆变换为：

$$x^{\prime }=x+\frac{N}{2}$$

$$y^{\prime }=-y+\frac{M}{2}$$

  于是，根据前面说的3个步骤（3次变换），旋转(顺时针旋转)的变换形式就为，3次变换就有3个矩阵：

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}1& 0& -0.5\cdot N\\ 0& -1& -0.5\cdot M\\ 0& 0& 1\end{array}\right]\left[\begin{array}{ccc}cos\theta & sin\theta & 0\\ -sin\theta & cos\theta & 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{ccc}1& 0& 0.5\cdot N\\ 0& -1& 0.5\cdot M\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

即：

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}cos\theta & -sin\theta & -0.5N(1-cos\theta )+0.5Msin\theta \\ sin\theta & -cos\theta & -0.5M(1-sin\theta )-0.5Mcos\theta \\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

2.5 基于OpenCV的实现

• 工具：OpenCV4.1.0+VS2019
• 平台：WIN10

函数原型（c++）

OpenCV仿射变换相关的函数一般涉及到warpAffine和getRotationMatrix2D这两个：

• 使用OpenCV函数warpAffine 来实现一些简单的重映射.
• OpenCV函数getRotationMatrix2D 来获得旋转矩阵。

1、warpAffined函数详解

void boxFilter( InputArray src, OutputArray dst, 
                int ddepth,
                Size ksize,  
                Point anchor = Point(-1,-1),
                bool normalize = true,
                int borderType = BORDER_DEFAULT );

• 第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。
• 第二个参数，OutputArray类型的dst，函数调用后的运算结果存在这里，需和源图片有一样的尺寸和类型。
• 第三个参数，InputArray类型的M，2×3的变换矩阵。
• 第四个参数，Size类型的dsize，表示输出图像的尺寸。
• 第五个参数，int类型的flags，插值方法的标识符。此参数有默认值INTER_LINEAR(线性插值)，可选的插值方式如下：
  INTER_NEAREST - 最近邻插值
  INTER_LINEAR - 线性插值（默认值）
  INTER_AREA - 区域插值
  INTER_CUBIC –三次样条插值
  INTER_LANCZOS4 -Lanczos插值
  CV_WARP_FILL_OUTLIERS - 填充所有输出图像的象素。如果部分象素落在输入图像的边界外，那么它们的值设定为 fillval.
  CV_WARP_INVERSE_MAP –表示M为输出图像到输入图像的反变换，即 。因此可以直接用来做象素插值。否则, warpAffine函数从M矩阵得到反变换。
• 第六个参数，int类型的borderMode，边界像素模式，默认值为BORDER_CONSTANT。
• 第七个参数，const Scalar&类型的borderValue，在恒定的边界情况下取的值，默认值为Scalar()，即0。

2、getRotationMatrix2D函数详解

C++: Mat getRotationMatrix2D(Point2f center, double angle, double scale)

参数：

• 第一个参数，Point2f类型的center，表示源图像的旋转中心。
• 第二个参数，double类型的angle，旋转角度。角度为正值表示向逆时针旋转（坐标原点是左上角）。
• 第三个参数，double类型的scale，缩放系数。

实现示例（c++)

1、旋转

	Mat src = imread("../image/source3.jpg");//读取原图像
	cv::Mat dst;
 
	//旋转角度
	double angle = 45;
 
	cv::Size src_sz = src.size();
	cv::Size dst_sz(src_sz.height, src_sz.width);
	int len = std::max(src.cols, src.rows);
 
	//指定旋转中心（图像中点）
	cv::Point2f center(len / 2., len / 2.);
	
	//获取旋转矩阵（2x3矩阵）
	cv::Mat rot_mat = cv::getRotationMatrix2D(center, angle, 1.0);
 
	//根据旋转矩阵进行仿射变换
	cv::warpAffine(src, dst, rot_mat, dst_sz);
 
	//显示旋转效果
	cv::imshow("image", src);
	cv::imshow("result", dst);
 
	cv::waitKey(0);
 
	return 0;

但是这么写有一个问题，就是旋转后图像会被截断，如下图所示：（左边为原图,右边为顺时针旋转45度后的图）

可以看到，图像的一部分被截断了，其原因是：

1. 旋转过后的图像大小应该发生变化才能装下旋转后的图片
2. OpenCv将坐标转成笛卡尔坐标系后没转回图像坐标系

其中比较难理解的是图像大小的变换，下面举一个例子大家就能明白了：

如图：ABCD是变换前矩形，EFGH是变换后的矩形，变换的矩阵表示为：

$$\left[\begin{array}{c}x\\ y\\ 1\end{array}\right]=\left[\begin{array}{ccc}cos\theta & sin\theta & 0\\ -sin\theta & cos\theta & 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_0\\ y_0\\ 1\end{array}\right]$$

即表达式为：

$$x=cos\theta x_0+sin\theta y_0$$

$$y=-sin\theta x_0+cos\theta y_0$$

  所以，要算旋转后图片的大小，只需计算原图像四个顶点变换后的图像所确定的外接矩形长宽。因为经过坐标变换后的图像是关于原点对称的，所以计算D点变换后的横坐标的绝对值乘2，就是变换后矩形的长，计算A点变换后的纵坐标的绝对值乘2，就是变换后矩形的宽

设原图像长为$2a$，宽为$2b$，变换后的图像长宽为$c$，$d$，则$A$点的坐标为：$(-a,b)$， $D$点坐标：$(a,b)$

$$c=2\ast (a|cos\theta |+b|sin\theta |)$$

$$d=2\ast (a|sin\theta |+b|cos\theta |)$$

	Mat src = imread("../image/source3.jpg");//读取原图像
	Mat dst;
	// 旋转角度
	double angle = 45.0;

	// 计算旋转后输出图形的尺寸
	int rotated_width = ceil(src.rows * fabs(sin(angle * CV_PI / 180)) + src.cols * fabs(cos(angle * CV_PI / 180)));
	int rotated_height = ceil(src.cols * fabs(sin(angle * CV_PI / 180)) + src.rows * fabs(cos(angle * CV_PI / 180)));

	// 计算仿射变换矩阵
	Point2f center(src.cols / 2, src.rows / 2);
	Mat rotate_matrix = getRotationMatrix2D(center, angle, 1.0);

	// 防止切边，对平移矩阵B进行修改
	rotate_matrix.at<double>(0, 2) += (rotated_width - src.cols) / 2;
	rotate_matrix.at<double>(1, 2) += (rotated_height - src.rows) / 2;

	// 应用仿射变换
	warpAffine(src, dst, rotate_matrix, Size(rotated_width, rotated_height), INTER_LINEAR, 0, Scalar(255, 255, 255));
	imshow("result", dst);
	cv::imwrite("right.jpg", dst);
	waitKey();
	return 0;

结果：

2、平移

	Mat src = imread("../image/source2.jpg");//读取原图像
	cv::Mat dst;
 
	cv::Size dst_sz = src.size();
	
	//定义平移矩阵
	cv::Mat t_mat =cv::Mat::zeros(2, 3, CV_32FC1);
 
	t_mat.at<float>(0, 0) = 1;
	t_mat.at<float>(0, 2) = 300; //水平平移量
	t_mat.at<float>(1, 1) = 1;
	t_mat.at<float>(1, 2) = 300; //竖直平移量
 
	//根据平移矩阵进行仿射变换
	cv::warpAffine(src, dst, t_mat, dst_sz);
 
	//显示平移效果
	cv::imshow("image", src);
	cv::imshow("result", dst);
 
	cv::waitKey(0);
 
	return 0;

3.仿射变化

#include <opencv2/opencv.hpp>
#include <iostream>
using namespace cv;
using namespace std;

int main(int argc, char** argv)
{
    Mat src = imread("../image/source2.jpg");//读取原图像
    
    //分别在原图像和目标图像上定义三个点
    Point2f srcTri[3];
    Point2f dstTri[3];
    
    srcTri[0] = Point2f(0, 0);
    srcTri[1] = Point2f(src.cols - 1, 0);
    srcTri[2] = Point2f(0, src.rows - 1);
    
    dstTri[0] = Point2f(src.cols * 0.0, src.rows * 0.33);
    dstTri[1] = Point2f(src.cols * 0.85, src.rows * 0.25);
    dstTri[2] = Point2f(src.cols * 0.15, src.rows * 0.7);
    
    Mat dst;//目标图像
    //设置目标图像的大小和类型与原图像一致,初始像素值都为0
    dst = Mat::zeros(src.rows, src.cols, src.type());
    //计算仿射变换矩阵
     Mat trans_mat = getAffineTransform(srcTri, dstTri);
    //对原图像应用上面求得的仿射变换
    warpAffine(src, dst, trans_mat, src.size());
    
    //显示结果
    imshow("origin_image", src);
    imshow("dst_image", dst);
    
    //储存图像
    imwrite("dst1.jpg", dst);
    waitKey(0);
    return 0;
}

进阶实现(根据原理自己实现)

1、旋转

/*图像旋转（以图像中心为旋转中心）*/
void affine_trans_rotate(cv::Mat& src, cv::Mat& dst, double Angle){
	double angle = Angle*CV_PI / 180.0;
	//构造输出图像
	int dst_rows = round(fabs(src.rows * cos(angle)) + fabs(src.cols * sin(angle)));//图像高度
	int dst_cols = round(fabs(src.cols * cos(angle)) + fabs(src.rows * sin(angle)));//图像宽度
 
	if (src.channels() == 1) {
		dst = cv::Mat::zeros(dst_rows, dst_cols, CV_8UC1); //灰度图初始
	} 
	else {
		dst = cv::Mat::zeros(dst_rows, dst_cols, CV_8UC3); //RGB图初始
	}
 
	cv::Mat T1 = (cv::Mat_<double>(3,3) << 1.0,0.0,0.0 , 0.0,-1.0,0.0, -0.5*src.cols , 0.5*src.rows , 1.0); // 将原图像坐标映射到数学笛卡尔坐标
	cv::Mat T2 = (cv::Mat_<double>(3,3) << cos(angle),-sin(angle),0.0 , sin(angle), cos(angle),0.0, 0.0,0.0,1.0); //数学笛卡尔坐标下顺时针旋转的变换矩阵
	double t3[3][3] = { { 1.0, 0.0, 0.0 }, { 0.0, -1.0, 0.0 }, { 0.5*dst.cols, 0.5*dst.rows ,1.0} }; // 将数学笛卡尔坐标映射到旋转后的图像坐标
	cv::Mat T3 = cv::Mat(3.0,3.0,CV_64FC1,t3);
	cv::Mat T = T1*T2*T3;
	cv::Mat T_inv = T.inv(); // 求逆矩阵
 
	for (double i = 0.0; i < dst.rows; i++){
		for (double j = 0.0; j < dst.cols; j++){
			cv::Mat dst_coordinate = (cv::Mat_<double>(1, 3) << j, i, 1.0);
			cv::Mat src_coordinate = dst_coordinate * T_inv;
			double v = src_coordinate.at<double>(0, 0); // 原图像的横坐标，列，宽
			double w = src_coordinate.at<double>(0, 1); // 原图像的纵坐标，行，高
		//	std::cout << v << std::endl;
 
			/*双线性插值*/
			// 判断是否越界
			if (int(Angle) % 90 == 0) {
				if (v < 0) v = 0; if (v > src.cols - 1) v = src.cols - 1;
				if (w < 0) w = 0; if (w > src.rows - 1) w = src.rows - 1; //必须要加上，否则会出现边界问题
			}
 
			if (v >= 0 && w >= 0 && v <= src.cols - 1 && w <= src.rows - 1){
				int top = floor(w), bottom = ceil(w), left = floor(v), right = ceil(v); //与映射到原图坐标相邻的四个像素点的坐标
				double pw = w - top ; //pw为坐标 行 的小数部分(坐标偏差)
				double pv = v - left; //pv为坐标 列 的小数部分(坐标偏差)
				if (src.channels() == 1){
					//灰度图像
					dst.at<uchar>(i, j) = (1 - pw)*(1 - pv)*src.at<uchar>(top, left) + (1 - pw)*pv*src.at<uchar>(top, right) + pw*(1 - pv)*src.at<uchar>(bottom, left) + pw*pv*src.at<uchar>(bottom, right);
				}
				else{
					//彩色图像
					dst.at<cv::Vec3b>(i, j)[0] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[0] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[0] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[0] + pw*pv*src.at<cv::Vec3b>(bottom, right)[0];
					dst.at<cv::Vec3b>(i, j)[1] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[1] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[1] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[1] + pw*pv*src.at<cv::Vec3b>(bottom, right)[1];
					dst.at<cv::Vec3b>(i, j)[2] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[2] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[2] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[2] + pw*pv*src.at<cv::Vec3b>(bottom, right)[2];
				}
			}
		}
	}
}

2、平移

/*平移变换*（以图像左顶点为原点）/
/****************************************
tx: 水平平移距离 正数向右移动 负数向左移动
ty: 垂直平移距离 正数向下移动 负数向上移动
*****************************************/
void affine_trans_translation(cv::Mat& src, cv::Mat& dst, double tx, double ty){
	//构造输出图像
	int dst_rows = src.rows;//图像高度
	int dst_cols = src.cols;//图像宽度
 
	if (src.channels() == 1) {
		dst = cv::Mat::zeros(dst_rows, dst_cols, CV_8UC1); //灰度图初始
	}
	else {
		dst = cv::Mat::zeros(dst_rows, dst_cols, CV_8UC3); //RGB图初始
	}
 
	cv::Mat T = (cv::Mat_<double>(3, 3) << 1,0,0 , 0,1,0 , tx,ty,1); //平移变换矩阵
	cv::Mat T_inv = T.inv(); // 求逆矩阵
 
	for (int i = 0; i < dst.rows; i++){
		for (int j = 0; j < dst.cols; j++){
			cv::Mat dst_coordinate = (cv::Mat_<double>(1, 3) << j, i, 1);
			cv::Mat src_coordinate = dst_coordinate * T_inv;
			double v = src_coordinate.at<double>(0, 0); // 原图像的横坐标，列，宽
			double w = src_coordinate.at<double>(0, 1); // 原图像的纵坐标，行，高
 
			/*双线性插值*/
			// 判断是否越界
 
			if (v >= 0 && w >= 0 && v <= src.cols - 1 && w <= src.rows - 1){
				int top = floor(w), bottom = ceil(w), left = floor(v), right = ceil(v); //与映射到原图坐标相邻的四个像素点的坐标
				double pw = w - top; //pw为坐标 行 的小数部分(坐标偏差)
				double pv = v - left; //pv为坐标 列 的小数部分(坐标偏差)
				if (src.channels() == 1){
					//灰度图像
					dst.at<uchar>(i, j) = (1 - pw)*(1 - pv)*src.at<uchar>(top, left) + (1 - pw)*pv*src.at<uchar>(top, right) + pw*(1 - pv)*src.at<uchar>(bottom, left) + pw*pv*src.at<uchar>(bottom, right);
				}
				else{
					//彩色图像
					dst.at<cv::Vec3b>(i, j)[0] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[0] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[0] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[0] + pw*pv*src.at<cv::Vec3b>(bottom, right)[0];
					dst.at<cv::Vec3b>(i, j)[1] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[1] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[1] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[1] + pw*pv*src.at<cv::Vec3b>(bottom, right)[1];
					dst.at<cv::Vec3b>(i, j)[2] = (1 - pw)*(1 - pv)*src.at<cv::Vec3b>(top, left)[2] + (1 - pw)*pv*src.at<cv::Vec3b>(top, right)[2] + pw*(1 - pv)*src.at<cv::Vec3b>(bottom, left)[2] + pw*pv*src.at<cv::Vec3b>(bottom, right)[2];
				}
			}
		}
	}
}

相关技术文档、博客、教材、项目推荐

opencv文档: https://docs.opencv.org/3.1.0/da/d54/group__imgproc__transform.html#ga0203d9ee5fcd28d40dbc4a1ea4451983
博客：https://blog.csdn.net/weixin_40647819/article/details/87912122
https://www.jianshu.com/p/18cd12e776e1
https://blog.csdn.net/whuhan2013/article/details/53814026
python版本：https://blog.csdn.net/g11d111/article/details/79978582
https://www.kancloud.cn/aollo/aolloopencv/264331 http://www.woshicver.com/FifthSection/4_2_%E5%9B%BE%E5%83%8F%E5%87%A0%E4%BD%95%E5%8F%98%E6%8D%A2/

2.6 总结

该部分对几何变换的平移和旋转进行了介绍，读者可根据提供的资料对相关原理进行学习，然后参考示例代码自行实现。另外读者可以尝试学习并实现其他几何变换，如偏移。

关于Datawhale：

Datawhale是一个专注于数据科学与AI领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。Datawhale以“for the learner，和学习者一起成长”为愿景，鼓励真实地展现自我、开放包容、互信互助、敢于试错和勇于担当。同时Datawhale 用开源的理念去探索开源内容、开源学习和开源方案，赋能人才培养，助力人才成长，建立起人与人，人与知识，人与企业和人与未来的联结。