python照相机模型与增强现实

Posted 2022-01-03 hyhy904

这次试验主要实现以平面和标记物进行姿态估计以及增强现实的应用。

一、以平面和标记物进行姿态估计
（1）下面演示的是一个简单例子：如何在一副图像上放置一个立方体，原图如下：

（2）先提取两幅JPG图像的SIFT特征，然后使用RANSAC算法稳健地估计单应性矩阵，这两个算法前面的博文都有介绍，代码参考《python计算机视觉编程》，按如下运行一般不会有什么问题。
代码：

# -*- coding: utf-8 -*-
from pylab import *
from PIL import Image

# If you have PCV installed, these imports should work
from PCV.geometry import homography, camera
from PCV.localdescriptors import sift

"""
This is the augmented reality and pose estimation cube example from Section 4.3.
"""

def cube_points(c, wid):
""" 创建用于绘制立方体的一个点列表（前5个点是底部的正方形，一些边重合了） """
p = []
# bottom
p.append([c[0]-wid, c[1]-wid, c[2]-wid])
p.append([c[0]-wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]-wid, c[2]-wid])
p.append([c[0]-wid, c[1]-wid, c[2]-wid]) #same as first to close plot

# top
p.append([c[0]-wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]-wid, c[2]+wid]) #same as first to close plot

# vertical sides
p.append([c[0]-wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]-wid])

return array(p).T

def my_calibration(sz):
"""根据自己图像的分辨率修改这个函数中的数值"""
"""
Calibration function for the camera (iPhone4) used in this example.
"""
row, col = sz
fx = 2555*col/2592
fy = 2586*row/1936
K = diag([fx, fy, 1])
K[0, 2] = 0.5*col
K[1, 2] = 0.5*row
return K

 

#计算特征
sift.process_image(‘image4/book_frontal.JPG‘, ‘im0.sift‘)
l0, d0 = sift.read_features_from_file(‘im0.sift‘)

sift.process_image(‘image4/book_perspective.JPG‘, ‘im1.sift‘)
l1, d1 = sift.read_features_from_file(‘im1.sift‘)

# 匹配特征，并计算单应性矩阵
matches = sift.match_twosided(d0, d1)
ndx = matches.nonzero()[0]
fp = homography.make_homog(l0[ndx, :2].T)
ndx2 = [int(matches[i]) for i in ndx]
tp = homography.make_homog(l1[ndx2, :2].T)

model = homography.RansacModel()
H, inliers = homography.H_from_ransac(fp, tp, model)

# 计算照相机标定矩阵
K = my_calibration((747, 1000))

# 位于边长为0.2，z=0平面上的三维点
box = cube_points([0, 0, 0.1], 0.1)

# 投影第一幅图像上底部的正方形
cam1 = camera.Camera(hstack((K, dot(K, array([[0], [0], [-1]])))))
# 底部正方形上的点
box_cam1 = cam1.project(homography.make_homog(box[:, :5]))

# 使用H将点变换到第二幅图像中
box_trans = homography.normalize(dot(H,box_cam1))

# 从cam1和H中计算第二个照相机矩阵
cam2 = camera.Camera(dot(H, cam1.P))
A = dot(linalg.inv(K), cam2.P[:, :3])
A = array([A[:, 0], A[:, 1], cross(A[:, 0], A[:, 1])]).T
cam2.P[:, :3] = dot(K, A)

# 使用第二个照相机矩阵投影
box_cam2 = cam2.project(homography.make_homog(box))
‘‘‘
with open(‘ar_camera.pkl‘,‘r‘) as f:
pickle.dump(k,f)
pickle.dump(dot(linalg.inv(K),cam2.p),f)
‘‘‘
# 绘制
im0 = array(Image.open(‘image4/book_frontal.JPG‘))
im1 = array(Image.open(‘image4/book_perspective.JPG‘))

figure()
imshow(im0)
plot(box_cam1[0, :], box_cam1[1, :], linewidth=3)
title(‘2D projection of bottom square‘)
axis(‘off‘)

