Opencv_10 图像的透视变换_cv透视变换 图像空白部分

一. 透视变换的原理

透视变换(Perspective Transformation)是将图片投影到一个新的视平面(Viewing Plance),也称为投影映射(Projective Mapping).通用的变换公式为:

透视变换矩阵

(x,y,1)是原点, [X,Y,Z]是变换后的点位

这是一个二维空间变换到三维空间的转换,因为图像在二维平面,故除以Z

二. 透视变换实现

① 函数原型

Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[], 
							int solveMethod = DECOMP_LU);
1
2

参数说明:

• src[]: 原图像中的四个像素坐标
• dst[]: 目标图像中的四个像素点坐标
• solveMethod: 选择计算透视变换矩阵方法的标志,可以选择参数以及含义在下表中

该函数两个输入量都是存放浮点坐标的数组,在生成数组的时候像素点的输入顺序没有要求,但是需要注意像素点的对应关系是一一对应的,函数的返回值是一个3*3的矩阵.最后一个参数是对应点坐标计算透视变换矩阵方法的选择标志,默认使用的是最佳主轴元素的高斯消元法DECOMP_LU

获取到透视变换矩阵以后,就可以进行透视变换了

void warpPerspective( InputArray src, OutputArray dst,
                                   InputArray M, Size dsize,
                                   int flags = INTER_LINEAR,
                                   int borderMode = BORDER_CONSTANT,
                                   const Scalar& borderValue = Scalar());
1
2
3
4
5

参数说明:

• src: 输入图像
• dst: 输出图像
• M: 3*3的变换矩阵
• dSize: 输出图像的尺寸
• flags: 插值方法标志
• boardMode: 像素边界填充方式的标志
• boardValue: 填充边界使用的数值,默认情况下是0

② 透视变换实现

#include"MyOpencv.h"
#include <vector>

