opencv----计算图像旋转参数

最新推荐文章于 2022-08-05 10:58:27 发布
最新推荐文章于 2022-08-05 10:58:27 发布
阅读量1k 收藏 1
点赞数
分类专栏： opencv 文章标签： fourier opencv 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lst227405/article/details/24626455
版权

弄这个弄了好几天，一直想的复杂了

其实很简单，其实并不难

先上代码吧，不过里面有很多多余的函数，不过之后计算平移+旋转的时候会用到

// xuanzhuan.cpp : 定义控制台应用程序的入口点。
//

#include "StdAfx.h"



#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/legacy/legacy.hpp>
#include <iostream>
#include <vector>

using namespace cv;
using namespace std;

void fourier(cv::Mat in,cv::Mat &out_re,cv::Mat &out_im);//计算傅里叶变换，分别输出变换后结果的实部和虚部
void gonglvpu(cv::Mat in1,cv::Mat in2,cv::Mat out);//计算傅里叶变换后的功率谱
void pingyi(cv::Mat in_1,cv::Mat in_2,int &x,int &y);
void cart2polar(cv::Mat in,cv::Mat &out);
void polar2cart(cv::Mat in,cv::Mat out);
void fft2(IplImage *src, IplImage *dst);
void fft2shift(IplImage *src, IplImage *dst);
void test(cv::Mat in,cv::Mat out);//本函数可以实现计算图像傅里叶变换后功率谱的功能
int _tmain(int argc, _TCHAR* argv[])
{

	cv::Mat image1=cv::imread("lena.bmp");
	cv::Mat image2=cv::imread("5du.bmp");
	cv::cvtColor(image1,image1,CV_RGB2GRAY);
	cv::cvtColor(image2,image2,CV_RGB2GRAY);
	cart2polar(image1,image1);
	//image1=image1(cv::Rect(0,0,200,200));
	cart2polar(image2,image2);
	//image2=image2(cv::Rect(0,0,200,200));
	cv::namedWindow("www");
	cv::imshow("www",image2);
	int xx=0,yy=0;
	pingyi(image1,image2,xx,yy);
	cout<<xx<<"     "<<yy<<endl;
	int theta=((double)(yy+1)/image1.rows)*360;
	cout<<"theta  "<<theta<<endl;
	cv::waitKey();
	/*
	cv::Mat src1s[]={Mat_<float>(image1),cv::Mat::zeros(image1.size(),CV_32FC1)};
	cv::Mat FA1;
	cv::merge(src1s,2,FA1);
	//cv::dft(FA1,FA1);
	cv::split(FA1,src1s);
	cv::magnitude(src1s[0],src1s[1],src1s[0]);
	src1s[0]=src1s[0](cv::Rect(100,100,400,400));
	cart2polar(src1s[0],src1s[0]);
	//polar2cart(src1s[0],src1s[0]);
	src1s[0]=src1s[0](cv::Rect(0,0,200,200));
	cv::normalize(src1s[0],src1s[0],0,1,CV_MINMAX);

	cv::Mat src2s[]={Mat_<float>(image2),cv::Mat::zeros(image2.size(),CV_32FC1)};
	cv::Mat FA2;
	cv::merge(src2s,2,FA2);
	//cv::dft(FA2,FA2);
	cv::split(FA2,src2s);
	cv::magnitude(src2s[0],src2s[1],src2s[0]);
	src2s[0]=src2s[0](cv::Rect(100,100,400,400));
	cart2polar(src2s[0],src2s[0]);
	src2s[0]=src2s[0](cv::Rect(0,0,200,200));
	cv::normalize(src2s[0],src2s[0],0,1,CV_MINMAX);
	
	//cv::normalize(src2s[0],src2s[0],0,1,CV_MINMAX);
	cv::namedWindow("test");
	cv::imshow("test",src2s[0]);
	cv::waitKey();

	int xx=0,yy=0;
	pingyi(src1s[0],src2s[0],xx,yy);
	cout<<xx<<"     "<<yy<<endl;

		
	*/
	return 0;
}

