照相机模型与现实增强

照相机模型与现实增强

(该实验参书籍：Python计算机视觉编程 第四章)

（代码为书上源码）

该实验的整合版代码在该网址下（只需在test.py中选择自己想要运行的功能即可）：
https://download.csdn.net/download/titansm/11092782

文章目录

• 照相机模型与现实增强
• 1.运行增强现实相关代码是遇到的问题
• 2.在视频实现现实增强
• 3.开始实验
• 1.用摄像头获取视频（如果是用手机拍摄的话可以跳过，建议不要录太长的视频）
• 2.对生成的视频进行sift特征处理
• 3.增强现实的实现
• 4.视频合成

1.运行增强现实相关代码是遇到的问题

问题1：OpenGL.error.NullFunctionError: Attempt to call an undefined function glutInitDisplayMode…

该问题的主要原因是我们的机器大部分都是64位的，但是通过pip install opengl 安装的版本默认为32位的

https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyopengl

可以在该地址里下载opengl的安装包（在网页的下面，要下拉挺久的）

下载64位的版本，然后通过 pip install PyOpenGl-3.1.3b2-cp27m-win_amd64.whl 来安装opengl

问题2：freeglut ERROR: Function called without first calling ‘glutInit’.

这个错误是freeglut和glut共存的缘故，它们俩定义了相同的方法，这个是动态链接库的重叠问题，将Anaconda2\Lib\site-packages\OpenGL\DLLS文件夹里面的freeglut64.vc9.dll删掉就行了。

应该只有这些问题。。

2.在视频实现现实增强

要在视频上实现现实增强我们需要先用摄像头采集一段视频，还有用同一个摄像头拍三张照片

照片如下：

1.用来测定照相机标定矩阵的图片

2.实现现实增强时使用的图片（两张）

第一张图片是我将书贴在墙上然后找了个较长的桌子拍成的（如下）

因为我们测定标定矩阵的时候需要拍照物品的边长dX和dY(也就是书的宽和长)；

然后镜头和物体要平行，在测量照相机到物体的镜头的距离dZ；

最后还需要用像素测量标定物体图像的宽度和高度（dx和dy）

前两个可以用尺子直接测量出来，后一个可以用Windows自带的画图工具，然后打开图片

1.选择裁剪功能；

2.把标定的物体截出来（尽量按边截，上图有点截太大了）

3.下面的第一个像素就是 标定物体的宽度和高度

我测量好之后我得到的数据分别是：

dX=179mm，dY=233mm，dZ=827mm，dx=164，dy=212

然后用公式
$fx=dx/dX*dZ$fx=dx/dX∗dZ

$fy=dy/dY*dZ$fy=dy/dY∗dZ

即可获得焦距的大小，我的焦距的大小为：

​ fx=758

​ fy=752

然后将原代码中的函数 my_calibration(sz) 中的对应的位置替换成自己的（如下图，其中3为我们图像的分辨率，我的为 640*480）

下面为我的模板：

def my_calibration(sz):
    row, col = sz
    fx = 758*col/640
    fy = 752*row/480
    K = diag([fx, fy, 1])
    K[0, 2] = 0.5*col
    K[1, 2] = 0.5*row
    return K

设置完相机的标定矩阵函数后，就可以开始进行我们的实验了

3.开始实验

1.用摄像头获取视频（如果是用手机拍摄的话可以跳过，建议不要录太长的视频）

用摄像头获取视频时使用的时Opencv，所以如果没装过可能要先安装一下

直接输入命令：

pip install opencv-python

安装即可。

下面为生成视频代码：

#-*- coding=utf-8 -*-
import cv2
import numpy as np

#0为默认摄像头的编号
cap = cv2.VideoCapture(0)

sz = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
        int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))

fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')

out = cv2.VideoWriter('output.avi', fourcc,30,sz) # 第三个参数则是镜头快慢的（即为帧数）
print "OK!!!!!!"
while True:
    ret,frame = cap.read()
    if ret == True:
        frame = cv2.flip(frame, 1)
        a = out.write(frame)
        cv2.imshow("frame", frame)
        cv2.imwrite("test/test3.jpg", frame) #这句代码用来将录像的最后一帧保存为图片，这样就能照相了
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    else:
        break
cap.release()
out.release()
cv2.destroyAllWindows()

用该代码调用摄像头就会在当前目录下生成视频 ”output.avi“；

还会将视频中的最后一帧保存为 .jpg图片。

由于是用摄像头，所以之前用来测标定矩阵的图片也必须是用同一个摄像头拍摄的，这样就可以用摄像头来拍照了。