figure()
imshow(im1)
plot(box_trans[0, :], box_trans[1, :], linewidth=3)
title(‘2D projection transfered with H‘)
axis(‘off‘)

figure()
imshow(im1)
plot(box_cam2[0, :], box_cam2[1, :], linewidth=3)
title(‘3D points projected in second image‘)
axis(‘off‘)

show()

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
（3）运行结果

可以看到在书的平面上建立起了一个正方体，这三幅实验图的分辨率都是747×1000，若是所用的图片分辨率有所变化，则需要在代码中K = my_calibration((747, 1000))这一部分做相应的修改。

二、增强现实
（1）运行准备
增强现实是将物体和相应信息放置在图像数据上的一系列操作的总称，也就是大家熟悉的AR。在这里我们需要用到两个工具包：PyGame和PyOpenGL。这里给出下载地址：
https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyopengl
http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame
在安装这两个工具包之前，先查看一下自己所用的版本信息，下载对应的包的版本，若是版本不对应则会出现is not a supported wheel on this platform这样的报错。
具体操作如下：
1.打开cmd，输入python，则会显示对应版本信息。

2.输入import pip._internal，回车。

3.继续输入print(pip._internal.pep425tags.get_supported())，则会显示相对应的信息。

我这里所使用的是32位的python27版本，也就是说我们所需要安装的包的版本应是如上格式的，在这里我直接在命令行pip install pygame就可以下载，下载下来的就是32位的，若版本是64位的，那么就需要去官网下载pygame?1.9.4?cp27?cp27m?win_amd64.whl，安装过程很简单，进入所在目录pip就行。

（2）完成包的导入后，我用python脚本开始运行代码，碰到了如下几个问题。

1.opengl的窗口弹出后便闪退了，但是shell里并没有报错，我一开始以为是版本的问题，尝试换了一些版本，但是结果都是一样的，便改用cmd运行，发现出现了如下的报错：

有人提醒这个错误是freeglut和glut共存的缘故，它们俩定义了相同的方法，这个是动态链接库的重叠问题，在我的电脑中需要到C:\Python27\Lib\site-packages\OpenGL\DLLS中删除重复的dll文件，只剩下glut32.vc9.dll这个文件就行。

2.下面第一个错误就是单纯的图片不过关的问题了，这里要注意的是在选用图片时，一定要将分辨率以及代码中的宽高设定就行修改，第二个错误就是因为没有仔细修改代码中对应图片的数据造成的。

（3）运行结果
我先用与上面的相同的图片做了测试，发现能够呈现与书中相同的效果

那么就可以进一步地尝试自己拍摄的图片，选用测试图片如下：

1.失败结果

这两张图的结果显示就是上面所说的图片数据没有改好，代码中的宽高要根据你所用的图片来设定，若是不一致则可能出现上面这样成功率为0的情况。

2.成功结果

上面这组所选用的图片分辨率为1080×1440，我的电脑的分辨率为1366×768，所以高度上显示不完全，但是不怎么影响实验结果。若是想要显示完全，还需要调整自己的图片和代码，将其改成1000×747，调整后结果如下：

（4）代码

import math
import pickle
from pylab import *
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
import pygame, pygame.image
from pygame.locals import *
from PCV.geometry import homography, camera
from PCV.localdescriptors import sift

def cube_points(c, wid):
""" Creates a list of points for plotting
a cube with plot. (the first 5 points are
the bottom square, some sides repeated). """
p = []
# bottom
p.append([c[0]-wid, c[1]-wid, c[2]-wid])
p.append([c[0]-wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]-wid, c[2]-wid])
p.append([c[0]-wid, c[1]-wid, c[2]-wid]) #same as first to close plot

# top
p.append([c[0]-wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]-wid, c[2]+wid]) #same as first to close plot

# vertical sides
p.append([c[0]-wid, c[1]-wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]+wid])
p.append([c[0]-wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]-wid])
p.append([c[0]+wid, c[1]+wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]+wid])
p.append([c[0]+wid, c[1]-wid, c[2]-wid])

return array(p).T

def my_calibration(sz):
row, col = sz
fx = 2555*col/2592
fy = 2586*row/1936
K = diag([fx, fy, 1])
K[0, 2] = 0.5*col
K[1, 2] = 0.5*row
return K

def set_projection_from_camera(K):
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
fx = K[0,0]
fy = K[1,1]
fovy = 2*math.atan(0.5*height/fy)*180/math.pi
aspect = (width*fy)/(height*fx)
near = 0.1
far = 100.0
gluPerspective(fovy,aspect,near,far)
glViewport(0,0,width,height)

def set_modelview_from_camera(Rt):
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])
R = Rt[:,:3]
U,S,V = np.linalg.svd(R)
R = np.dot(U,V)
R[0,:] = -R[0,:]
t = Rt[:,3]
M = np.eye(4)
M[:3,:3] = np.dot(R,Rx)
M[:3,3] = t
M = M.T
m = M.flatten()
glLoadMatrixf(m)

def draw_background(imname):
bg_image = pygame.image.load(imname).convert()
bg_data = pygame.image.tostring(bg_image,"RGBX",1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D,glGenTextures(1))
glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,width,height,0,GL_RGBA,GL_UNSIGNED_BYTE,bg_data)
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST)
glBegin(GL_QUADS)
glTexCoord2f(0.0,0.0); glVertex3f(-1.0,-1.0,-1.0)
glTexCoord2f(1.0,0.0); glVertex3f( 1.0,-1.0,-1.0)
glTexCoord2f(1.0,1.0); glVertex3f( 1.0, 1.0,-1.0)
glTexCoord2f(0.0,1.0); glVertex3f(-1.0, 1.0,-1.0)
glEnd()
glDeleteTextures(1)

def draw_teapot(size):
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_DEPTH_TEST)
glClear(GL_DEPTH_BUFFER_BIT)
glMaterialfv(GL_FRONT,GL_AMBIENT,[0,0,0,0])
glMaterialfv(GL_FRONT,GL_DIFFUSE,[0.5,0.0,0.0,0.0])
glMaterialfv(GL_FRONT,GL_SPECULAR,[0.7,0.6,0.6,0.0])
glMaterialf(GL_FRONT,GL_SHININESS,0.25*128.0)
glutSolidTeapot(size)

width,height = 1000,747 #根据图片修改
def setup():
pygame.init()
pygame.display.set_mode((width,height),OPENGL | DOUBLEBUF)
pygame.display.set_caption("OpenGL AR demo")

# compute features
sift.process_image(‘python6.jpg‘, ‘im0.sift‘)
l0, d0 = sift.read_features_from_file(‘im0.sift‘)

sift.process_image(‘python7.jpg‘, ‘im1.sift‘)
l1, d1 = sift.read_features_from_file(‘im1.sift‘)

# match features and estimate homography
matches = sift.match_twosided(d0, d1)
ndx = matches.nonzero()[0]
fp = homography.make_homog(l0[ndx, :2].T)
ndx2 = [int(matches[i]) for i in ndx]
tp = homography.make_homog(l1[ndx2, :2].T)

model = homography.RansacModel()
H, inliers = homography.H_from_ransac(fp, tp, model)

K = my_calibration((747, 1000))
cam1 = camera.Camera(hstack((K, dot(K, array([[0], [0], [-1]])))))
box = cube_points([0, 0, 0.1], 0.1)
box_cam1 = cam1.project(homography.make_homog(box[:, :5]))
box_trans = homography.normalize(dot(H,box_cam1))
cam2 = camera.Camera(dot(H, cam1.P))
A = dot(linalg.inv(K), cam2.P[:, :3])
A = array([A[:, 0], A[:, 1], cross(A[:, 0], A[:, 1])]).T
cam2.P[:, :3] = dot(K, A)

Rt=dot(linalg.inv(K),cam2.P)

setup()
draw_background("python7.bmp")
set_projection_from_camera(K)
set_modelview_from_camera(Rt)
draw_teapot(0.05)
pygame.display.flip()
while True:
for event in pygame.event.get(http://www.my516.com):
if event.type == pygame.QUIT:
sys.exit()
pygame.quit()
pygame.display.flip()
---------------------