OpenCV：图像几何变换（镜像，错切，缩放，旋转）

最新推荐文章于 2023-05-15 17:32:33 发布
最新推荐文章于 2023-05-15 17:32:33 发布
阅读量5.2k 收藏 26
点赞数 15
分类专栏： opencv image processing 文章标签： opencv image processing image warping
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38901147/article/details/83930372
版权

        图像的几何变换是各种图像处理的基础，一般来说图像的几何变换是在不改变原有图像像素的基础上进行的，几何变换相当于是原图像到新图像的一种映射。图像的几何变换基本有镜像，平移、错切，缩放，旋转。常用的几何变换方法有“向前映射”和”向后映射“。对于图像大小不改变的几何变换，如镜像、平移等，一般采用“向前映射”，对于图像大小改变的几何变形，如错切、缩放、旋转，一般采用“向后映射”。

       “向前映射”是指将输入图像像素一个个的映射到输出图像。如果输入像素被映射到四个输出像素之间的位置，则其像素值按插值算法在四个输出像素之间分配。

        “向后映射”是指输出像素一个个地映射回输入图像中，以确定其像素值。如果输出像素被映射到邻近的四个输入像素之间，则其像素值由插值决定。

常用的插值方法：双线性插值

一、镜像变换

镜像变换分为水平镜像和垂直镜像。水平镜像以图像垂直中轴线为对称轴，垂直镜像以图像水平中轴线为对称轴。设点P_{0}(x_{0},y_{0})进行镜像后的对应点为P(x,y)，图像高度为H，宽度为W。

经过水平镜像后，原图像P_{0}(x_{0},y_{0})坐标变为P(W-x_{0},y_{0})。

矩阵表达式为：\begin{bmatrix} x \\ y \\1 \end{bmatrix}=\begin{bmatrix} -1 & 0 & W\\ 0& 1 & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x_{0}\\ y_{0} \\ 1 \end{bmatrix}

逆运算为：\begin{bmatrix} x_{0} \\ y_{0} \\1 \end{bmatrix}=\begin{bmatrix} -1 & 0 & W\\ 0& 1 & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x\\ y\\ 1 \end{bmatrix}

经过垂直镜像后，原图像P_{0}(x_{0},y_{0})坐标变为P(x_{0},H-y_{0})

矩阵表达式为：\begin{bmatrix} x \\ y \\1 \end{bmatrix}=\begin{bmatrix} 1 & 0 & 0\\ 0& -1 & H\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x_{0}\\ y_{0} \\ 1 \end{bmatrix}

逆运算为：\begin{bmatrix} x_{0} \\ y_{0} \\1 \end{bmatrix}=\begin{bmatrix} 1 & 0 & 0\\ 0& -1 & H\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x\\ y\\ 1 \end{bmatrix}

具体程序如下：

#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include "opencv2/opencv.hpp"