void test(cv::Mat in,cv::Mat out)
{
	IplImage ss=in;
	IplImage tt=in;
	IplImage *src=&in.operator IplImage();          //源图像
	IplImage *Image=&out.operator IplImage();
	IplImage *Fourier;   //傅里叶系数
	IplImage *dst ;


	IplImage *ImageRe;
	IplImage *ImageIm;
	IplImage *ImageIm1;

	
	IplImage *ImageDst;


	double m,M;
	double scale;
	double shift;
	//src = cvLoadImage("lena.bmp",0);   //加载源图像，第二个参数表示将输入的图片转为单信道 
	Fourier = cvCreateImage(cvGetSize(src),IPL_DEPTH_64F,2);
	dst = cvCreateImage(cvGetSize(src),IPL_DEPTH_64F,2);
	ImageRe = cvCreateImage(cvGetSize(src),IPL_DEPTH_64F,1);
	ImageIm = cvCreateImage(cvGetSize(src),IPL_DEPTH_64F,1);
	ImageIm1 = cvCreateImage(cvGetSize(src),IPL_DEPTH_64F,1);
	//Image = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
	ImageDst = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
	fft2(src,Fourier);                  //傅里叶变换
	fft2shift(Fourier, Image);          //中心化
	//cvDFT(Fourier,dst,CV_DXT_INV_SCALE);//实现傅里叶逆变换，并对结果进行缩放
	
	cvSplit(dst,ImageRe,ImageIm,0,0);
	//cvNamedWindow("源图像",0);
	//cvShowImage("源图像",src);             
	//对数组每个元素平方并存储在第二个参数中
	cvPow(ImageRe,ImageRe,2);               
	cvPow(ImageIm,ImageIm1,2);
	cvAdd(ImageRe,ImageIm1,ImageRe,NULL);
	cvPow(ImageRe,ImageRe,0.5);
	cvMinMaxLoc(ImageRe,&m,&M,NULL,NULL);
	scale = 255/(M - m);
	shift = -m * scale;
	//将shift加在ImageRe各元素按比例缩放的结果上，存储为ImageDst
	cvConvertScale(ImageRe,ImageDst,scale,shift);
	cvNormalize(ImageIm,ImageIm, 0, 1, CV_MINMAX);
	//cvNamedWindow("傅里叶谱",0);
	//cvShowImage("傅里叶谱",Image);
	//cvNamedWindow("傅里叶逆变换",0);
	//cvShowImage("傅里叶逆变换",ImageDst);
	//cvNamedWindow("test",0);
	//cvShowImage("test",ImageIm);
	cvWaitKey(0);
	//cvReleaseImage(&src);
	//cvReleaseImage(&Image);
	cvReleaseImage(&ImageIm);
	cvReleaseImage(&ImageRe);
	cvReleaseImage(&Fourier);
	cvReleaseImage(&dst);
	cvReleaseImage(&ImageDst);
    //    cvDestroyAllWindows();
}
void fourier(cv::Mat in,cv::Mat &out_re,cv::Mat &out_im)
{
	Mat planes[] = {Mat_<float>(in), Mat::zeros(in.size(), CV_32FC1)};
	Mat complexI;
	merge(planes, 2, complexI); 
	cv::dft(complexI, complexI);
	cv::split(complexI, planes);
	out_re=planes[0];
	out_im=planes[1];

}
void gonglvpu(cv::Mat in1,cv::Mat in2,cv::Mat out)
{
	cv::magnitude(in1,in2,out);
	/*
	IplImage data_1=in1;
	IplImage data_2=in2;
	IplImage data_3=out;
	IplImage* pI1  = &in1.operator IplImage();
	IplImage* pI2  = &in2.operator IplImage();
	IplImage* pI3  = &out.operator IplImage();
	cvPow(pI1,pI1,2);
	cvPow(pI2,pI2,2);
	cvAdd(pI1,pI2,pI3);
	cvPow(pI3,pI3,0.5);
	*/
}
void pingyi(cv::Mat in_1,cv::Mat in_2,int &x,int &y)
{
	
	cv::Mat padded=in_1;
	Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
	Mat complexI;
	merge(planes, 2, complexI); 
	cv::dft(complexI, complexI);
	cv::split(complexI, planes);

	//
	
	cv::Mat padded2=in_2;
	Mat planes2[] = {Mat_<float>(padded2), Mat::zeros(padded2.size(), CV_32F)};
	Mat complexI2;
	merge(planes2, 2, complexI2); 
	cv::dft(complexI2, complexI2);
	cv::split(complexI2, planes2);
	//cv::normalize(planes[1],planes[1], 0, 1, CV_MINMAX);
	
	//src1变换后实部 planes[0]   虚部planes[1]
	//src2变换后实部 planes2[0]  虚部planes2[1]


	//互功率谱存放矩阵 实部  planes3[0]   虚部planes3[1]
	//
	
	Mat planes3[] = {Mat::zeros(in_1.size(), CV_32F), Mat::zeros(in_1.size(), CV_32F)};

	for(int i=0;i<in_1.rows-1;i++)
	{
		for(int j=0;j<in_1.cols-1;j++)
		{
			double r1=planes[0].at<float>(j,i);//获取像素值
			double i1=planes[1].at<float>(j,i);
			double r2=planes2[0].at<float>(j,i);
			double i2=planes2[1].at<float>(j,i);

			double r3    =r1*r2+i1*i2;//计算互功率谱的值 
			double i3    =r1*i2-r2*i1;
			double abs   =sqrt((r3*r3)+(i3*i3));
			double r_exp =r3/abs;
			double i_exp =i3/abs;

			
			planes3[0].at<float>(j,i)=r_exp;
			planes3[1].at<float>(j,i)=i_exp;
		}
	}

	Mat complexI3;
	merge(planes3, 2, complexI3);
	cv::dft(complexI3,complexI3,CV_DXT_INV_SCALE);
	cv::split(complexI3,planes3);
	magnitude(planes3[0], planes3[1], planes3[0]);
	complexI3=planes3[0];
	complexI3 += Scalar::all(1); 
	log(complexI3, complexI3);
	cv::normalize(complexI3,complexI3, 0, 1, CV_MINMAX);

	double max=0,min=0;
	cv::Point minLoc,maxLoc;
	cv::minMaxLoc(complexI3,&min,&max,&minLoc,&maxLoc);
	//cv::imwrite("complexI3.bmp",complexI3);


	x=maxLoc.x;
	y=maxLoc.y;
	cout<<min<<"   "<<max<<endl;
	cout<<complexI3.at<float>(maxLoc)<<endl;
}
void cart2polar(cv::Mat in,cv::Mat &out)
{
	IplImage tmp1=in;
	IplImage* pI1  = &in.operator IplImage();
	IplImage tmp2=out;
	IplImage* pI2  = &out.operator IplImage();
	cvLogPolar( pI1, pI2, cvPoint2D32f(pI1->width/2,pI1->height/2), 40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
	//cvReleaseImage(&pI1);
	//cvReleaseImage(&pI2);
}
void polar2cart(cv::Mat in,cv::Mat out)
{
	IplImage tmp1=in;
	IplImage* pI1  = &in.operator IplImage();
	IplImage tmp2=out;
	IplImage* pI2  = &out.operator IplImage();
	cvLogPolar( pI1, pI2, cvPoint2D32f(pI1->width/2,pI1->height/2), 40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS+CV_WARP_INVERSE_MAP );
}
void fft2(IplImage *src, IplImage *dst)
{  
	IplImage *image_Re = 0, *image_Im = 0, *Fourier = 0; //实部、虚部


	image_Re = cvCreateImage(cvGetSize(src), IPL_DEPTH_64F, 1);  //实部


	image_Im = cvCreateImage(cvGetSize(src), IPL_DEPTH_64F, 1);  //虚部


	Fourier = cvCreateImage(cvGetSize(src), IPL_DEPTH_64F, 2);//2 channels (image_Re, image_Im)


	cvConvertScale(src, image_Re, 1, 0);// Real part conversion from u8 to 64f (double)


	cvZero(image_Im);// Imaginary part (zeros)


	cvMerge(image_Re, image_Im, 0, 0, Fourier);// Join real and imaginary parts and stock them in Fourier image


	cvDFT(Fourier, dst, CV_DXT_FORWARD);// Application of the forward Fourier transform


	cvReleaseImage(&image_Re);
	cvReleaseImage(&image_Im);
	cvReleaseImage(&Fourier);
}
void fft2shift(IplImage *src, IplImage *dst)
{
	IplImage *image_Re = 0, *image_Im = 0;
	int nRow, nCol, i, j, cy, cx;
	double scale, shift, tmp13, tmp24;


	image_Re = cvCreateImage(cvGetSize(src), IPL_DEPTH_64F, 1);


	image_Im = cvCreateImage(cvGetSize(src), IPL_DEPTH_64F, 1);
	cvSplit( src, image_Re, image_Im, 0, 0 );


	//具体原理见冈萨雷斯数字图像处理p123
	// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
	//计算傅里叶谱
	cvPow( image_Re, image_Re, 2.0);
	cvPow( image_Im, image_Im, 2.0);
	cvAdd( image_Re, image_Im, image_Re);
	cvPow( image_Re, image_Re, 0.5 );


	//对数变换以增强灰度级细节(这种变换使以窄带低灰度输入图像值映射一宽带输出值，具体可见冈萨雷斯数字图像处理p62)
	// Compute log(1 + Mag);
	cvAddS( image_Re, cvScalar(1.0), image_Re ); // 1 + Mag
	cvLog( image_Re, image_Re ); // log(1 + Mag)


	//Rearrange the quadrants of Fourier image so that the origin is at the image center
	nRow = src->height; nCol = src->width;
	cx = nCol/2; cy = nRow/2; // image center


	//CV_IMAGE_ELEM为OpenCV定义的宏，用来读取图像的像素值，这一部分就是进行中心变换
	for( j = 0; j < cy; j++ ){
		for( i = 0; i < cx; i++ ){
			//中心化，将整体份成四块进行对角交换
			tmp13 = CV_IMAGE_ELEM( image_Re, double, j, i);
			CV_IMAGE_ELEM( image_Re, double, j, i) = CV_IMAGE_ELEM(image_Re, double, j+cy, i+cx);
			CV_IMAGE_ELEM( image_Re, double, j+cy, i+cx) = tmp13;


			tmp24 = CV_IMAGE_ELEM( image_Re, double, j, i+cx);
			CV_IMAGE_ELEM( image_Re, double, j, i+cx) =CV_IMAGE_ELEM( image_Re, double, j+cy, i);
			CV_IMAGE_ELEM( image_Re, double, j+cy, i) = tmp24;
		}
	}
	//归一化处理将矩阵的元素值归一为[0,255]
	//[(f(x,y)-minVal)/(maxVal-minVal)]*255
	double minVal = 0, maxVal = 0;
	// Localize minimum and maximum values
	cvMinMaxLoc( image_Re, &minVal, &maxVal );
	// Normalize image (0 - 255) to be observed as an u8 image
	scale = 255/(maxVal - minVal);
	shift = -minVal * scale;
	cvConvertScale(image_Re, dst, scale, shift);
	cvReleaseImage(&image_Re);
	cvReleaseImage(&image_Im);


}


/*
	for(int i=0;i<500;i++)
	{
		for(int j=0;j<500;j++)
		{
			if(i%20==0&&j%20==0)
				cout<<src1_f_re.at<float>(i,j)<<endl;
		}
	}
	*/

	/*string name1="lena.bmp";
	string name2="90du.bmp";
	cv::Mat src1=imread(name1);
	if(src1.channels()!=1)
		cv::cvtColor(src1,src1,CV_RGB2GRAY);
	cv::Mat src1_f_re   =cv::Mat::zeros(src1.size(),CV_32FC1);
	cv::Mat src1_f_im   =cv::Mat::zeros(src1.size(),CV_32FC1);
	cv::Mat src1_gonglv =cv::Mat::zeros(src1.size(),CV_32FC1);
	cv::Mat src1_g_log  =cv::Mat::zeros(src1.size(),CV_32FC1);
	fourier(src1,src1_f_re,src1_f_im);
	gonglvpu(src1_f_re,src1_f_im,src1_gonglv);
	cart2polar(src1_gonglv,src1_g_log);
	cv::normalize(src1_g_log,src1_g_log, 0, 1, CV_MINMAX);


	cv::Mat src2=imread(name2);
	if(src2.channels()!=1)
		cv::cvtColor(src2,src2,CV_RGB2GRAY);
	cv::Mat src2_f_re   =cv::Mat::zeros(src2.size(),CV_32FC1);
	cv::Mat src2_f_im   =cv::Mat::zeros(src2.size(),CV_32FC1);
	cv::Mat src2_gonglv =cv::Mat::zeros(src2.size(),CV_32FC1);
	cv::Mat src2_g_log  =cv::Mat::zeros(src2.size(),CV_32FC1);
	fourier(src2,src2_f_re,src2_f_im);
	gonglvpu(src2_f_re,src2_f_im,src2_gonglv);
	cart2polar(src2_gonglv,src2_g_log);
	cv::normalize(src2_g_log,src2_g_log, 0, 1, CV_MINMAX);
	int gx=0,gy=0;
	
	pingyi(src1_gonglv,src2_gonglv,gx,gy);
		//cout<<"max  "<<max<<"  min  "<<min<<endl;
	cout<<gx<<"   "<<gy<<endl;
	//pingyi(src1,src2,gx,gy);
	*/


应澜lst
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
isar的时频分析程序
05-14
isar的时频分析程序 isar的时频分析程序 isar的时频分析程序
opencv-python教程中文版.pdf
07-11
opencv-python官方教程中文版
【opencv学习笔记】第七篇：离散傅里叶变换
非晚非晚的博客
06-24 1252
离散傅里叶变换(Discrete Fourier Transform, DFT)， 是指傅里叶变换在时域和频域都呈现离散的形式，将时域信号的采样变换为在离散时间傅里叶变换(DTFT)频域的采样。对一幅图使用傅里叶变换就是将它分解成正弦和余弦两部分，也就是图像从空间域(spatial domain)转换到频域(frequency domain)。
指数函数、对数函数、双曲函数
一个搬运知识的笨小孩
10-07 4409
Chapter9：指数函数和对数函数4.指数函数与对数函数4.1 指数函数回顾4.2 对数函数回顾4.3 指数函数与对数函数互为反函数4.4 对数法则 4.指数函数与对数函数 4.1 指数函数回顾 底数指数底数^{指数}底数指数 4.2 对数函数回顾 y=2x=8y=2^x=8y=2x=8 x=log2(y)=log2(8)=3x=log_2(y)=log_2(8)=3x=log2​(y)=log2​(8)=3 代表着将2提升3个幂次才能得到8 logb(y)log_b(y)logb​(y)是为了得到
Matlab的函数及指令Functions and Commands
前 进的步伐
01-28 1925
A aabs 绝对值、模、字符的ASCII码值acos 反余弦 acosh 反双曲余弦 acot 反余切acoth 反双曲余切acsc 反余割 acsch 反双曲余割align 启动图形对象几何位置排列工具all 所有元素非零为真angle 相角ans 表达式计算结果的缺省变量名any 所有元素非全零为真area 面域图argnames 函数M文件宗量名asec 反正割asech 反双曲正割asi
opencv：计算二维矢量的幅值—magnitude()函数
热门推荐
Trace
05-11 2万+
计算二维矢量的幅值：magnitude()函数 该函数用来计算二维矢量的幅值 void magnitude(InputArray x,InputArray y,OutputArray magnitude) 第一个参数：InputArray类型的x，表示矢量的浮点型X坐标值，也就是实部 第二个参数：InputArray类型的y，表示矢量的浮点型Y坐标值，也就是虚部 第三个参数：OutputA
【OpenCV4】使用 magnitude() 函数计算幅值（c++）
AItrust的博客
08-05 1398
表示两个矩阵对应元素求平方和后开根号，形成的矩阵和 x 的大小，数据类型一致。
OpenCV学习记录 三 （傅里叶逆变换原理及实现）
weixin_51621120的博客
12-01 2573
为什么要在频率域研究图像增强？ 利用频率成分和图像外表之间的对应关系。滤波在频率域更为直观，它可以解释空间域滤波的某些性质。可以在频率域指定滤波器，做反变换，然后在空间域使用结果滤波器作为空间域滤波器的指导。一旦通过频率域试验选择了空间滤波，通常实施都在空间域进行。 傅里叶变换是为后面低通滤波或者说是高通滤波做准备，处理的是灰度图像。 一、傅里叶变换 傅里叶变换（Fourier Transform，FT）后，对同一事物的观看角度随之改变，可以从频域里发现一些从时域里不易察觉的特征。 原理：将满
OpenCV基础: 计算图像的梯度幅值/角度/HOG特征
水木年崋
11-28 6974
通过调用 magnitude / phase / cartToPolar, 分别实现梯度幅值/角度的单独计算和同时计算, 并输出/显示.
基于python的openCV自学笔记（三）——傅里叶变换与滤波、harris角点检测、SIFT、特征匹配和图像拼接
weixin_45719141的博客
07-22 1185
大四毕业后的这个暑假正式开始学习openCV 参考教程：唐宇迪老师： https://www.bilibili.com/video/BV1tb4y1C7j7 1.傅里叶变换 傅里叶变换的作用 高频：变化剧烈的灰度分量，例如边界 低频：变化缓慢的灰度分量，例如一片大海 滤波： 低通滤波器：只保留低频，会使图像模糊 高通滤波器：只保留高频，会使得图像细节增强 opencv中主要是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32格式。 得到的结果中频率为0的部分会在左上角，通常需
opencv-4.5.1.rar
04-13
opencv-4.5.1
opencv-alpine：OpenCV高山
02-04
opencv-alpine：OpenCV高山
opencv-4.6.0-android-sdk
10-11
opencv-4.6.0 android的SDK用于androidopencv的移植。 OpenCV是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和...
opencv-master
08-10
opencv人脸识别----GitHub下载全包 文件位置 opencv-master\data\haarcascades\haarcascade_frontalface_default.xml
关于opencv图像类型的转换
lst227405的专栏
05-19 1万+
在vs下进行opencv的开发时，从来没有或者很少关注过图像的类型 zhezhongbufuz
OpenCV中findContours所用的算法
lst227405的专栏
11-21 1万+
先上代码，opencv官方文档中的代码如下： #include "opencv2/highgui.hpp" #include "opencv2/imgproc.hpp" #include #include #include using namespace cv; using namespace std; Mat src; Mat src_gray; int thresh = 100;
Qt环境下利用opencv逐帧播放视频
lst227405的专栏
06-22 5254
头文件
opencv----计算互功率谱
lst227405的专栏
04-23 2976
不知道哪里有问题，出不来正确的结果 // fourier.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include #include #include #include using namespace cv; using namespace std; int _tmain
opencv中读取视频每一帧并且单独保存
lst227405的专栏
06-18 2266
while(true) { src>>frame_src; if(frame_src.empty()) { cout<<"game over!"<<endl; break; } cv::resize(frame_src,frame_tmp,cv::Size(512,512)); cv::cvtColor(frame_tmp,frame_dst,CV_RGB
如何用opencv-python将图片旋转
最新发布
06-09
可以使用OpenCV库中的函数`cv2.getRotationMatrix2D`和`cv2.warpAffine`来实现图像旋转。具体步骤如下： 1. 读入原始图像。 ```python import cv2 import numpy as np img = cv2.imread('image.jpg') ``` 2. 计算旋转矩阵。 ```python (h, w) = img.shape[:2] (center_x, center_y) = (w // 2, h // 2) # 图像中心点坐标 angle = 45 # 旋转角度 scale = 1.0 # 缩放比例 M = cv2.getRotationMatrix2D((center_x, center_y), angle, scale) ``` `cv2.getRotationMatrix2D`函数的第一个参数是旋转中心点的坐标，第二个参数是旋转角度，第三个参数是缩放比例。 3. 进行图像旋转。 ```python rotated_img = cv2.warpAffine(img, M, (w, h)) ``` `cv2.warpAffine`函数的第一个参数是原始图像，第二个参数是旋转矩阵，第三个参数是输出图像的大小。 完整代码如下： ```python import cv2 import numpy as np img = cv2.imread('image.jpg') (h, w) = img.shape[:2] (center_x, center_y) = (w // 2, h // 2) angle = 45 scale = 1.0 M = cv2.getRotationMatrix2D((center_x, center_y), angle, scale) rotated_img = cv2.warpAffine(img, M, (w, h)) cv2.imshow('Rotated Image', rotated_img) cv2.waitKey(0) cv2.destroyAllWindows() ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值