OpenCV：第2章 几何变换

最新推荐文章于 2022-11-17 16:18:41 发布
最新推荐文章于 2022-11-17 16:18:41 发布
阅读量327 收藏 1
点赞数
分类专栏： opencv 文章标签： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38059712/article/details/105670465
版权

第2章 几何变换

本章思维导图

在这里插入图片描述

本章内容概要

1、几何变换算法原理介绍

变换形式

在冈萨雷斯的《数字图像处理_第三版》书中的描述，仿射变换的一般形式如下：

在这里插入图片描述
式中的 T T T 就是变换矩阵，其中 ( v , w ) (v,w) (v,w) 为原坐标， ( x , y ) (x,y) (x,y) 为变换后的坐标，不同的变换对应不同的矩阵，这里也贴出来吧，一些常见的变换矩阵及作用如下表：

在这里插入图片描述

坐标系变换

对于缩放、平移可以以图像坐标原点（图像左上角为原点） 为中心变换，这不用坐标系变换，直接按照一般形式计算即可。

对于旋转和偏移，一般是以图像中心为原点，那么这就涉及坐标系转换了。

  • 图像坐标系：原点在图像左上角，水平向右为 X 轴，垂直向下为 Y 轴。
  • 笛卡尔坐标系：以图像中心为原点，水平向右为 X 轴，垂直向上为 Y 轴。
    在这里插入图片描述

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

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

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

在这里插入图片描述
在图像中我们的坐标系通常是AB和AC方向的,原点为A，而笛卡尔直角坐标系是DE和DF方向的，原点为D。
令图像表示为M×N的矩阵，对于点A而言，两坐标系中的坐标分别是**(0，0)和(-N/2,M/2)**，则图像某像素点 (x’,y’) 转换为笛卡尔坐标 (x,y) 转换关系为(x为列，y为行)：

x = x ′ − N / 2 x=x^{'}-N/2 x=x′−N/2

y = − y ′ + M / 2 y=-y^{'}+M/2 y=−y′+M/2

逆变换为：

x ′ = x + N / 2 x^{'}=x+N/2 x′=x+N/2

y ′ = − y + M / 2 y^{'}=-y+M/2 y′=−y+M/2

于是，根据前面说的3个步骤（3次变换），旋转(顺时针旋转)的变换形式就为，3次变换就有3个矩阵：
在这里插入图片描述

反向映射

前向映射就是根据原图用变换公式直接算出输出图像相应像素的空间位置。
那么这会导致一个问题：可能会有多个像素坐标映射到输出图像的同一位置，也可能输出图像的某些位置完全没有相应的输入图像像素与它匹配，也就是没有被映射到，造成有规律的空洞（黑色的蜂窝状）。
更好的一种方式是采用 反向映射（Inverse Mapping）：扫描输出图像的位置(x,y)，通过 [ v , w , 1 ] = [ x , y , 1 ] ∗ T − 1 [v,w,1]=[x,y,1]*T^{-1} [v,w,1]=[x,y,1]∗T−1（为T的逆矩阵）计算输入图像对应的位置 (v,w)，通过插值方法决定输出图像中对应位置的灰度值。

插值

采用反向映射后，需通过插值方法决定输出图像该位置的值，因此需要选择插值算法。通常有最近邻插值、双线性插值，双三次插值等，OpenCV默认采用双线性插值。

基于OpenCV的实现

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，缩放系数。

代码实践：

1、旋转

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

    cv::Mat src = cv::imread("lenna.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;

2、平移

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

    cv::Mat src = cv::imread("lenna.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) = 20; //水平平移量
	t_mat.at<float>(1, 1) = 1;
	t_mat.at<float>(1, 2) = 10; //竖直平移量
 
	//根据平移矩阵进行仿射变换
	cv::warpAffine(src, dst, t_mat, dst_sz);
 
	//显示平移效果
	cv::imshow("image", src);
	cv::imshow("result", dst);
 
	cv::waitKey(0);
 
	return 0;

进阶实现：

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <math.h>
 
 
/*图像旋转（以图像中心为旋转中心）*/
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];
				}
			}
		}
	}
}
 
/*平移变换*（以图像左顶点为原点）/
/****************************************
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];
				}
			}
		}
	}
}
 
 
/*尺度变换*（以图像左顶点为原点）/
/***************
cx: 水平缩放尺度
cy: 垂直缩放尺度
***************/
void affine_trans_scale(cv::Mat& src, cv::Mat& dst, double cx, double cy){
	//构造输出图像
	int dst_rows = round(cy*src.rows);//图像高度
	int dst_cols = round(cx*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) <<cx,0,0, 0,cy,0 ,0,0,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) 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];
				}
			}
		}
	}
}
 
/*偏移变换*（以图像中心为偏移中心）/
/***************************************
sx: 水平偏移尺度 正数向左偏移 负数向右偏移
sy: 垂直偏移尺度 正数向上偏移 负数向下偏移
****************************************/
void affine_trans_deviation(cv::Mat& src, cv::Mat& dst, double sx, double sy){
	//构造输出图像
	int dst_rows = fabs(sy)*src.cols + src.rows;//图像高度
	int dst_cols = fabs(sx)*src.rows + 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 T1 = (cv::Mat_<double>(3, 3) << 1, 0, 0, 0, -1, 0, -0.5*src.cols, 0.5*src.rows, 1); // 将原图像坐标映射到数学笛卡尔坐标
	cv::Mat T2 = (cv::Mat_<double>(3, 3) << 1,sy,0, sx,1,0, 0,0,1); //数学笛卡尔坐标偏移变换矩阵
	double t3[3][3] = { { 1, 0, 0 }, { 0, -1, 0 }, { 0.5*dst.cols, 0.5*dst.rows, 1 } }; // 将数学笛卡尔坐标映射到旋转后的图像坐标
	cv::Mat T3 = cv::Mat(3, 3, CV_64FC1, t3);
	cv::Mat T = T1*T2*T3;
	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];
				}
			}
		}
	}
}
 
/*组合变换*/
/*变换顺序：缩放->旋转—>偏移*/
void affine_trans_comb(cv::Mat& src, cv::Mat& dst, double cx, double cy, double Angle, double sx, double sy){
	double angle = Angle*CV_PI / 180;
	//构造输出图像
	int dst_s_rows = round(cy*src.rows);//尺度变换后图像高度
	int dst_s_cols = round(cx*src.cols);//尺度变换后图像宽度
 
	int dst_sr_rows = round(fabs(dst_s_rows * cos(angle)) + fabs(dst_s_cols * sin(angle)));//再经过旋转后图像高度
	int dst_sr_cols = round(fabs(dst_s_cols * cos(angle)) + fabs(dst_s_rows * sin(angle)));//再经过旋转后图像宽度
 
	int dst_srd_rows = fabs(sy)*dst_sr_cols + dst_sr_rows;//最后经过偏移后图像高度
    int dst_srd_cols = fabs(sx)*dst_sr_rows + dst_sr_cols;//最后经过偏移后图像宽度
 
 
	if (src.channels() == 1) {
 
		dst = cv::Mat::zeros(dst_srd_rows, dst_srd_cols, CV_8UC1); //灰度图初始
	}
	else {
		dst = cv::Mat::zeros(dst_srd_rows, dst_srd_cols, CV_8UC3); //RGB图初始
	}
 
	cv::Mat T1 = (cv::Mat_<double>(3, 3) << cx, 0, 0, 0, cy, 0, 0, 0, 1); //尺度变换矩阵
 
	cv::Mat T21 = (cv::Mat_<double>(3, 3) << 1, 0, 0, 0, -1, 0, -0.5*dst_s_cols, 0.5*dst_s_rows, 1); // 将尺度变换后的图像坐标映射到数学笛卡尔坐标
	cv::Mat T22 = (cv::Mat_<double>(3, 3) << cos(angle), -sin(angle), 0, sin(angle), cos(angle), 0, 0, 0, 1); //数学笛卡尔坐标下顺时针旋转的变换矩阵
	cv::Mat T2 = T21*T22;// 这里不需要转回图像坐标了，因为下面的偏移变换是在笛卡尔坐标下进行的
 
	cv::Mat T32 = (cv::Mat_<double>(3, 3) << 1, sy, 0, sx, 1, 0, 0, 0, 1); //数学笛卡尔坐标偏移变换矩阵
	double t33[3][3] = { { 1, 0, 0 }, { 0, -1, 0 }, { 0.5*dst.cols, 0.5*dst.rows, 1 } }; // 将数学笛卡尔坐标映射到偏移后的图像坐标
	cv::Mat T33 = cv::Mat(3, 3, CV_64FC1, t33);
	cv::Mat T3 = T32*T33;
 
	cv::Mat T = T1*T2*T3; //矩阵相乘按照组合变换的顺序
	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 (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];
				}
			}
		}
	}
}
 
 
int main(){
	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\5.bmp");
	cvtColor(src, src, CV_BGR2GRAY);
	if (src.empty()){
		std::cout << "Failure to load image..." << std::endl;
		return -1;
	}
	cv::Mat dst;
	double angle =250;  //旋转角度
	double tx = 50, ty = -50; //平移距离
	double cx =1.5, cy = 1.5; //缩放尺度
	double sx = 0.2, sy =0.2; //偏移尺度
 
	//affine_trans_rotate(src, dst, angle); //旋转
 
	//affine_trans_translation(src, dst, tx,ty); //平移
 
	//affine_trans_scale(src, dst, cx, cy);  //尺度缩放
 
    //affine_trans_deviation(src, dst, sx, sy); //偏移
 
	affine_trans_comb(src, dst, cx,  cy, angle, sx,  sy); // 缩放->旋转—>偏移
 
	//cv::imwrite("result.jpg", dst);
	cv::namedWindow("src");
	cv::imshow("src", src);
	cv::namedWindow("dst",CV_WINDOW_NORMAL);
	cv::imshow("dst", dst);
	cv::waitKey(0);
}

参考：
1、OpenCV：第2章 几何变换

2、OpenCV-Python中文教程

3、OpenCV教程

4、图像的仿射变换原理及c++实现（旋转，平移，缩放，偏移，组合变换）

Axiiiz
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习【OpenCV入门教程之十三】OpenCV图像金字塔：高斯金字塔、拉普拉斯金字塔与图片尺寸缩放---思维导图
lindazhu520的博客
05-21 1535
文章参考@浅墨_毛星云文章链接： http://blog.csdn.net/poem_qianmo/article/details/26157633 今天学习了OpenCV图像金字塔：高斯金字塔、拉普拉斯金字塔与图片尺寸缩放，分几个部分来整理了一个笔记，见思维导图： 一、引言 二、图像金字塔 三、resize()函数分析 四、pyrUp()函数分析 五、
OpenCV 几何变换
weixin_57556081的博客
06-28 294
几何变换是指将一幅图像映射到另外一幅图像内的操作。根据OpenCV函数的不同，将映射关系划分为缩放、翻转、仿射变换、透视等。 案例来源于傅老师。 1.缩放 在OpenCV中，使用函数cv2.resize()实现对图像的缩放，具体形式为： dst =cv2.resize(src, dsize[, fx[, fy[, interpolation]]]) src：原图 dsize：输出图像的大小 fx：水平方向的缩放比例 fy：垂直方向的缩放比例 interpolation：插值方法 实践：.
OpenCV学习思维导图
07-15
自己总结的OpenCV的知识思维导图
OpenCV思维导图
Peter的博客
11-01 724
OpenCV思维导图。
学习OpenCV思维导图
YBAdiam的博客
08-24 1545
 
