OpenCv
OpenCv是一个C++库，用于处理计算机视觉问题。
10.1 OpenCv的Python 接口
直接使用pip install opencv-python即可安装。
10.2 OpenCv的基础知识
OpenCV 自带读取、写入图像函数以及矩阵操作和数学库。
10.2.1 读取和写入图像
下面这个简短的例子会载入一张图像，打印出图像大小，对图像进行转换并保存
为 .png 格式：
import cv2
# 读取图像
im = cv2.imread('empire.jpg')
h,w = im.shape[:2]
print h,w
# 保存图像
cv2.imwrite('result.png',im)
函数 imread() 返回图像为一个标准的 NumPy 数组，并且该函数能够处理很多不同格式的图像。该函数可以作为 PIL 模块读取图像的备选方案。函数imwrite() 会根据文件后缀自动转换图像。
控制台输出：
10.2.2 颜色空间
在 OpenCV 中，图像不是按传统的 RGB 颜色通道，而是按 BGR 顺序（即 RGB 的倒序）存储的。读取图像时默认的是 BGR，但是还有一些可用的转换函数。颜色空间的转换可以用函数 cvColor() 来实现。
在读取原图像之后，紧接其后的是 OpenCV 颜色转换代码，其中最有用的一些转换代码如下：
1.cv2.COLOR_BGR2GRAY (原图像转化为灰度图像)
2.cv2.COLOR_BGR2RGB (原图像转化为RGB图像)
3.cv2.COLOR_GRAY2BGR (灰度图像图像转化为BGR图像)
import cv2
from pylab import *
im = cv2.imread('shangdalou.jpg')
gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
#imshow(gray)
k = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
imshow(k)
show()
10.2.3 显示图像及结果
用 OpenCV 处理图像，利用 OpenCV 绘制功能和窗口管理功能来显示结果。首先是从文件中读取一幅图像，并创建一个整数图像表示：
import cv2
im = cv2.imread('shangdalou.jpg')
gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
intim = cv2.integral(gray)
intim = (255.0*intim) / intim.max()
cv2.imwrite('result.jpg',intim)
读取图像后，将其转化为灰度图像，函数 integral() 创建一幅图像，该图像的每个像素值是原图上方和左边强度值相加后的结果；这对于快速评估特征是一个非常有用的技巧。在保存图像前，通过除以图像中的像素最大值将其归一化到 0 至 255 之间。图显示了示例图像结果。
第二个 例子是从一个种子像素进行泛洪填充：
import cv2
filename = 'fisherman.jpg'
im = cv2.imread(filename)
h,w = im.shape[:2]
# 泛洪填充
diff = (6,6,6)
mask = zeros((h+2,w+2),uint8)
cv2.floodfill(im,mask,(10,10), (255,255,0),diff,diff)
# 在 OpenCV 窗口中显示结果
cv2.imshow('flood fill',im)
cv2.waitKey()
# 保存结果
cv2.imwrite('result.jpg',im)
在该例中，对图像应用泛洪填充并在 OpenCV 窗口中显示结果。waitKey() 函数一直处于暂停状态，直到有按键按下，此时窗口才会自动关闭。这里的 floodfill() 函数获取（灰度或彩色）图像、一个掩膜（非零像素区域表明该区域不会被填充）、一个种子像素以及新的颜色值来代替下限和上限阈值差的泛洪像素。泛洪填充以种子像素为起始，只要能在阈值的差异范围内添加新的像素，泛洪填充就会持续扩展。不同的阈值差异由元组 (R,G,B) 给出。
第三个例子SURF 特征的提取，SURF 特征是 SIFT 特征的一个更快特征提取版。
import cv2
# 读取图像
im = cv2.imread('empire.jpg')
# 下采样
im_lowres = cv2.pyrDown(im)
# 变换成灰度图像
gray = cv2.cvtColor(im_lowres,cv2.COLOR_RGB2GRAY)
# 检测特征点
s = cv2.SURF()
mask = uint8(ones(gray.shape))
keypoints = s.detect(gray,mask)
# 显示结果及特征点
vis = cv2.cvtColor(gray,cv2.COLOR_GRAY2BGR)
for k in keypoints[::10]:
cv2.circle(vis,(int(k.pt[0]),int(k.pt[1])),2,(0,255,0),-1)
cv2.circle(vis,(int(k.pt[0]),int(k.pt[1])),int(k.size),(0,255,0),2)
cv2.imshow('local descriptors',vis)
cv2.waitKey()
读取图像后，如果没有给定新尺寸，则用 pyrDown() 进行下采样，创建一个尺寸为原图像大小一半的新图像，然后将该图像转换为灰度图像，并传递到一个 SURF 关键点检测对象；掩膜决定了在哪些区域应用关键点检测器。在画出检测结果时，我们将灰度图像转换成彩色图像，并用绿色通道画出检测到的关键点。我们在每到第十个关键点时循环一次，并在中心画一个圆环，每一个圆环显示出关键点的尺度（大小）。绘图函数circle() 获取一幅图像、图像坐标（仅整数坐标）元组、半径、绘图的颜色元组以及线条粗细（-1 是实线圆环）。图显示了提取出来的 SURF 特征。
10.3 处理视频
10.3.1 视频输入
OpenCV 能够很好地支持从摄像头读取视频。下面给出了一个捕获视频帧并在OpenCV 窗口中显示这些视频帧的完整例子：
import cv2
cap = cv2.VideoCapture(0)
while True:
ret,im = cap.read()
cv2.imshow('video test',im)
key = cv2.waitKey(10)
if key == 27:
break
if key == ord(' '):
cv2.imwrite('vid_result.jpg',im)
捕获对象 VideoCapture 从摄像头或文件捕获视频。我们通过一个整数进行初始化，该数为视频设备的 id；如果仅有一个摄像头与计算机相连接，那么该摄像头的 id为 0.read()方法解码并返回下一视频帧，第一个变量 ret 是一个判断视频帧是否成功读入的标志，第二个变量则是实际读入的图像数组。函数 waitKey() 等待用户按键：如果按下的是 Esc 键、（ASCII 码是 27）键，则退出应用；如果按下的是空格键，就保存该视频帧。
拓展上面的例子，将摄像头捕获的数据作为输入，并在 OpenCV 窗口中实时显示经模糊的（彩色）图像，我们只需对上面的例子做简单的修改：
import cv2
# 设置视频捕获
cap = cv2.VideoCapture(0)
# 获取视频帧，应用高斯平滑，显示结果
while True:
ret,im = cap.read()
blur = cv2.GaussianBlur(im,(0,0),5)
cv2.imshow('camera blur',blur)
if cv2.waitKey(10) == 27:
break
每一视频帧都会被传递给 GaussianBlur() 函数，该函数会用高斯滤波器对传入的该帧图像进行滤波。这里，我们传递的是彩色图像，所以 Gaussian Blur() 函数会录入对彩色图像的每一个通道单独进行模糊。该函数需要为高斯函数设定滤波器尺寸（保存在元组中）及标准差；在本例中标准差设为 5。如果该滤波器尺寸设为 0，则它由标准差自动决定。
10.3.2 将视频读取到NumPy数组中
使用 OpenCV 可以从一个文件读取视频帧，并将其转换成 NumPy 数组。下面是一个从摄像头捕获视频并将视频帧存储在一个 NumPy 数组中的例子：
import cv2
from numpy import *
cap = cv2.VideoCapture(0)
frames = []
while True:
ret,im = cap.read()
cv2.imshow('video',im)
frames.append(im)
if cv2.waitKey(10) == 27:
break
frames = array(frames)
print im.shape
print frames.shape
上述代码将每一视频帧数组添加到列表末，直到捕获结束。最终得到的数组会有帧数、帧高、帧宽及颜色通道数（3 个）。
10.4 跟踪
跟踪是在图像序列或视频里对其中的目标进行跟踪的过程。
10.4.1 光流
光流是目标、场景或摄像机在连续两帧图像间运动时造成的目标的运动。它是图像在平移过程中的二维矢量场。作为一种经典并深入研究了的方法，它在诸如视频压缩、运动估计、目标跟踪和图像分割等计算机视觉中得到了广泛的应用。
光流法主要依赖于三个假设
(1) 亮度恒定 图像中目标的像素强度在连续帧之间不会发生变化。
(2) 时间规律 相邻帧之间的时间足够短，以至于在考虑运行变化时可以忽略它们之间的差异。该假设用于导出下面的核心方程。
(3) 空间一致性 相邻像素具有相似的运动。
在很多情况下这些假设并不成立，但是对于相邻帧间的小运动以及短时间跳跃，它还是一个非常好的模型。假设一个目标像素在 t 时刻亮度为 I(x,y,t)，在 t+δt 时刻运动 [δx,δy] 后与 t 时刻具有相同的亮度，即 I(x,y,t)=I(x+δx, y+δy, t+δt). 对该约束用泰勒公式进行一阶展开并关于 t 求偏导可以得到光流方程：
v=[u,v] 是运动矢量，It 是时间偏导。对于图像中那些单个的点，该方程是线性方程组。由于 v 包含两个未知变量，所以该方程是不可解的。通过强制加入空间一致性约束，则有可能获得该方程的解。Lucas-Kanade 算法会利用该假设。
# -*- coding: utf-8 -*-
import cv2
import numpy as np
from pylab import *
from PIL import Image
def draw_flow(im,flow,step=16):
""" 在间隔分开的像素采样点处绘制光流 """
h,w = im.shape[:2]
y,x = mgrid[step/2:h:step,step/2:w:step].reshape(2,-1)
fx, fy = flow[y, x].T
# 创建线的终点
lines = vstack([x,y,x+fx,y+fy]).T.reshape(-1,2,2)
lines = int32(lines)
# 创建图像并绘制
vis = cv2.cvtColor(im, cv2.COLOR_GRAY2BGR)
for (x1, y1), (x2, y2) in lines:
cv2.line(vis, (x1, y1), (x2, y2), (0, 255, 0), 1)
cv2.circle(vis, (x1, y1), 1, (0, 255, 0), -1)
return vis
#设置视频捕获
cap = cv2.VideoCapture(0)
ret,im = cap.read()
prev_gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
while True:
# 获取灰度图像
ret,im = cap.read()
gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
# 计算流
flow = cv2.calcOpticalFlowFarneback(prev_gray,gray,None,0.5,3,15,3,5,1.2,0)
prev_gray = gray
# 画出流矢量
cv2.imshow('Optical flow',draw_flow(gray,flow))
if cv2.waitKey(10) == 27:
break
利用摄像头捕获图像，并对每个连续图像对进行光流估计。由calcOpticalFlowFarneback() 返回的运动光流矢量保存在双通道图像变量 flow 中。辅助函数 draw_flow() 会在图像均匀间隔的点处绘制光流矢量， 它利用 OpenCV 的绘图函数 line() 和 circle()，并用变量 step 控制流样本的间距。 最终的结果上图所示：圆环网格表示流样本的位置，带有线条的流矢量显示了每个样本点是怎样运动的。
10.4.2 Lucas-Kanade算法
跟踪最基本的形式是跟随感兴趣点，比如角点。Lucas-Kanade 跟踪算法可以应用于任何一种特征，不过通常使用一些角点，角点是结构张量（Harris 矩阵）中有两个较大特征值的那些点，且更小的特征值要大于某个阈值。
如果基于每一个像素考虑，该光流方程组是欠定方程，即每个方程中含很多未知变量。利用相邻像素有相同运动这一假设，对于 n 个相邻像素，可以将这些方程写成如下系统方程：
该系统方程的优势是，现在方程的数目多于未知变量，并且可以用最小二乘法解出该系统方程。对于周围像素的贡献可以进行加权处理，使越远的像素影响越小；高斯权重是一种最常见的选择。可以得出以下关系：
该超定方程组可以用最小二乘法求解，得出运动矢量：
v 只有在 ATA 可逆时才是可解的，如果应用在 Harris 角点或 Shi-Tomasi 的“利于跟踪的好的特征 features to track”上，ATA 是可逆的。这就是 Lucas-Kanade 跟踪算法运行矢量怎样计算出来的全过程。
# -*- coding: utf-8 -*-
from numpy import *
import cv2
# 一些常数及默认参数
lk_params = dict(winSize=(15,15),maxLevel=2,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,10,0.03))
subpix_params = dict(zeroZone=(-1,-1),winSize=(10,10),
criteria = (cv2.TERM_CRITERIA_COUNT | cv2.TERM_CRITERIA_EPS,20,0.03))
feature_params = dict(maxCorners=500,qualityLevel=0.01,minDistance=10)
class LKTracker(object):
""" 用金字塔光流 Lucas-Kanade 跟踪类"""
def __init__(self,imnames):
""" 使用图像名称列表初始化 """
self.imnames = imnames
self.features = []
self.tracks = []
self.current_frame = 0
def step(self,framenbr=None):
""" 移到下一帧。如果没有给定参数，直接移到下一帧 """
if framenbr is None:
self.current_frame = (self.current_frame + 1) % len(self.imnames)
else:
self.current_frame = framenbr % len(self.imnames)
def detect_points(self):
""" 利用子像素精确度在当前帧中检测“利于跟踪的好的特征”( 角点 ) """
# 载入图像并创建灰度图像
self.image = cv2.imread(self.imnames[self.current_frame])
self.gray = cv2.cvtColor(self.image,cv2.COLOR_BGR2GRAY)
# 搜索好的特征点
features = cv2.goodFeaturesToTrack(self.gray, **feature_params)
# 提炼角点位置
cv2.cornerSubPix(self.gray,features, **subpix_params)
self.features = features
self.tracks = [[p] for p in features.reshape((-1,2))]
self.prev_gray = self.gray
def track_points(self):
""" 跟踪检测到的特征 """
if self.features != []:
self.step() # 移到下一帧
# 载入图像并创建灰度图像
self.image = cv2.imread(self.imnames[self.current_frame])
self.gray = cv2.cvtColor(self.image,cv2.COLOR_BGR2GRAY)
#reshape() 操作，以适应输入格式
tmp = float32(self.features).reshape(-1, 1, 2)
# 计算光流
features,status,track_error = cv2.calcOpticalFlowPyrLK(self.prev_gray,self.gray,tmp,None,**lk_params)
# 去除丢失的点
self.features = [p for (st,p) in zip(status,features) if st]
# 从丢失的点清楚跟踪轨迹
features = array(features).reshape((-1,2))
for i,f in enumerate(features):
self.tracks[i].append(f)
ndx = [i for (i,st) in enumerate(status) if not st]
ndx.reverse() # 从后面移除
for i in ndx:
self.tracks.pop(i)
self.prev_gray = self.gray
def track(self):
""" 发生器，用于遍历整个序列 """
for i in range(len(self.imnames)):
if self.features == []:
self.detect_points()
else:
self.track_points()
#创建一份 RGB 副本
f = array(self.features).reshape(-1,2)
im = cv2.cvtColor(self.image,cv2.COLOR_BGR2RGB)
yield im,f
def draw(self):
""" 用 OpenCV 自带的画图函数画出当前图像及跟踪点，按任意键关闭窗口 """
# 用绿色圆圈画出跟踪点
for point in self.features:
cv2.circle(self.image,(int(point[0][0]),int(point[0][1])),3,(0,255,0),-1)
cv2.imshow('LKtrack',self.image)
cv2.waitKey()
现在，我们用 OpenCV 函数实现了一个完整独立的跟踪系统。
1. 使用跟踪器
将该跟踪类用于真实的场景中。下面的脚本初始化一个跟踪对象，对视频序列进行角点检测、跟踪，并画出跟踪结果：
# -*- coding: utf-8 -*-
import lktrack
imnames = ['D:\\Python\\chapter10\\bt.003.pgm', 'D:\\Python\\chapter10\\bt.002.pgm', 'D:\\Python\\chapter10\\bt.001.pgm', 'D:\\Python\\chapter10\\bt.000.pgm']
# 创建跟踪对象
lkt = lktrack.LKTracker(imnames)
# 在第一帧进行检测，跟踪剩下的帧
lkt.detect_points()
lkt.draw()
for i in range(len(imnames)-1):
lkt.track_points()
lkt.draw()
2. 使用发生器
# -*- coding: utf-8 -*-
import lktrack
import cv2
import numpy as np
from pylab import *
from PIL import Image
imnames = ['D:\\Python\\chapter10\\bt.003.pgm', 'D:\\Python\\chapter10\\bt.002.pgm', 'D:\\Python\\chapter10\\bt.001.pgm', 'D:\\Python\\chapter10\\bt.000.pgm']
# 用 LKTracker 发生器进行跟踪
lkt = lktrack.LKTracker(imnames)
for im,ft in lkt.track():
print 'tracking %d features' % len(ft)
# 画出轨迹
figure()
imshow(im)
for p in ft:
plot(p[0],p[1],'bo')
for t in lkt.tracks:
plot([p[0] for p in t],[p[1] for p in t])
axis('off')
show()
显示跟踪点的轨迹。
扫一扫
22万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
