python照相机模型与增强现实

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

一、以平面和标记物进行姿态估计
（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()
---------------------

原文地址：https://www.cnblogs.com/hyhy904/p/11001420.html

时间： 2024-10-05 23:25:16

python照相机模型与增强现实的相关文章

OpenGL边用边学------2 经典照相机模型

实际照相步骤 1 布置场景和调整照相机位置 3 选择镜头对焦Focus 4 按下快门 5 在电脑窗体中赞赏图片 OpenGL的相机模型 0 确定胶片位置 1 确立场景世界坐标系 2 在世界坐标系中确定相机位置与方向 3 在世界坐标系中建立物理世界模型 4 视图变换与模型变换的抉择 5 在照相机坐标系中确定可视范围对焦投影变换 6 调用glBegin glEnd拍照 OpenGL相机模型与实际相机的不同 1 物体和相机都能够随意移动 2 终于的照片能够是多次拍摄合成的 3 特殊的投影方式正投影 相

[转][python sklearn模型中random_state参数的意义]

来自简书“owolf”:python sklearn模型中random_state参数的意义 “如果你在需要设置随机数种子的地方都设置好,那么当别人重新运行你的代码的时候就能得到完全一样的结果,复现和你一样的过程.” “ 这里的random_state就是为了保证程序每次运行都分割一样的训练集和测试集.否则,同样的算法模型在不同的训练集和测试集上的效果不一样.当你用sklearn分割完测试集和训练集,确定模型和初始参数以后,你会发现程序每运行一次,都会得到不同的准确率,无法调参.这个时候就是因为

python django模型内部类meta详解

Django 模型类的Meta是一个内部类,它用于定义一些Django模型类的行为特性.以下对此作一总结: abstract 这个属性是定义当前的模型类是不是一个抽象类.所谓抽象类是不会对应数据库表的.一般我们用它来归纳一些公共属性字段,然后继承它的子类可以继承这些字段.比如下面的代码中Human是一个抽象类,Employee是一个继承了Human的子类,那么在运行syncdb命令时,不会生成Human表,但是会生成一个Employee表,它包含了Human中继承来的字段,以后如果再添加一个Cu

python sklearn模型的保存

使用python的机器学习包sklearn的时候,如果训练集是固定的,我们往往想要将一次训练的模型结果保存起来,以便下一次使用,这样能够避免每次运行时都要重新训练模型时的麻烦. 在python里面,有一个joblib可以实现将模型保存,并将保存后的模型取出用于不同的测试集: 1 from sklearn import svm 2 from sklearn.externals import joblib 3 4 #训练模型 5 clf = svc = svm.SVC(kernel='linear'

python事件驱动模型的代码

__author__ = 'Administrator' #/usr/env/bin python '''   this is document ''' class Event(object):     '''       事件初始化的一个方式     '''     def __init__(self,event_type,data=None):         self._type = event_type         self._data = data     @property   

python django模型内部类meta

Django 模型类的Meta是一个内部类,它用于定义一些Django模型类的行为特性.下面对此作一总结: abstract 这个属性是定义当前的模型类是不是一个抽象类.所谓抽象类是不会相应数据库表的.一般我们用它来归纳一些公共属性字段,然后继承它的子类能够继承这些字段. 比方以下的代码中Human是一个抽象类.Employee是一个继承了Human的子类,那么在执行syncdb命令时,不会生成Human表.可是会生成一个Employee表,它包括了Human中继承来的字段.以后假设再加入一个C

Python 存储模型

我们对类型进行分类的第一种方式,就是看看这种类型的对象能保存多少种对象,Python 的类型,就像绝大多数其他语言一样,能容纳一个或多个值. (1) 只能保存一种对象的类型,称为原子存储/标量存储,如数值类型和字符串类型,前者只能存储数字,后者只能存储文字 (2) 可以保存多种对象的类型,称为容器存储,如列表.元组.字典,因为它们都可以存储数值.字符串.列表等类型

Python 更新模型

更新模型分为两种,即可变类型和不可变类型: (1) 可变类型:该类型的值可以被修改,列表.字典都属于这种类型 (2) 不可变类型:该类型的值不可以被修改,数字.字符串.元组都属于这种类型

Python 访问模型

访问模型即根据访问我们存储的数据的方式对数据类型进行分类,在访问模型中有三种访问方式: (1) 直接存取:即对该类型内的元素可以直接访问,所有的数值类型都归到这一类 (2) 顺序:序列类型中的元素是从 0 开始的索引顺序来访问的,字符串.列表.元组都归到这一类 (3) 映射:映射类型有键值对,通过一个唯一的键来访问,字典归到这一类