int main(void)
{
	Mat imageSrc = Mat::zeros(Size(800, 800), CV_8UC3);
	// 画一个多边形
	vector<Point> pts;
	pts.push_back(Point(50, 40));
	pts.push_back(Point(600, 40));
	pts.push_back(Point(600, 600));
	pts.push_back(Point(50, 600));

	polylines(imageSrc, pts, true, Scalar(0, 255, 0), 3, LINE_8);

	pts.clear();
	pts.push_back(Point(150, 80));
	pts.push_back(Point(350, 80));
	pts.push_back(Point(350, 200));
	pts.push_back(Point(150, 200));
	polylines(imageSrc, pts, true, Scalar(0, 0, 255), 3, LINE_8);

	Point2f srcPoint[4];
	Point2f dstPoint[4];

	srcPoint[0] = Point2f(150, 80);
	srcPoint[1] = Point2f(350, 80);
	srcPoint[2] = Point2f(350, 200);
	srcPoint[3] = Point2f(150, 200);

	dstPoint[0] = Point2f(150, 80);
	dstPoint[1] = Point2f(350, 80);
	dstPoint[2] = Point2f(400, 200);
	dstPoint[3] = Point2f(200, 200);

	Mat M = getPerspectiveTransform(srcPoint, dstPoint);
	Mat dst;
	warpPerspective(imageSrc, dst, M, Size(1000, 1000));
	imshow("Original", imageSrc);
	imshow("Dst", dst);
	waitKey(0);

	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

结果:

三. 透视变换的案例

将这张图像摆正.用到的技术.

1. 灰度处理,二值化,形态学操作行程连通域
2. 轮廓发现,将目标的轮廓绘制出来
3. 在绘制的轮廓中进行直线检测
4. 找出4个边,求出四个交点
5. 使用透视变换函数,得到结果

#include "MyOpencv.h"
#include <vector>

int main(void)
{
	Mat imageSrc = imread("./test_01.png", IMREAD_GRAYSCALE);
	imshow("Original", imageSrc);
	// 二值化
	Mat binary;
	threshold(imageSrc, binary, 0, 255, THRESH_BINARY | THRESH_OTSU);
	imshow("Binary", binary);

	// 形态学 开操作,可以填充白色小区域
	Mat morphImage;
	Mat kernel = getStructuringElement(MORPH_RECT, Size(5, 5), Point(-1, -1));
	morphologyEx(binary, morphImage, MORPH_OPEN, kernel, Point(-1, -1), 3);
	imshow("Opened", morphImage);

	// 查找轮廓
	vector<vector<Point>> contours;
	vector<Vec4i> hireachy;
	findContours(morphImage, contours, hireachy, RETR_LIST, CHAIN_APPROX_SIMPLE);
	cout << "Contours.size: " << contours.size() << endl;

	// 轮廓绘制
	int width = imageSrc.cols;
	int height = imageSrc.rows;
	Mat drawImage = Mat::zeros(imageSrc.size(), CV_8UC3);

	for (int index = 0; index < contours.size(); index++)
	{
		Rect rect = boundingRect(contours[index]);
		if (rect.width > width / 2 && rect.height > height / 2 
		&& rect.width < width - 5 && rect.height < height - 5)
		{
			drawContours(drawImage, contours, index, Scalar(0, 0, 255), 2, 8,
						 hireachy, 0, Point(0, 0));
		}
	}
	imshow("Contours", drawImage);

	// 直线检测
	vector<Vec4i> lines;
	Mat contoursImage;
	int accu = static_cast<int>(min(width * 0.3, height * 0.3));
	cvtColor(drawImage, contoursImage, COLOR_BGR2GRAY);
	imshow("Contours", contoursImage);

	Mat linesImage = Mat::zeros(imageSrc.size(), CV_8UC3);
	HoughLinesP(contoursImage, lines, 1, CV_PI / 180.0,150,accu,accu);

	for (int index = 0; index < lines.size(); index++)
	{
		Vec4i ln = lines[index];
		line(linesImage, Point(ln[0], ln[1]), Point(ln[2], ln[3]),
		 Scalar(0, 0, 255), 2, 8, 0);
	}

	cout << "Number of lines: " << lines.size() << endl;
	imshow("ImageLines",linesImage);

	// 先确定上下左右四条直线,然后求交点
	Vec4i topLine, bottomLine, leftLine, rightLine;
	int yOffset;
	int xOffset;
	for (int i = 0; i < lines.size(); i++)
	{
		Vec4i line = lines[i];
		yOffset = abs(line[3] - line[1]);
		xOffset = abs(line[0] - line[2]);

		// topLine and bottomLine
		if (yOffset < height * 0.2 )
		{
			if (line[1] < height / 2 && line[3] < height / 2)
			{
				topLine = lines[i];
			}
			else
			{
				bottomLine = lines[i];
			}
		}

		// leftLine and rightLine
		if (xOffset < width * 0.2)
		{
			if (line[0] < width / 2 && line[1] < width / 2)
			{
				leftLine = lines[i];
			}
			else
			{
				rightLine = lines[i];
			}
		}

	}

	cout << "topLine : p1(x,y)= " << topLine[0] << "," << topLine[1] << 
	"; p2(x,y)= " << topLine[2] << "," << topLine[3] << endl;
	cout << "bottomLine : p1(x,y)= " << bottomLine[0] << "," << bottomLine[1] << 
	"; p2(x,y)= " << bottomLine[2] << "," << bottomLine[3] << endl;
	cout << "leftLine : p1(x,y)= " << leftLine[0] << "," << leftLine[1] << 
	"; p2(x,y)= " << leftLine[2] << "," << leftLine[3] << endl;
	cout << "rightLine : p1(x,y)= " << rightLine[0] << "," << rightLine[1] << 
	"; p2(x,y)= " << rightLine[2] << "," << rightLine[3] << endl;


	// 获取两条直线的交点
	Point leftTop, rightTop, rightBottom, leftBottom;

	float leftLineK, leftLineB, topLineK, topLineB, 
	      rightLineK, rightLineB, bottomLineK, bottomLineB;
	leftLineK = float(leftLine[3] - leftLine[1]) / float(leftLine[2] - leftLine[0]);
	leftLineB = leftLine[1] - leftLineK * leftLine[0];

	rightLineK = float(rightLine[3] - rightLine[1]) / float(rightLine[2] - rightLine[0]);
	rightLineB = rightLine[1] - rightLineK * rightLine[0];

	topLineK = float(topLine[3] - topLine[1]) / float(topLine[2] - topLine[0]);
	topLineB = topLine[1] - topLineK * topLine[0];

	bottomLineK = float(bottomLine[3] - bottomLine[1]) /
				  float(bottomLine[2] - bottomLine[0]);
	bottomLineB = bottomLine[1] - bottomLineK * bottomLine[0];
	cout << "leftLineK = " << leftLineK << ", leftLineB = " << leftLineB << endl;
	cout << "rightLineK = " << rightLineK << ", rightLineB = " << rightLineB << endl;
	cout << "topLineK = " << topLineK << ", topLineB = " << topLineB << endl;
	cout << "bottomLineK = " << bottomLineK << ", bottomLineB = " << bottomLineB << endl;


	// 获取交点
	Point p1;
	p1.x = -static_cast<int>((leftLineB - topLineB) / (leftLineK - topLineK));
	p1.y = static_cast<int>(leftLineK * p1.x + leftLineB);

	Point p2;
	p2.x = -static_cast<int>((topLineB - rightLineB) / (topLineK - rightLineK));
	p2.y = static_cast<int>(topLineK * p2.x + topLineB);

	Point p3;
	p3.x = -static_cast<int>((rightLineB - bottomLineB) / (rightLineK - bottomLineK));
	p3.y = static_cast<int>(rightLineK * p3.x + rightLineB);

	Point p4;
	p4.x = -static_cast<int>((bottomLineB - leftLineB) / (bottomLineK - leftLineK));
	p4.y = static_cast<int>(bottomLineK * p4.x + bottomLineB);

	cout << "Point p1: (" << p1.x << "," << p1.y << ")" << endl;
	cout << "Point p2: (" << p2.x << "," << p2.y << ")" << endl;
	cout << "Point p3: (" << p3.x << "," << p3.y << ")" << endl;
	cout << "Point p4: (" << p4.x << "," << p4.y << ")" << endl;

	// 获取两点之间的距离'
	int newWidth, newHeight;

	newWidth = sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
	newHeight = sqrt((p1.x - p4.x) * (p1.x - p4.x) + (p1.y - p4.y) * (p1.y - p4.y));

	cout << "newWidth = " << newWidth << ", newHeight = " << newHeight << endl;

	// 透视变换
	Point2f srcPts[4];
	Point2f dstPts[4];
	
	srcPts[0] = p1;
	srcPts[1] = p2;
	srcPts[2] = p3;
	srcPts[3] = p4;

	dstPts[0] = Point(0, 0);
	dstPts[1] = Point(newWidth, 0);
	dstPts[2] = Point(newWidth, newHeight);
	dstPts[3] = Point(0, newHeight);

	Mat M = getPerspectiveTransform(srcPts, dstPts, 0);
	Mat dst;
	warpPerspective(imageSrc, dst, M, Size(newWidth+5, newHeight+5), INTER_LINEAR);
	imshow("Dst", dst);

	waitKey(0);
	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

结果: