基于opencv对图像进行任意角度旋转，翻转，缩放，加噪，去噪，亮度均匀，反色代码演示

已于 2022-08-17 10:53:04 修改
阅读量1.8k 收藏 10
点赞数 1
文章标签： opencv 人工智能 计算机视觉
于 2022-08-16 09:43:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61735576/article/details/126359273
版权

目录

任意角度旋转：

任意方向翻转

缩放

加噪（两种方法）

去噪（四种方法）

亮度均匀与反色

全程opencv+vs

很多都是opencv封装的库函数

拼凑一下，调调参就出了

程序设计毒瘤课

任意角度旋转：

原理可以参考(63条消息) 经验 | OpenCV图像旋转的原理与技巧_小白学视觉的博客-CSDN博客


#include<bits/stdc++.h>
#include<opencv2/opencv.hpp>
using namespace std;
const double pii = acosl(-1.0);
//计算点point2绕点point1逆时针旋转angle度后得到新的点newPoint
void rotatePoint(cv::Point& point1, cv::Point& point2, cv::Point& newPoint, double angle)
{
	int dx, dy;
	double dx1, dy1;
	dy1 = -((double)point2.x - point1.x) * sin(angle) + ((double)point2.y - point1.y) * cos(angle);
	dx1 = ((double)point2.x - point1.x) * cos(angle) + ((double)point2.y - point1.y) * sin(angle);
	if (dx1 - (int)dx1 > 0.5)    //做一个四舍五入
		dx = (int)dx1 + 1;
	else
	{
		if (dx1 - (int)dx1 < -0.5)
			dx = (int)dx1 - 1;
		else
			dx = (int)(dx1);
	}
	if (dy1 - (int)dy1 > 0.5)   //做一个四舍五入
		dy = (int)dy1 + 1;
	else
	{
		if (dy1 - (int)dy1 < -0.5)
			dy = (int)dy1 - 1;
		else
			dy = (int)(dy1);
	}
	newPoint.x = point1.x + dx;
	newPoint.y = point1.y + dy;
}
void translationPoint(cv::Point& point, int x, int y) //平移运算
{
	point.x = point.x + x;
	point.y = point.y + y;
}
int Max4(int a[4])    //获取四个数中的最大值
{
	int max = a[0];
	for (int i = 1; i < 4; i++)
	{
		if (max < a[i])
			max = a[i];
	}
	return max;
}

int Min4(int a[4])    //获取四个数中的最小值
{
	int min = a[0];
	for (int i = 1; i < 4; i++)
	{
		if (min > a[i])
			min = a[i];
	}
	return min;
}

int absMax4(int a[4])
{
	int max = 0, m;
	for (int i = 0; i < 4; i++)
	{
		if (a[i] < 0)
			m = -a[i];
		else m = a[i];
		if (max < m)
			max = m;
	}
	return max;
}

void rotateImage(cv::Mat inputMat, cv::Mat& outputMat, std::vector<cv::Point> points, cv::Point point, double angle)
{
	std::vector<cv::Point> newPoints;
	cv::Point newP;
	for (int i = 0; i < 4; ++i)
	{
		if (points[i] != point)  //判断输入的4个顶点是否与旋转点point相同
		{
			rotatePoint(point, points[i], newP, angle);  //顶点points[i]与旋转点point不同，则进行旋转计算
			newPoints.push_back(newP);
		}
		else
		{
			newPoints.push_back(points[i]);
		}
	}
	//获取经旋转后，新图像的大小，其中w表示图像宽长，h表示图像高长。
	int w = 0, h = 0;
	int suw[4] = { newPoints[1].x - newPoints[0].x,newPoints[1].x - newPoints[3].x,
		newPoints[2].x - newPoints[0].x,newPoints[2].x - newPoints[3].x };
	int suh[4] = { newPoints[2].y - newPoints[0].y ,newPoints[2].y - newPoints[1].y,
		newPoints[3].y - newPoints[0].y,newPoints[3].y - newPoints[1].y };
	w = absMax4(suw);
	h = absMax4(suh);
	//获取需要旋转的四边形区域的外接矩形表示区域范围（x_min,y_min)、(x_max,y_max)
	int y_max, y_min, x_max, x_min;
	int points_x[4] = { points[0].x,points[1].x,points[2].x,points[3].x };
	int points_y[4] = { points[0].y,points[1].y,points[2].y,points[3].y };
	y_max = Max4(points_y);
	y_min = Min4(points_y);
	x_max = Max4(points_x);
	x_min = Min4(points_x);
	//计算向x轴的平移量dx,向y轴的平移量dy
	int dx, dy;
	int a[4] = { newPoints[0].x,newPoints[1].x,newPoints[2].x,newPoints[3].x };
	int b[4] = { newPoints[0].y,newPoints[1].y,newPoints[2].y,newPoints[3].y };
	dx = Min4(a);
	dy = Min4(b);
	//初始化输出矩阵
	if (inputMat.type() == CV_8UC1)
		cv::Mat(h, w, CV_8UC1, cv::Scalar::all(255)).copyTo(outputMat);
	if (inputMat.type() == CV_8UC3)
		cv::Mat(h, w, CV_8UC3, cv::Scalar(255, 255, 255)).copyTo(outputMat);
	//实现I(x',y')=I(x,y)
	double z1, z2, z3, z4;
	for (int i = y_min; i < y_max; ++i)
	{
		for (int j = x_min; j < x_max; ++j)
		{
			//四边形顶点A为points[0],顶点B为points[1],顶点C为points[2],顶点D为points[3].
  //直线AB
			z1 = i - (double)points[0].y -
				(j - (double)points[0].x) * ((double)points[0].y - points[1].y) / ((double)points[0].x - points[1].x);
			//直线BC
			z2 = j - (double)points[1].x -
				(i - (double)points[1].y) * ((double)points[1].x - points[2].x) / ((double)points[1].y - points[2].y);
			//直线CD
			z3 = i - (double)points[2].y -
				(j - (double)points[2].x) * ((double)points[2].y - points[3].y) / ((double)points[2].x - points[3].x);
			//直线AD
			z4 = j - (double)points[0].x -
				(i - (double)points[0].y) * ((double)points[0].x - points[3].x) / ((double)points[0].y - points[3].y);
			if (z1 >= 0 && z2 <= 0 && z3 <= 0 && z4 >= 0)
			{
				cv::Point point0(j, i);
				rotatePoint(point, point0, point0, angle);  //将点point0绕点point旋转angle度得到新的点point0
				translationPoint(point0, -dx, -dy);
				if (point0.x >= 0 && point0.x < w && point0.y >= 0 && point0.y < h)
				{
					if (inputMat.type() == CV_8UC1)
					{
						uchar* str = inputMat.ptr<uchar>(i);
						outputMat.at<uchar>(point0.y, point0.x) = str[j];
					}
					if (inputMat.type() == CV_8UC3)
					{
						cv::Vec3b* str = inputMat.ptr<cv::Vec3b>(i);
						outputMat.at<cv::Vec3b>(point0.y, point0.x) = str[j];
					}
				}
			}
		}
	}
	if (inputMat.type() == CV_8UC1)
	{   //插值
		for (int i = 1; i < outputMat.rows - 1; ++i)
		{
			for (int j = 1; j < outputMat.cols - 1; ++j)
			{
				if (outputMat.at<uchar>(i, j) == 255)
				{
					int sum = 0;
					uchar* str1 = outputMat.ptr<uchar>(i - 1);
					sum = str1[j - 1] + str1[j] + str1[j + 1];
					uchar* str2 = outputMat.ptr<uchar>(i);
					sum = sum + str2[j - 1] + str2[j + 1];
					uchar* str3 = outputMat.ptr<uchar>(i + 1);
					sum = sum + str3[j - 1] + str3[j] + str3[j + 1];
					sum = sum / 8;
					outputMat.at<uchar>(i, j) = (uchar)sum;
				}
			}
		}
	}
	if (inputMat.type() == CV_8UC3)
	{   //插值
		for (int i = 1; i < outputMat.rows - 1; ++i)
		{
			for (int j = 1; j < outputMat.cols - 1; ++j)
			{
				if (outputMat.at<cv::Vec3b>(i, j) == cv::Vec3b(255, 255, 255))
				{
					int sum[3] = { 0,0,0 };
					uchar r, g, b;
					for (int k = 0; k < 3; k++)
					{
						cv::Vec3b* str1 = outputMat.ptr<cv::Vec3b>(i - 1);
						sum[k] = str1[j - 1][k] + str1[j][k] + str1[j + 1][k];
						cv::Vec3b* str2 = outputMat.ptr<cv::Vec3b>(i);
						sum[k] = sum[k] + str2[j - 1][k] + str2[j + 1][k];
						cv::Vec3b* str3 = outputMat.ptr<cv::Vec3b>(i + 1);
						sum[k] = sum[k] + str3[j - 1][k] + str3[j][k] + str3[j + 1][k];
						sum[k] = sum[k] / 8;
					}
					r = (uchar)sum[0];
					g = (uchar)sum[1];
					b = (uchar)sum[2];
					outputMat.at<cv::Vec3b>(i, j) = cv::Vec3b(r, g, b);
				}
			}
		}
	}
}
int main()
{
	cv::Mat srcImage = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (srcImage.empty())
	{
		printf("图片读取失败！\n");
		return -1;
	}
	//需要旋转的图像区域四个顶点

	std::vector<cv::Point> points;
	points.push_back(cv::Point(0, 0));    //顶点A
	points.push_back(cv::Point(srcImage.cols, 0));  //顶点B
	points.push_back(cv::Point(srcImage.cols, srcImage.rows));  //顶点C
	points.push_back(cv::Point(0, srcImage.rows));

	cv::Mat outputImage;
	cout << "请输入旋转中心" << endl;
	cout << "为方便用户在不知道总像素时操作，把图看成100*100的矩形，请输入相对旋转中心（例：50 50为中心点）" << endl;
	int starx, stary;
	cin >> starx >> stary;
	starx = (double)starx / 100.0 * srcImage.cols;
	stary = (double)stary / 100.0 * srcImage.rows;
	cout << "请输入旋转的角度（逆时针）" << endl;
	double poi;
	cin >> poi;
	rotateImage(srcImage, outputImage, points, cv::Point(starx, stary), poi / 180 * pii);
	cv::imshow("原图", srcImage);
	cv::imshow("旋转得到的图像", outputImage);
	cv::waitKey(0);
	return 0;
}