int main()
{
	const char *filename = "island.bmp";
	IplImage *inputimage = cvLoadImage(filename, -1);
	// x_mirror(垂直镜像),y_mirror(水平镜像),xy_mirror(中心对称)
	IplImage *xmirrorimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
	IplImage *ymirrorimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
	IplImage *xymirrorimage = cvCreateImage(cvSize(inputimage->width, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);

	for (int i = 0; i < xmirrorimage->height; i++)
	{
		for (int j = 0; j < xmirrorimage->width; j++)
		{
			for (int k = 0; k < xmirrorimage->nChannels; k++)
			{
				ymirrorimage->imageData[i*ymirrorimage->widthStep + j * ymirrorimage->nChannels + k]
					= inputimage->imageData[i*inputimage->widthStep + (inputimage->width - 1 - j)*inputimage->nChannels + k];

				xmirrorimage->imageData[i*xmirrorimage->widthStep + j * xmirrorimage->nChannels + k]
					= inputimage->imageData[(inputimage->height-1-i)*inputimage->widthStep + j*inputimage->nChannels + k];

				xymirrorimage->imageData[i*xymirrorimage->widthStep + j * xymirrorimage->nChannels + k]
					= inputimage->imageData[(inputimage->height - 1 - i)*inputimage->widthStep + (inputimage->width-1-j) * inputimage->nChannels + k];
			}
		}
	}

	cvNamedWindow("inputimage", 1);
	cvNamedWindow("ymirrorimage", 1);
	cvNamedWindow("xmirrorimage", 1);
	cvNamedWindow("xymirrorimage", 1);

	cvShowImage("inputimage", inputimage);
	cvShowImage("ymirrorimage", ymirrorimage);
	cvShowImage("xmirrorimage", xmirrorimage);
	cvShowImage("xymirrorimage", xymirrorimage);
	cvWaitKey(0);

	cv::Mat amplification = cv::cvarrToMat(ymirrorimage);
	cv::Mat amplification1 = cv::cvarrToMat(xmirrorimage);
	cv::Mat amplification2 = cv::cvarrToMat(xymirrorimage);
	cv::imwrite("ymirrorimage.bmp", amplification);
	cv::imwrite("xmirrorimage.bmp", amplification1);
	cv::imwrite("xymirrorimage.bmp", amplification2);

	cvDestroyWindow("inputimage");
	cvDestroyWindow("ymirrorimage");
	cvDestroyWindow("xmirrorimage");
	cvDestroyWindow("xymirrorimage");

	cvReleaseImage(&inputimage);
	cvReleaseImage(&ymirrorimage);
	cvReleaseImage(&xmirrorimage);
	cvReleaseImage(&xymirrorimage);
}

二、错切变换


#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include<math.h>
#include "opencv2/opencv.hpp"
//#define pi 3.141592653;   //定义pi的值
//#define a pi/4;

int main()
{
	float pi = 3.141592653;
	float a = pi / 3;//错切角度
	const char *filename = "island.bmp";
	IplImage *inputimage = cvLoadImage(filename, -1);

	IplImage *x_shear = cvCreateImage(cvSize((inputimage->width+inputimage->height/tan(a)), inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
	IplImage *y_shear = cvCreateImage(cvSize(inputimage->width, (inputimage->height + inputimage->width / tan(a))), IPL_DEPTH_8U, inputimage->nChannels);

	for (int i = 0; i < x_shear->height; i++)
	{
		for (int j = 0; j < x_shear->width; j++)
		{
			for (int k = 0; k < x_shear->nChannels; k++)
				if (j < x_shear->height / tan(a) - i / tan(a) || j > x_shear->height / tan(a) - i / tan(a) + inputimage->width)
					x_shear->imageData[i*x_shear->widthStep + j*x_shear->nChannels + k]
					= 0;
				else
					x_shear->imageData[i*x_shear->widthStep+ j*x_shear->nChannels+k]
						= inputimage->imageData[i*inputimage->widthStep+ (j - int(x_shear->height / tan(a) - i / tan(a)))*inputimage->nChannels+k];
		}
	}

	for (int i = 0; i < y_shear->height; i++)
	{
		for (int j = 0; j < y_shear->width; j++)
		{
			for (int k = 0; k < y_shear->nChannels; k++)
				if(i < y_shear->width / tan(a) - j / tan(a) || i > y_shear->width / tan(a) - j / tan(a) + inputimage->height)
					y_shear->imageData[i*y_shear->widthStep + j * y_shear->nChannels + k]
					= 0;
				else
					y_shear->imageData[i*y_shear->widthStep + j *y_shear->nChannels + k]
						= inputimage->imageData[(i- int(y_shear->width / tan(a) - j / tan(a)))*inputimage->widthStep + j * inputimage->nChannels + k];
		}
	}

	cvNamedWindow("inputimage", 1);
	cvNamedWindow("x_shear", 1);
	cvNamedWindow("y_shear", 1);
	//显示图像
	cvShowImage("inputimage", inputimage);
	cvShowImage("x_shear", x_shear);
	cvShowImage("y_shear", y_shear);
	cvWaitKey(0);
	//保存图像
	cv::Mat amplification1 = cv::cvarrToMat(x_shear);
	cv::Mat amplification2 = cv::cvarrToMat(y_shear);
	cv::imwrite("x_island.bmp", amplification1);
	cv::imwrite("y_island.bmp", amplification2);

	cvDestroyWindow("inputimage");
	cvDestroyWindow("x_shear");
	cvDestroyWindow("y_shear");

	cvReleaseImage(&inputimage);
	cvReleaseImage(&x_shear);
	cvReleaseImage(&y_shear);
}

以下为原图及延水平方向和垂直方向不同角度的错切

三、图像缩放

        图像比例缩放是将给定图像在x轴方向按比例缩放f_{x}倍，在y轴方向缩放f_{y}倍，得到新图像。如果f_{x}=f_{y}，即x轴与y轴缩放比例相同，称为全比例缩放。比例缩放前后，两点P_{0}(x_{0},y_{0})，P(x,y)之间的关系矩阵表达式如下，

矩阵表达式为：\begin{bmatrix} x \\ y \\1 \end{bmatrix}=\begin{bmatrix} f_{x} & 0 & 0\\ 0& f_{y} & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x_{0}\\ y_{0} \\ 1 \end{bmatrix}

逆运算为：\begin{bmatrix} x_{0} \\ y_{0} \\1 \end{bmatrix}=\begin{bmatrix} 1/f_{x} & 0 & 0\\ 0& 1/f_{y} & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x\\ y \\ 1 \end{bmatrix}，即 \left\{\begin{matrix} x_{0}=x/f_{x}\\ y_{0}=y/f_{y} \end{matrix}\right.

       图像的比例缩小，因为缩小后信息量变少，只需在原图像中按缩小比例隔行隔列选取像素点即可，构成新图像。

       图像的比例放大，放大后的图像像素点变多，有些放大后的图像像素在原图像中找不到对应像素，需要进行近似处理。常用方法有两种（1）直接赋值为和他最相近的像素点（2）通过插值计算相应像素值。第一种计算方法虽然简单，但是会造成图像马赛克现象；第二种方法处理效果好些，但是运算量加大。

我们采用“向后映射”的方法，用双线性插值计算放大后图像的像素值。

 

放大后灰度值计算如下（彩色图像对RGB三通道分别按如下公式计算）：

g(x,y)=(1-q)*\left ( (1-p)*f([x],[y])+p*f([x]+1,[y]) \right )+ q*\left ( (1-p)*f([x],[y]+1)+p*f([x]+1,[y]+1) \right )

式中：g(x,y)为插值后新图像坐标(x,y)的灰度值；f(x,y)为插值前坐标(x,y)的灰度值；[x]，[y]分别为不大于x，y的整数。

#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include<math.h>
#include "opencv2/opencv.hpp"

int main()
{
	 //amplification
	const char *filename = "island.bmp";
	IplImage *inputimage = cvLoadImage(filename, -1);
	float multiple = 2.5;//放大倍数
	IplImage * ScaleAmplifying = cvCreateImage(cvSize(inputimage->width * multiple, inputimage->height * multiple), IPL_DEPTH_8U, inputimage->nChannels);
	IplImage * X_Amplifying = cvCreateImage(cvSize(inputimage->width * multiple, inputimage->height), IPL_DEPTH_8U, inputimage->nChannels);
	IplImage * Y_Amplifying = cvCreateImage(cvSize(inputimage->width , inputimage->height * multiple), IPL_DEPTH_8U, inputimage->nChannels);
	//比例缩放
	for (int i = 0; i < ScaleAmplifying->height; i++)
	{
		for (int j = 0; j < ScaleAmplifying->width; j++)
		{
			for (int k = 0; k < ScaleAmplifying->nChannels; k++)
			{
				float q = i / multiple - floor(i / multiple);
				float p = j / multiple - floor(j / multiple);
				int x = floor(i / multiple);
				int y = floor(j / multiple);
				if (q < 0.001 && p < 0.001)
				{
					ScaleAmplifying->imageData[i*ScaleAmplifying->widthStep + j * ScaleAmplifying->nChannels + k]
						= inputimage->imageData[x * inputimage->widthStep + y * inputimage->nChannels + k];
				}
				else
				{
					float temp1 = 0,temp2 = 0;
					temp1 = (1-p)*(unsigned char)inputimage->imageData[x * inputimage->widthStep + y * inputimage->nChannels + k]
						+p* (unsigned char)inputimage->imageData[x * inputimage->widthStep + (y + 1) * inputimage->nChannels + k];
					temp2=(1-p)*(unsigned char)inputimage->imageData[(x + 1) * inputimage->widthStep + y * inputimage->nChannels + k]
						+ p*(unsigned char)inputimage->imageData[(x + 1)* inputimage->widthStep + (y + 1) * inputimage->nChannels + k];
					
					ScaleAmplifying->imageData[i*ScaleAmplifying->widthStep + j * ScaleAmplifying->nChannels + k]
						= (1 - q)*temp1 + q * temp2;
				}
			}
		}
	}
	//水平缩放
	for (int i = 0; i < X_Amplifying->height; i++)
	{
		for (int j = 0; j < X_Amplifying->width; j++)
		{
			for (int k = 0; k < X_Amplifying->nChannels; k++)
			{
				float p = j / multiple - floor(j / multiple);
				int x = floor(i / multiple);
				int y = floor(j / multiple);
				if ( p < 0.001)
				{
					X_Amplifying->imageData[i*X_Amplifying->widthStep + j * X_Amplifying->nChannels + k]
						= inputimage->imageData[i * inputimage->widthStep + y * inputimage->nChannels + k];
				}
				else
				{
					float temp = 0;
					temp = (1 - p)*(unsigned char)inputimage->imageData[i * inputimage->widthStep + y * inputimage->nChannels + k]
						+ p * (unsigned char)inputimage->imageData[i * inputimage->widthStep + (y + 1) * inputimage->nChannels + k];

					X_Amplifying->imageData[i*X_Amplifying->widthStep + j * X_Amplifying->nChannels + k]
						= temp ;
				}
			}
		}
	}
	//垂直缩放
	for (int i = 0; i < Y_Amplifying->height; i++)
	{
		for (int j = 0; j < Y_Amplifying->width; j++)
		{
			for (int k = 0; k < Y_Amplifying->nChannels; k++)
			{
				float p = j / multiple - floor(j / multiple);
				float q = i / multiple - floor(i / multiple);
				int x = floor(i / multiple);
				int y = floor(j / multiple);
				if (q < 0.001)
				{
					Y_Amplifying->imageData[i*Y_Amplifying->widthStep + j * Y_Amplifying->nChannels + k]
						= inputimage->imageData[x * inputimage->widthStep + j * inputimage->nChannels + k];
				}
				else
				{
					float temp = 0;
		
					temp = (1 - q)*(unsigned char)inputimage->imageData[(x + 1) * inputimage->widthStep + j * inputimage->nChannels + k]
						+ q * (unsigned char)inputimage->imageData[x* inputimage->widthStep + j * inputimage->nChannels + k];

					Y_Amplifying->imageData[i*Y_Amplifying->widthStep + j * Y_Amplifying->nChannels + k]
						= temp;
				}
			}
		}
	}

	cvNamedWindow("inputimage", 1);
	cvNamedWindow("ScaleAmplifying", 1);
	cvNamedWindow("X_Amplifying", 1);
	cvNamedWindow("Y_Amplifying", 1);
	//显示图像
	cvShowImage("inputimage", inputimage);
	cvShowImage("ScaleAmplifying", ScaleAmplifying);
	cvShowImage("X_Amplifying", X_Amplifying);
	cvShowImage("Y_Amplifying", Y_Amplifying);
	cvWaitKey(0);
	//保存图像
	cv::Mat amplification = cv::cvarrToMat(ScaleAmplifying);
	cv::Mat amplification1 = cv::cvarrToMat(X_Amplifying);
	cv::Mat amplification2 = cv::cvarrToMat(Y_Amplifying);
	cv::imwrite("ScaleAmplifying.bmp", amplification);
	cv::imwrite("X_Amplifying.bmp", amplification1);
	cv::imwrite("Y_Amplifying.bmp", amplification2);


	cvDestroyWindow("inputimage");
	cvDestroyWindow("ScaleAmplifying");
	cvDestroyWindow("X_Amplifying");
	cvDestroyWindow("Y_Amplifying");

	cvReleaseImage(&inputimage);
	cvReleaseImage(&ScaleAmplifying);
	cvReleaseImage(&X_Amplifying);
	cvReleaseImage(&Y_Amplifying);
}

图像依次为原图、延x方向放大、延y方向放大、比例放大。

四、旋转变换

        图像旋转变换会改变图像大小，如果采用“前向映射”生成图像会有一些空洞点，空洞点需要差值的方法补全，过程比较麻烦，所以采用“后向映射”效果较好，不会产生空洞点。

        设P_{0}(x_{0},y_{0})旋转\theta角后对应的点为P(x,y)（逆时针旋转）

旋转前后点P_{0}(x_{0},y_{0})、P(x,y)的坐标分别是

\left\{\begin{matrix} x_{0}=r*\cos \alpha \\ y_{0}=r*\sin \alpha \end{matrix}\right.

\left\{\begin{matrix} x=r*\cos(\alpha -\theta ) =r*\cos \alpha \cos \theta +r*\sin \alpha \sin \theta =x_{0}*\cos \theta +y_{0}*\sin \theta \\ y=r*\sin(\alpha -\theta )=r*\sin \alpha \cos \theta -r*\cos \alpha \sin \theta =-x_{0}*\sin \theta +y_{0}*\cos \theta \end{matrix}\right.

矩阵表达式为：\begin{bmatrix} x \\ y \\1 \end{bmatrix}=\begin{bmatrix} \cos \theta & \sin \theta & 0\\ -\sin \theta & \cos \theta & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x_{0}\\ y_{0} \\ 1 \end{bmatrix}

逆运算为：\begin{bmatrix} x_{0} \\ y_{0} \\1 \end{bmatrix}=\begin{bmatrix} \cos \theta & \--sin \theta & 0\\ \sin \theta & \cos \theta & 0\\ 0& 0 & 1 \end{bmatrix}*\begin{bmatrix} x\\ y\\ 1 \end{bmatrix}

上述算法是以（0，0）点为中心进行旋转，如果需要以（a，b）点为中心进行旋转，需要先将图像平移至该点，然后进行旋转，旋转后再平移回原点。

#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include<math.h>
#include "opencv2/opencv.hpp"

int main()
{
	float pi = 3.141592653;
	float a = pi / 4.0;//控制旋转角度
	float b = pi / 3.0;
	// Rotation
	const char *filename = "football.jpg";
	IplImage *inputimage = cvLoadImage(filename, -1);
	float diagonal = sqrt(inputimage->width * inputimage->width + inputimage->height*inputimage->height);
	float angle = atan((float)inputimage->width / (float)inputimage->height);
	float a_x = pi / 2.0 - angle - a;
	float a_y = angle - a;
	int width = diagonal * cos(a_x);
	int height = diagonal * cos(a_y);
	float d_x = (width - inputimage -> width) / 2.0;
	float d_y = (height - inputimage->height) / 2.0;
	//printf("%f", angle);
	//printf("%d %d %f %f %f %d %d %f", width,height,a_x,a_y,angle,inputimage->width,inputimage->height, (float)inputimage->width/(float)inputimage->height);
	IplImage *Rotateimage = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, inputimage->nChannels);
	
	for (int i = 0; i < Rotateimage->height; i++)
	{
		for (int j = 0; j < Rotateimage->width; j++)
		{
			for (int k = 0; k < Rotateimage->nChannels; k++)
			{
				float x = j * cos(a) + i * sin(a);
				float y = -j * sin(a) + i * cos(a);
				float x0 = ((j- Rotateimage->width/2) * cos(a) - (i - Rotateimage->height/2)* sin(a))+ Rotateimage->width/2;
				float y0 = ((j - Rotateimage->width/2)* sin(a) + (i - Rotateimage->height/2) * cos(a))+ Rotateimage->height/2;
				if (x0 >(int)d_x && x0 < Rotateimage->width-d_x && y0>d_y && y0 < Rotateimage->height-d_y)
				{
					int x_coordinate = x0;
					int y_coordinate = y0;
					Rotateimage->imageData[i*Rotateimage->widthStep + j * Rotateimage->nChannels + k]
						= inputimage->imageData[int(y_coordinate-d_y)*inputimage->widthStep + (int)(x_coordinate-d_x) * inputimage->nChannels + k];
				}
				else
					Rotateimage->imageData[i*Rotateimage->widthStep + j * Rotateimage->nChannels + k]
					= 0;
			}
		}
	}

	cvNamedWindow("inputimage", 1);
	cvNamedWindow("Rotateimage", 1);
	//显示图像
	cvShowImage("inputimage", inputimage);
	cvShowImage("Rotateimage", Rotateimage);
	
	cvWaitKey(0);
	//储存图像
	cv::Mat rotate = cv::cvarrToMat(Rotateimage);
	cv::imwrite("Rotation.bmp", rotate);

	cvDestroyWindow("inputimage");
	cvDestroyWindow("Rotateimage");

	cvReleaseImage(&inputimage);
	cvReleaseImage(&Rotateimage);
}

图像依次为原图、逆时针旋15转度、逆时针旋转30度、逆时针旋转45度、逆时针旋转60度、逆时针旋转90度

睡虎
关注
  • 15
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenCV入门（十二）快速学会OpenCV 11几何变换
小幽余生不加糖
03-15 920
我们在处理图像时，往往会遇到需要对图像进行几何变换的问题。图像的几何变换是图像处理和图像分析的基础内容之一，不仅提供了产生某些图像的可能，还可以使图像处理和分析的程序简单化，特别是图像具有一定的规律性时，一个图像可以由另一个图像通过几何变换来实现。所以，为了提高图像处理和分析程序设计的速度和质量，开拓图像程序应用范围的新领域，对图像进行几何变换是十分必要的。图像的几何变换不改变图像的像素值，而是改变像素所在的几何位置。
（数字图像处理MATLAB+Python）第三章图像基本运算-第一节：图像几何变换
快乐江湖的博客
03-30 1782
图像插值运算：利用已知邻近像素点的灰度值来产生未知像素点的灰度值。包括最近邻插值非整数像素灰度值就等于距离最近的像素的灰度值双线性插值利用非整数像素点周围的四个像素点的相关性，通过双线性算法计算得出的双三次插值利用非整数像素点周围的16个像素点进行计算原理：变换公式如下x′xΔxy′yΔyx′xΔxy′yΔy​矩阵表示如下x′y′110Δx01Δy001xy110 & 0 & 1x \\y \\1​x′。
opencv图像处理之图像镜像
Jabok的博客
09-23 2340
由原图像映射到目标图像称为正映射，由目标图像通过映射关系得到原图像称为反映射。 由于正映射常会映射不完全以及出现映射重复现象，一般在图像处理的过程中采取 反映射的方式来保证输出目标图像的每个像素都可以通过映射关系在原图像中找到唯一的对应像素。 重映射：把一个图像中一个位置的像素通过映射关系转换到另一图像的指定位置。
opencv图片镜像
cyj5201314的博客
01-31 245
import numpy as np #读取原图 img = cv2.imread("E:/code/conputer_visual/data/0.jpg", 1) #显示原图 cv2.imshow("src", img) #获取原图宽高信息 img_info = img.shape height = img_info[0] width = img_info[1] deep = img_info[2] #获取新图宽高信息 new_image_info = (height * 2, width, deep)
【学习OpenCV】flip函数、镜像操作
Kelvin_Yan的专栏
11-10 3万+
矩阵（图像）镜像（翻转） cv::flip void flip(InputArray src, OutputArray dst, int flipCode) 参数： src，输入矩阵 dst，翻转后矩阵，类型与src一致 flipCode，翻转模式，flipCode==0垂直翻转（沿X轴翻转），flipCode>0水平翻转（沿Y轴翻转），flipCode
OpenCV for Python 学习笔记
vivian_ll的博客
07-20 494
转载自：http://www.cnblogs.com/pakfahome/p/3914318.html给源图像增加边界cv2.copyMakeBorder(src,top, bottom, left, right ,borderType,value) src:源图像top,bottem,left,right: 分别表示四个方向上边界的长度borderType: 边界的类型有以下几种： BORDER_
4.3【图像镜像】-------------基于Opencv实现-----图像的镜像变换
李丽的博客
03-02 1574
 【1】理论知识：         镜像变换又分为水平镜像和垂直镜像，水平镜像即将图像左半部分和右半部分以图像竖直中轴线为中心轴进行兑换，而竖直镜像则是将图像上半部分和下半部分以图像水平中轴线为中心轴进行兑换。 【2】图像水平镜像完整代码 /*----------------------------------------------------------------------
【OpenCV】图像几何变换：旋转，缩放，斜切
热门推荐
小魏的修行路
05-30 15万+
几何变换 几何变换可以看成图像中物体（或像素）空间位置改变，或者说是像素的移动。 几何运算需要空间变换和灰度级差值两个步骤的算法，像素通过变换映射到新的坐标位置，新的位置可能是在几个像素之间，即不一定为整数坐标。这时就需要灰度级差值将映射的新坐标匹配到输出像素之间。最简单的插值方法是最近邻插值，就是令输出像素的灰度值等于映射最近的位置像素，该方法可能会产生锯齿。这种方法也叫零阶插值，相应比较复...
36.OpenCV图像几何变换万字详解（平移缩放旋转、镜像仿射透视）.pdf
最新发布
03-31
**图像仿射变换**是一种更为复杂的几何变换，它可以实现图像的平移、旋转、缩放、错切等多种组合操作。仿射变换是由一组线性方程定义的，通常涉及到三个对应点之间的映射关系。 #### 实现方法 在OpenCV中，通过`cv2...
Java OpenCV实现图像镜像翻转效果
08-25
主要为大家详细介绍了Java OpenCV实现图像镜像翻转效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
图像仿射变换原理3：仿射变换类型及变换矩阵详解
老猿Python
02-16 5542
本文介绍了仿射变换的类型及其关系以及仿射变换矩阵，基本的仿射变换包括平移、旋转、缩放和错切，镜像可以看做特殊的缩放。实际中一般图像的仿射变换就是平移、旋转、缩放和错切的叠加组合，每叠加一个处理，就进行一次仿射变换矩阵和齐次坐标的乘法，再进行一次处理则再乘一次对应变换的矩阵。
数字图像处理第五章——几何变换与图像配准
Dujing2019的博客
04-21 7649
数字图像处理第五章数字图像处理---几何变换与图像标准（一）点变换（二）仿射变换（三）投影变换（四）应用于图像的几何变换（五）MATLAB 中的图像坐标系统5.1 输出图像位置5.2 控制输出网格（六）图像内插6.1 二维内插6.2 内插方法的比较（七） 图像配准7.1 配准处理7.2 使用 cpselect 的手工特征选择和匹配7.3 使用 cp2tform 推断变换参数7.4 基于区域的配准 ...
OpenCV: 图片镜像
简单随风的博客
06-05 2637
import cv2 import numpy as np img = cv2.imread('test0.png',1) cv2.imshow('src', img) imgInfo = img.shape height = imgInfo[0] width = imgInfo[1] deep = imgInfo[2] newImgInfo = (height*2,width,deep) ds...
【千律】OpenCV基础：图像的镜像变换
weixin_42704093的博客
03-20 1531
环境：Python3.8 和 OpenCV 内容：图像的镜像变换 水平镜像变换公式如下： 垂直镜像变换公式如下： import cv2 as cv import numpy as np import matplotlib.pyplot as plt # 封装图片显示函数 def image_show(image): if image.ndim == 2: plt.imshow(image, cmap='gray') else: imag.
常见的图像几何变换
安阳知秋
08-08 5394
文章目录旋转平移缩放镜像转置错切(倾斜)刚体变换相似变换仿射变换投影变换 图像的几何变换又称为图像空间变换， 它将一幅图像中的坐标位置映射到另一幅图像中的 新坐标位置。常见的几何变换包括旋转、平移、缩放、镜像、转置、错切等，以及几种组合变换，如刚体变换、仿射变换、单应变换 旋转 (x,y,)=(cos(θ)−sin(θ)sin(θ)cos(θ))(xy) \left(\begin{matrix} x^,\\y^, \end{matrix}\right) = \left(\begin{matrix} co
OpenCV图像旋转（cv::rotate）与镜像（cv::flip）
m0_60259116的博客
02-22 2682
OpenCV图像旋转（cv::rotate）与镜像（cv::flip）
【OpenCV】学习课-图像平移、旋转、镜像（4）！
相信过程！
05-15 607
图像平移+旋转+镜像@Neng。
opencv-基础知识点-图像镜像
求知小鸟
09-07 397
opencv-基础知识点-图像镜像 代码： import cv2 import numpy as np img = cv2.imread(r"C:\Users\lenovo\Desktop\python\python_vision\image.jpg",1) cv2.imshow("img",img) imgInfo = img.shape print(imgInfo) height = imgInfo[0] weight = imgInfo[1] deep = imgInfo[2]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值