【OpenCV学习】 《OpenCV3编程入门》--毛星云 01 邂逅OpenCV（OpenCV基本概念与基本架构）& ROS系统上的运用（python实现）
Howe_xixi的博客
11-17 1576
《OpenCV3编程入门》第一章的学习笔记，包含OpenCV的概念与基本架构。在ROS noetic中实现图像的读取显示，图像腐蚀，blur图像模糊，canny图像边缘检测与获取摄像机中的图像并进行canny边缘检测。
OpenCV -几何变换
NOimachi的博客
06-29 265
本次素材都来源于傅贤君老师 1.缩放： img_resize=cv2.resize(img,None,fx=1,fy=0.5)dst：为输出目标图像src：原图dsize：输出图像大小fx：水平方向的缩放比例fy：垂直方向的缩放比例 代码： import cv2 img=cv2.imread(“lina.png”) h,w,c=img.shape img_resize=cv2.resize(img,None,fx=1,fy=0.5) cv2.imshow(‘lina’,img_resize) cv2.i
OpenCV-python 学习笔记 OpenCV几何变换1
08-03
在OpenCV中，几何变换是图像处理的重要组成部分，它允许我们对图像进行各种操作，如缩放、平移、旋转、仿射变换和透视变换。这些变换在图像分析、识别和增强等领域有着广泛的应用。 1. **扩展缩放**： 使用`cv2....
openCv-python中文教程_段力辉-译（14章几何变换训练代码）
10-16
《OpenCV-Python中文教程_段力辉-译（14章几何变换训练代码）》是针对计算机视觉领域中OpenCV库使用Python编程语言进行图像处理的实践指导书。本教程由知名技术专家段力辉翻译，旨在帮助读者深入理解和掌握OpenCV在...
Python 在OpenCV里实现仿射变换—坐标变换效果
09-18
在二维空间中，一个仿射变换可以通过一个2x3的矩阵来表示，其中前两列对应于线性变换部分，第三列对应于平移向量。 在实际应用中，我们通常需要根据用户指定的控制点来计算这个2x3的变换矩阵。例如，假设我们有三个...
OpenCV.xmind
06-11
个人在学习机器学习过程中整理的OpenCV常用方法的思维导图，后续仍会继续更新，有问题欢迎联系指出。
opencv基础学习笔记大全
01-05
史上最全的opencv基础学习笔记，诚心希望能对你有所帮助。
空间插值方法对比整理 Interpolation
11-15
Interpolation 空间插值方法对比整理
学习opencv第六章课后答案，完整版（自己敲的，不是网上的）
01-02
3. **6_2**: 第二题可能涵盖了基础的图像读取和显示。在OpenCV中，可以使用`imread`函数加载图像，`imshow`函数展示图像。此外，也可能涉及到图像的尺寸调整、颜色空间转换等操作。 4. **6_14**: 14题可能涉及到...
山东大学数字图像处理实验二：几何变换与变形
01-17
在本实验的第二个部分，即`test2-2.cpp`文件中，可能会实现诸如仿射变换、透视变换等复杂的图像变形。例如，仿射变换可以保持直线的性质不变，适用于简单的倾斜或旋转；而透视变换则可以模拟三维空间中的视图变化，...
Opencv 实战学习总结一 （思维导图）
weixin_34854320的博客
01-13 492
Opencv 实战学习总结一
OPENCV思维导图
hbx19720513的专栏
09-21 462
OpenCV：第4章 图像滤波
sinat_38059712的博客
04-29 1221
第4章 图像滤波本章思维导图本章内容概要算法理论介绍1、均值滤波、方框滤波2、高斯滤波基于OpenCV的实现C++ 本章思维导图 （待更新） 本章内容概要 图像的实质是一种二维信号，滤波是信号处理中的一个重要概念。在图像处理中，滤波是一种非常常见的技术，它们的原理非常简单，但是其思想却十分值得借鉴，滤波是很多图像算法的前置步骤或基础，掌握图像滤波对理解卷积神经网络也有一定帮助。 算法理论介绍 ...
OpenCV计算机视觉基础教程(Python版)课件05边缘和轮廓.pptx
最新发布
06-11
OpenCV计算机视觉基础教程 Python版 慕课版 主讲教师：*** OpenCV计算机视觉基础教程(Python版)课件05边缘和轮廓全文共41页，当前为第1页。 第5章 边缘和轮廓 本章主要内容： 边缘检测 图像轮廓 霍夫变换 实验 OpenCV计算机视觉基础教程(Python版)课件05边缘和轮廓全文共41页，当前为第2页。 5.1.1 Laplacian边缘检测 Laplacian（拉普拉斯）边缘检测使用图像矩阵与拉普拉斯核进行卷积运算，其本质是计算图像中任意一点与其在水平方向和垂直方向上4个相邻点平均值的差值。常用的拉普拉斯核如下。 cv2.Laplacian()函数用于实现Laplacian边缘检测，其基本格式如下。 dst=cv2.Laplacian(src,ddepth[,ksize[,scale[,delta[,borderType]]]]) 参数说明如下。 dst表示边缘检测结果图像。 src为原图像。 ddepth为目标图像的深度。 ksize为用于计算二阶导数滤波器的系数，必须为正数且为奇数。 scale为可选比例因子。 delta为添加到边缘检测结果中的可

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值