任意方向翻转

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

using namespace cv;
using namespace std;

int main() {
	Mat src = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}

	Mat dst;
	// X Flip 倒影
	char s[10] = "";
	cout << "请输入翻转对称轴（x/y/xy）" << endl;
	cin >> s;
	imshow("input", src);
	if (s[0] == 'x' && s[1] == 'y') {
		flip(src, dst, -1);
		imshow("xy-flip", dst);
	}
	else if (s[0] == 'y') {
		flip(src, dst, 1);
		imshow("y-flip", dst);
	}
	else if (s[0] == 'x') {
		flip(src, dst, 0);
		imshow("x-flip", dst);
	}
	else {
		cout << "请输入正确的反转对称轴" << endl;
	}

	waitKey(0);
	return 0;
}

缩放

#include<iostream>
#include"opencv2/imgproc/imgproc.hpp"
#include"opencv2/highgui/highgui.hpp"
#include<opencv2/core/core.hpp>
using namespace std;
using namespace cv;
int main()
{
	//用mat读取
	Mat src = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (src.empty()) {
		cout << "文件读取失败！" << endl;
		system("pause");
		return -1;
	}
	cout << "输入您想缩小/放大的比例(小于100为缩小，大于100为放大)" << endl;
	cout << "x轴->____ " << "y轴变成->____" << endl;
	double szx, szy;
	cin >> szx >> szy;
	szx /= 100;
	szy /= 100;
	imshow("src", src);//原图像显示
	Mat res;
	resize(src, res, Size(src.cols * szx, src.rows * szy), 0, 0, INTER_LINEAR);// X Y各缩小一半
	imshow("res", res);//显示缩放过后的结果

	waitKey(0);
	return 0;
}

加噪（两种方法）

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

using namespace cv;
using namespace std;
void addguessnoise(Mat src,int fz,int fm) {
	Mat img_noise = Mat::zeros(src.rows, src.cols, src.type());
	RNG rng;                                   //创建一个RNG类
	rng.fill(img_noise, RNG::NORMAL, 50, 50*fz*2/fm);
	imshow("三通道高斯噪声", img_noise);
	src = src + img_noise;
	imshow("result", src);
}
void addluffynoise(Mat src,int fz,int fm) {
	RNG rng(12345);
	int w = src.cols;
	int h = src.rows;
	int nums = 100000;
	for (int i = 0; i < nums; i++) {
		if (i % fm >= fz) continue;
		int x = rng.uniform(0, w);
		int y = rng.uniform(0, h);
		if (i % 2 == 1) {
			src.at<Vec3b>(y, x) = Vec3b(255, 255, 255);
		}
		else {
			src.at<Vec3b>(y, x) = Vec3b(0, 0, 0);
		}
	}
	imshow("src", src);
}
int main() {
	Mat src = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	char s[50];
	cout << "请输入您想加噪的类型（g：高斯噪声）（l：椒盐噪声）" << endl;
	cin >> s;
	int fz, fm;
	cout << "请输入您想加噪的密度（输入a,b代表a/b，越大密度越大）" << endl;
	cin >> fz >> fm;
	if (s[0] == 'g') {
		addguessnoise(src,fz,fm);
	}
	else {
		addluffynoise(src, fz, fm);
	}
	waitKey(0);
	return 0;
}

去噪（四种方法）

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

using namespace cv;
using namespace std;
void add_salt_pepper_noise(Mat& image) {
	RNG rng(12345);
	int h = image.rows;
	int w = image.cols;
	int nums = 10000;
	for (int i = 0; i < nums; i++) {
		int x = rng.uniform(0, w);
		int y = rng.uniform(0, h);
		if (i % 2 == 1) {
			image.at<Vec3b>(y, x) = Vec3b(255, 255, 255);
		}
		else {
			image.at<Vec3b>(y, x) = Vec3b(0, 0, 0);
		}
	}
	imshow("salt pepper", image);
}
void gaussian_noise(Mat& image) {
	Mat noise = Mat::zeros(image.size(), image.type());
	randn(noise, (15, 15, 15), (30, 30, 30));
	Mat dst;
	add(image, noise, dst);
	imshow("gaussian noise", dst);
	dst.copyTo(image);
}
int main() {
	Mat src = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	cout << "请输入您想去噪的方法" << endl;
	cout << "(1:均值滤波)(2：高斯滤波)(3：中值滤波)(4：非局部均值去噪)" << endl;
	int ind;
	cin >> ind;
	namedWindow("input", WINDOW_AUTOSIZE);
	gaussian_noise(src);
	Mat result1, result2, result3, result4;
	if (ind == 1) {
		blur(src, result1, Size(5, 5));
		imshow("result-1", result1);
	}
	else if (ind == 2) {
		GaussianBlur(src, result2, Size(5, 5), 0);
		imshow("result-2", result2);
	}
	else if (ind == 3) {
		medianBlur(src, result3, 5);
		imshow("result-3", result3);
	}
	else {
		fastNlMeansDenoisingColored(src, result4, 15, 15, 10, 30);
		imshow("result-4", result4);
	}

	waitKey(0);
	return 0;
}

亮度均匀与反色

#include<opencv2/opencv.hpp>
#include<iostream>
#include <opencv2\imgproc\types_c.h>

using namespace cv;
using namespace std;
void light_avg(Mat srcImage) {
	imshow("srcImage", srcImage);
	Mat srcGray;
	cvtColor(srcImage, srcGray, CV_BGR2GRAY);
	Mat heqResult;
	equalizeHist(srcGray, heqResult);
	imshow("heqResult", heqResult);
}
void recolor(Mat src) {
	imshow("src", src);
	Mat dst;
	dst.create(src.size(), src.type());
	int height = src.rows;
	int width = src.cols;
	int nc = src.channels();
	//b,g,r 三通道
	int b;
	int g;
	int r;
	for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			b = src.at<Vec3b>(row, col)[0];
			g = src.at<Vec3b>(row, col)[1];
			r = src.at<Vec3b>(row, col)[2];
			dst.at<Vec3b>(row, col)[0] = 255 - b;
			dst.at<Vec3b>(row, col)[1] = 255 - g;
			dst.at<Vec3b>(row, col)[2] = 255 - r;
		}
	}
	imshow("dst", dst);
	
}
int main() {
	Mat src = cv::imread("D:\\Cpan\\Download\\12.jpg");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	cout << "亮度均匀处理 or 反色处理（1或2）" << endl;
	int ind;
	cin >> ind;
	if (ind == 1) {
		light_avg(src);
	}
	else {
		recolor(src);
	}
	waitKey(0);
	return 0;
}