2.对生成的视频进行sift特征处理

这里我是先对视频进行处理，将每一帧的图片提取并保存为.jpg和.bmp的图片，生成之后还会一起把sift特征处理好。（之前说视频建议不要太长就是因为这个可能会处理很久，当然也可以中途停下来）

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
import cv2
def makesift():
	# compute features
    sift.process_image('test3.JPG', 'im0.sift')
    l0, d0 = sift.read_features_from_file('im0.sift')

    cap = cv2.VideoCapture("output.avi")
    i = 1
    while(cap.isOpened()):
        ret, frame = cap.read()
        cv2.imwrite("test/im"+str(i)+".jpg",frame)
        cv2.imwrite("test/im"+str(i)+".bmp",frame)
        sift.process_image("test/im"+str(i)+".jpg", "test/im"+str(i)+'.sift',)
        l1, d1 = sift.read_features_from_file('im1.sift')

    cap.release()
    cv2.destroyAllWindows()

makesift()

处理完会在test文件夹（需要自己创建）下将视频的每一帧都保存为 .jpg 图片和 .bmp图片（做显示增强的时候无法使用 .jpg格式的图片）。

还会生成每张图片对应的 .sift 文件

3.增强现实的实现

实现增强现实我们需要用到PyGame和PyOpenGL两个工具包。

PyGame是非常流行的游戏开发工具包，它可以简单的处理现实窗口、输入设备等等

PyGame可以直接pip install pygame安装

PyOpenGL是OpenGL图形编程的Python绑定接口，

PyOpenGL就直接按照开头的安装方法就行

下面直接给出实现的代码，基本都是书上原本的，稍微做了一些修改用来读取之前生成的视频图片并对每一张图片进行现实增强。(有些需要更改为自己的数据的地方我会注释一下)

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
import cv2

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 = 758*col/640
    fy = 752*row/480
    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 = 640,480 ###################这个要改成自己的图片分辨率

l0, d0 = sift.read_features_from_file('im0.sift')


##########################################################################
##########################主函数#######################################
######################################################################
##从这里开始时运行的主函数
mm = 2   ## mm表示进行处理的第n张图片，我是从二张开始的
while mm<=600 : ## mm<600表示循环执行到第六张图片后就停止，这两个都可以更改为自己想要的数字
	
    l1, d1 = sift.read_features_from_file('test/im'+str(mm)+'.sift')

    matches = sift.match_twosided(d0, d1)
    if sum(matches)<=1:
    	mm=mm+1
    	continue
    try:
    	pygame.init() 
        win=pygame.display.set_mode((width,height),OPENGL | DOUBLEBUF) 
        pygame.display.set_caption("OpenGL AR demo") 
        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((640, 480))
        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)
        ###################################下面这一串是对图片进行3D模型的绘制
        path = 'test/im'+str(mm)+'.bmp'  #### 这个时读取的.bmp 格式的图片地址，可以改为自己的
        draw_background(path)
        set_projection_from_camera(K)
        set_modelview_from_camera(Rt)
        draw_teapot(0.05)
        ###################################
        pygame.image.save(win, "test2/im"+str(mm)+'.jpg') #############保存的地址可以自己随意改变
        pygame.display.flip()
        mm=mm+1
        print 'test/im'+str(mm)+'.sift     ok!!!'
    except ValueError:
        print 'im'+str(mm)+"   Error!!!"
        mm=mm+1
        continue
          

运行此函数后会出现一张张显示增强后的图片，并且将这些图片保存在test2文件夹中

如下：

4.视频合成

将所有的图片进行显示增强后，我们需要将所有的图片拼起来形成我们最后需要的图片，代码如下，使用的是Opencv：

# -*- coding: UTF-8 -*-
import os
import cv2

# 图片合成视频
def image2video(path,size,file_path):
    
    filelist = os.listdir(path)#获取该目录下的所有文件名
    fps = 10
    fourcc = cv2.VideoWriter_fourcc(*'XVID')
    video = cv2.VideoWriter( file_path, fourcc, fps, size )
    for item in filelist:
        if item.endswith('.jpg'):#判断图片后缀是否是.jpg
            item = path + '/' + item 
            img = cv2.imread(item)#使用opencv读取图像，直接返回numpy.ndarray 对象，通道顺序为BGR ，注意是BGR，通道值默认范围0-255。
            video.write(img)#把图片写进视频
            print (item)
    video.release()#释放
 

path = '' #图片地址
image2video(path,(640,480),'XXX.avi') #分别为：图片地址，分辨率，视频保存地址