lxrrrrrrrr
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
opencv任意角度旋转
qwerqwerdhr的博客
08-27 553
opencv常规角度旋转就用cv::rotate，参数0,1，2可以进行90,180,270度旋转，运行速度也比较快。
opencv 实现图像任意角度的旋转
12-07
用opencv 2.4.9实现图像任意角度的旋转
opencv实现图片的任意角度旋转
热门推荐
u013263891的博客
11-10 4万+
一 旋转角度坐标的计算 1.如果O点为圆心,则点P绕点O旋转redian弧度之后,点P的坐标变换为点Q的计算公式为: Q.x=P.x*cos(redian)-P.y*sin(redian) Q.y=P.x*sin(redian)+P.y*cos(redian) redian表示的为弧度 弧度与角度的变换公式为: redian=pi*180/angle 2. 如果O点不是圆心,则点P绕...
OpenCV中图像的缩放与旋转讲解及实战演示（附Python源码）_opencv缩放图像
最新发布
2401_84139624的博客
05-15 341
interpolation 可选参数 缩放的插值方式dst 缩值之后的图像resize方法有两种使用方式，一种是通过dsize参数实现缩放，另一种是通过fx和fy参数实现缩放 下面分别介绍。
OpenCV实现图像任意角度旋转
Jerry0131的专栏
02-28 785
opencv实现图像任意角度旋转
利用opencv怎样旋转一幅图像
yangSHU21的博客
06-11 2460
在进行图像旋转的过程中，图像以旋转中心为坐标原点，最终完成旋转还需要将坐标原点移动到图像的左上角。旋转后图像的尺寸可以由图像极值点确定，设旋转后图像的最左边点的横坐标为lxmin，最右边的横坐标为lxmax，最高点的纵坐标为lymin，最低点的纵坐标为lymax.而旋转时一般使用的是常见的笛卡尔坐标系，向右为X正方向，向上为Y正方向。第一步先解释坐标系转换的过程。图像旋转后图像的水平对称轴、垂直对称轴以及中心坐标原点可能都会发生变换，因此需要对图像旋转中的坐标进行相应的转换。第二步解释旋转的过程。
图像加噪去噪_opencv_双边滤波方法_加噪去噪_中值滤波_图像处理_
09-29
在这个项目中，`图像加噪去噪.cpp` 文件很可能是实现这些滤波算法的主要代码。通过调用OpenCV库中的函数，比如`cv::GaussianBlur`（高斯滤波）、`cv::medianBlur`（中值滤波）和`cv::bilateralFilter`（双边滤波），...
图像加噪去噪.cpp
11-28
基于OpenCV的二维图像加噪去噪C++程序，程序包含给图像添加高斯噪声功能，去噪方法有方框滤波、均值滤波、高斯滤波、中值滤波、双边滤波
基于OpenCV的图像翻转和镜像.zip
04-21
这个名为"基于OpenCV的图像翻转和镜像"的压缩包文件着重介绍了如何利用OpenCV库来实现图像的翻转和镜像操作。在Python编程语言中，OpenCV提供了便捷的接口来完成这些功能。 首先，图像翻转是一种常见的图像操作，它...
基于OpenCV的的图像旋转匹配算法模板（C++实现）
01-02
基于OpenCv实现了模板图像的旋转匹配，此代码基于matchTemplate函数封装实现可以得知旋转角度的模板匹配（vs2013+opencv2.4.9） 2.带旋转的模板匹配的原理及算法实现(c++) 带旋转的模板匹配算法，能够匹配带旋转...
OpenCV-Python学习（20）—— OpenCV 图像几何变换之图像旋转（cv.warpAffine、cv.getRotationMatrix2D、cv.rotate、np.rot90）
止于至善
02-12 6461
cv.rotate 和 np.rot90 两个方法只能旋转特殊角度，只能是90度的整数倍数。cv.warpAffine 可以对图像进行任意角度旋转；实现自定原点旋转，需要借助 cv.getRotationMatrix2D 计算变化矩阵；cv.getRotationMatrix2D 的实现原理需要注意旋转角度对应的顺【逆】时针旋转！！！注意：cv.getRotationMatrix2D 的旋转角度【逆时针为正数，顺时针为负数！！
OPENCV入门教程九：图像旋转任意角度
李大宝的专栏
08-03 6523
一、目标学习如何旋转图片。二、函数说明在OpenCV中，没有现成的函数直接用来实现图像旋转，它是用仿射变换函数warpAffine来实现的，此函数目前支持4种插值算法，最近邻、双线性、双三次、兰索斯插值。 函数原型：void warpAffine(InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_L
【轻松驾驭】OpenCV图像旋转的原理与技巧
关注微信公众号【OpenCV学堂】
12-20 1847
掌握图像旋转的基本原理与代码技巧
使用Python，OpenCV旋转图像任意角度（完整和局部丢失~）
qq_40985985的博客
06-19 9820
这篇博客将介绍如何使用OpenCV旋转图像。并演示如何使用imutils库中的两个方便函数imutils.rotate和imutils.rotate_bound不丢失细节的旋转图像。
【机器视觉学习笔记】最近邻插值实现图片任意角度旋转（C++）
乙酸氧铍的博客
09-24 2134
目录源码RotateImage主函数效果完整源码 平台：Windows 10 20H2 Visual Studio 2015 OpenCV 4.5.3 源码 RotateImage Mat RotateImage(Mat src, double angle) { int x0, y0, x1, y1; angle = angle * 3.1415926535897932384626433832795 / 180; int dx = abs((int)src.cols*cos(angle)) +
OpenCV环境下实现图像任意角度旋转的原理及代码
昊虹AI笔记
12-24 1451
OpenCV环境下实现图像任意角度旋转的原理及代码
Opencv图像任意角度旋转
qq_19655645的博客
03-20 8642
实现图像的任意角度旋转特殊角度（90，180，270）旋转Mat img2, src; transpose(img, img2); flip(img2, src, 0);将图像img向左旋转90度（转置后沿x轴翻转）flip(img2, src, 0);将图像img向右旋转90度（转置后沿y轴翻转）flip(img2, src, 1);将图像img向旋转180度（转置后沿x和y轴翻转）flip(i...
【OpenCV 例程200篇】27. 图像的旋转（以任意点为中心）
youcans的博客
11-14 8324
图像以任意点 (x0, y0) 为旋转中心、顺时针旋转角度 θ 的旋转操作，可以先将原点平移到旋转中心 (x0, y0) ，然后按照原点旋转，最后再平移回坐标原点。 按上式构造旋转变换矩阵 MAR，由函数 **cv2.warpAffine** 可以计算变换后的绕原点旋转图像。 OpenCV 提供了 **cv2.getRotationMatrix2D** 函数， 根据旋转角度和位移计算旋转变换矩阵 MAR。...
opencv C++ 旋转任意角度图片
qq_40622955的博客
07-28 5013
摘要：opencv里面似乎没有直接的旋转图片的接口，这里实现一个旋转任意角度的方法，在旋转的时候调用opencv里面的仿射变换函数实现。有两种旋转模式：一种按图片中心旋转，尺寸与原图一致；另外一种模式是扩充图片尺寸以包含所有像素点。 文章目录1. 示例：2. 原理旋转平移的坐标变换3. 两种方式4. 源码 1. 示例： 2. 原理 旋转平移的坐标变换 设有任意一点p，在平面直角坐标中其坐标为(x,y),在平面极坐标系中其坐标为(ρ,θ)p，在平面直角坐标中其坐标为(x,y), 在平面极坐标系中其坐标为(\
基于OpenCV库的Python代码实现，实现对图像进行旋转
06-08
好的，以下是一个基于OpenCV库的Python代码实现，实现对图像进行旋转的例子： ``` python import cv2 import numpy as np # 读取图像并获取图像大小 img = cv2.imread('image.jpg') h, w = img.shape[:2] # 定义旋转角度和缩放比例 angle = 45 # 旋转角度 scale = 1 # 缩放比例 # 计算旋转后图像的大小 new_h = int(w * np.abs(np.sin(np.radians(angle))) + h * np.abs(np.cos(np.radians(angle)))) new_w = int(h * np.abs(np.sin(np.radians(angle))) + w * np.abs(np.cos(np.radians(angle)))) # 定义旋转矩阵 M = cv2.getRotationMatrix2D((w / 2, h / 2), angle, scale) # 执行旋转操作 img_rotate = cv2.warpAffine(img, M, (new_w, new_h)) # 显示旋转后的图像 cv2.imshow('Rotate', img_rotate) cv2.waitKey(0) cv2.destroyAllWindows() ``` 注意，本例中的图像是从文件中读取的，你需要将代码中的'image.jpg'替换为你自己的图像文件名。同时，你可以根据自己的需求修改旋转角度和缩放比例等参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值