算法
目标检测: MOG2
OpenCV提供了一个称为BackgroundSubtractor的类，在分割前景和背景时很方便。
在OpenCV3中有三种背景分割器：K-Nearest（KNN）、Mixture of Gaussians（MOG2）、Geometric Multigid（GMG）
BackgroundSubtractor类是专门用于视频分析的，即BackgroundSubtractor类会对每帧的环境进行“学习”。BackgroundSubtractor类常用来对不同帧进行比较，并存储以前的帧，可按时间推移方法来提高运动分析的结果。
BackgroundSubtractor类的另一个基本特征是它可以计算阴影。这对于精确读取视频帧绝对是至关重要的；通过检测阴影，可以排除检测图像的阴影区域（采用阈值方式），从而能关注实际特征。
目标跟踪:KCF
KCF是一种鉴别式追踪方法，这类方法一般都是在追踪过程中训练一个目标检测器，使用目标检测器去检测下一帧预测位置是否是目标，然后再使用新检测结果去更新训练集进而更新目标检测器。而在训练目标检测器时一般选取目标区域为正样本，目标的周围区域为负样本，当然越靠近目标的区域为正样本的可能性越大。
物体分类: CNN(卷积神经网络)
环境
Python 3
OpenCV + contrib
Tensorflow
Keras
Keras是一个高层神经网络API，Keras由纯Python编写而成并基Tensorflow、Theano以及CNTK后端。Keras 为支持快速实验而生，能够把你的idea迅速转换为结果.
目标检测
我们使用MOG2进行当前帧的目标检测任务。MOG2是一种背景减除算法，在之前的文章中进行了介绍。目标检测的代码如下所示：
OpenCV函数：cv2.erode(), cv2.dilate()
形态学操作一般作用于二值化图，来连接相邻的元素或分离成独立的元素。腐蚀和膨胀是针对图片中的白色部分！
腐蚀：腐蚀的效果是把图片"变瘦"，其原理是在原图的小区域内取局部最小值。这样原图中边缘地方就会变成0，达到了瘦身目的。
膨胀：膨胀与腐蚀相反，取的是局部最大值，效果是把图片"变胖"。
1690384-2d79afac906a96ec.jpg
import sys
import copy
import argparse
import cv2
import numpy as np
from keras.models import load_model
from utils.entity import Entity
camera = cv2.VideoCapture(video) #对视频进行读取操作以及调用摄像头
res, frame = camera.read() #获取视频帧,返回成功/失败，帧
y_size = frame.shape[0]
x_size = frame.shape[1]
# 导入CNN分类模型
model = load_model('model//weights.h5')
bs = cv2.createBackgroundSubtractorMOG2(detectShadows=True) # 定义MOG2，用于动态目标检测，是基于自适应混合高斯背景建模的背景减除法，detectShadows：是否检测影子
history = 20 # MOG2训练使用的帧数
frames = 0 # 当前帧数
counter = 0 # 当前目标id
cv2.namedWindow("detection", cv2.WINDOW_NORMAL) #通过指定的名字，创建一个可以作为图像和进度条的容器窗口。WINDOW_NORMAL设置了这个值，用户便可以改变窗口的大小（没有限制)
while True:
res, frame = camera.read()
if not res:
break
# 使用前20帧训练MOG2
fg_mask = bs.apply(frame)
if frames < history:
frames += 1
continue
# 对帧图像进行膨胀与去噪声操作
th = cv2.threshold(fg_mask.copy(), 244, 255, cv2.THRESH_BINARY)[1] #固定阈值二值化:像素高于阈值时，给像素赋予新值，否则，赋予另外一种颜色.ret, dst = cv2.threshold(src, thresh, maxval, type),当像素值超过了thresh（或者小于thresh，根据type来决定），赋予maxval，因为是二值化图，只有0和255
th = cv2.erode(th, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=2) #腐蚀图像erode(img, kernel)，MORPH_ELLIPSE：椭圆
dilated = cv2.dilate(th, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (8, 3)), iterations=2) #膨胀图像
# 获得目标位置
image, contours, hier = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) #查找检测物体的轮廓，cv2.findContours(image, mode, method[, contours[, hierarchy[, offset ]]])，
# 参数为二值图，即黑白的，mode为轮廓的检索模式，cv2.RETR_EXTERNAL表示只检测外轮廓，method为轮廓的近似办法， cv2.CHAIN_APPROX_SIMPLE压缩水平方向，垂直方向，对角线方向的元素，只保留该方向的终点坐标，例如一个矩形轮廓只需4个点来保存轮廓信息
# contour返回值，返回一个list，list中每个元素都是图像中的一个轮廓
# hierarchy返回值,每个轮廓contours[i]对应4个hierarchy元素hierarchy[i][0] ~hierarchy[i][3]，分别表示后一个轮廓、前一个轮廓、父轮廓、内嵌轮廓的索引编号，如果没有对应项，则该值为负数。
在提取目标之后，我们先对其进行重置大小，去均值等操作，然后将其送入CNN模型，判断是否为车辆。如果当前目标为车辆，那么就与跟踪列表中的对象进行对比。这里我们对比两者的IOU，即重叠度，只有当前目标与列表中所有的目标的重叠度都很小时，才会将当前目标加入跟踪列表。
for c in contours:
x, y, w, h = cv2.boundingRect(c) #用一个最小的矩形，把找到的形状包起来,x，y是矩阵左上点的坐标，w，h是矩阵的宽和高
if cv2.contourArea(c) > 3000: #在遍历检测框时，我们使用面积3000作为阈值对检测框进行过滤，去掉过小的检测框，以减轻分类模型运行的次数。
# 提取目标
img = frame[y: y + h, x: x + w, :]
rimg = cv2.resize(img, (64, 64), interpolation=cv2.INTER_CUBIC) #图像缩放,cv2.INTER_CUBIC:4x4像素邻域的双三次插值
image_data = np.array(rimg, dtype='float32') #图片与数组的转化
image_data /= 255.
roi = np.expand_dims(image_data, axis=0) #转换为预测所需类型
# 分类
flag = model.predict(roi)
if flag[0][0] > 0.5:
e = Entity(counter, (x, y, w, h), frame)
# 排除重复目标
if track_list:
count = 0
num = len(track_list)
for p in track_list: #对比当前目标和跟踪列表中现有目标
if overlap((x, y, w, h), p.windows) < iou:#track_list重叠,iou:目标窗口和原来标记窗口的交叠率，小于说明重叠度比较小（不重叠）
count += 1
if count == num: #说明没有重叠的目标
track_list.append(e)
else:
track_list.append(e)
counter += 1 #目标id
在处理完新的物体后，我们对跟踪列表中的对象进行处理。如果对象的中心接近帧边界，那么就将其从列表中移除。如果没有，那么就对该对象进行更新操作，激活其跟踪器。
if track_list:
tlist = copy.copy(track_list)
for e in tlist:
x, y = e.center #获取跟踪目标的中心
if 10 < x < x_size - 10 and 10 < y < y_size - 10:
e.update(frame) #更新操作，激活其跟踪器。
else:
track_list.remove(e)
目标跟踪
KCF(kernelized correlation filters)，全称核相关滤波，是一种鉴别式追踪方法。这类方法一般都是在追踪过程中训练一个目标检测器，使用目标检测器去检测下一帧预测位置是否是目标，然后再使用新检测结果去更新训练集进而更新目标检测器。而在训练目标检测器时一般选取目标区域为正样本，目标的周围区域为负样本，当然越靠近目标的区域为正样本的可能性越大。
我们定义了一个实体类，该类为每一个被检测到的物体实例化一个对象。对象实例化时会初始化一个KCF跟踪器。KCF跟踪器接受一个帧与目标的坐标位置。通过update()函数载入最新的帧，KCF跟踪器能够计算目标在当前帧中所处的位置。
# coding:utf8
import cv2
import numpy as np
class Entity(object):
def __init__(self, vid, windows, frame):
self.vid = vid #目标ID
self.windows = windows #目标矩阵，x y w h
self.center = self._set_center(windows) #目标中心
self.trajectory = [self.center] #轨迹
self.tracker = self._init_tracker(windows, frame) #跟踪器
def _set_center(self, windows):
x, y, w, h = windows
x = (2 * x + w) / 2 #x,y更新了？
y = (2 * y + h) / 2
center = np.array([np.float32(x), np.float32(y)], np.float32)
return center
def _init_tracker(self, windows, frame):
"""
初始化KCF跟踪器
"""
x, y, w, h = windows
tracker = cv2.Tracker_create('KCF')
tracker.init(frame, (x, y, w, h)) #初始化一个帧与目标的坐标位置
return tracker
def update(self, frame):
"""
更新目标位置
"""
self.tracker.update(frame)
ok, new_box = self.tracker.update(frame) # retval, boundingBox = cv.Tracker.update( image )
if ok:
x, y, w, h = int(new_box[0]), int(new_box[1]), int(new_box[2]), int(new_box[3])
self.center = self._set_center((x, y, w, h))
self.windows = (x, y, w, h)
self.trajectory.append(self.center) #轨迹增加中心点
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1) #画出矩阵
cv2.putText(frame, "vehicle", (x, y - 5),cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA) #添加文字
cv2.polylines(frame, [np.int32(self.trajectory)], 0, (0, 0, 255)) #绘制轨迹
分类数据
我们使用MIT的车辆与行人数据训练分类模型，数据为ppm格式，大小分别为128X128与128X64。为了使用数据统一并且符合CNN模型的输入，我们对其进行了处理操作，统一了大小。
# coding: utf8
import os
import cv2
def main():
path1 = 'cars128x128//'
path2 = 'pedestrians128x64//'
path3 = 'data//train//cars//'
path4 = 'data//train//pedestrians//'
for root, dirs, files in os.walk(path1):#目录遍历器
for f in files:
n = f.split('.')[0] #文件名
img = path1 + f
image = cv2.imread(img) #读取图片
resized_image = cv2.resize(image, (64, 64), interpolation=cv2.INTER_CUBIC)
cv2.imwrite(path3 + str(n) + '.jpg', resized_image)
for root, dirs, files in os.walk(path2):
for f in files:
n = f.split('.')[0]
img = path2 + f
image = cv2.imread(img)
resized_image = cv2.resize(image, (64, 64), interpolation=cv2.INTER_CUBIC)
cv2.imwrite(path4 + str(n) + '.jpg', resized_image)
if __name__ == '__main__':
main()
点击下载原始数据与处理好的数据。
CNN分类模型
我们使用了3层的CNN网络作为分类模型，每个卷积单元由卷积层、BN层、LeakyRelu与池化层组成。如下图：
image
CNN网络使用Keras进行定义，如下：
# coding: utf8
from keras.models import Sequential
from keras.regularizers import l2
from keras.layers import Convolution2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import LeakyReLU
def cnn_net(size):
model = Sequential()
model.add(Convolution2D(16, 5, 5, W_regularizer=l2(5e-4), border_mode='same', input_shape=(size, size, 3))) #卷积层，，第一个参数：卷积核的数目（即输出的维度），input_shape = (128,128,3)代表128*128的彩色RGB图像
model.add(BatchNormalization()) #规范化，该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1
model.add(LeakyReLU(alpha=0.1)) #激活函数，增加神经网络模型的非线性
model.add(MaxPooling2D(pool_size=(2, 2))) #池化层，池化层对输入做降采样，常用的池化做法是对每个滤波器的输出求最大值，平均值，中位数等。
model.add(Convolution2D(32, 5, 5, W_regularizer=l2(5e-4), border_mode='same'))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(64, 3, 3, W_regularizer=l2(5e-4), border_mode='same'))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) #Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。
model.add(Dense(128)) #Dense就是常用的全连接层，就是将样本从特征空间映射到标签。全连接层的每一个结点都与上一层的所有结点相连，用来把前边提取到的特征综合起来。由于其全相连的特性，一般全连接层的参数也是最多的。
model.add(Activation('relu')) #激活层
model.add(Dropout(0.2)) #Dropout将在训练过程中每次更新参数时按一定概率（rate）随机断开输入神经元，Dropout层用于防止过拟合。
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='Adam', metrics=['accuracy']) #编译模型以供训练
return model
数据增强与模型训练
Keras提供了数据增强的功能，能够增加数据量并且防止过拟合。使用ImageDataGenerator能够将文件夹中的原始数据转化为生成器，供模型使用。
import os
import sys
import argparse
import pandas as pd
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import EarlyStopping
from keras.utils.visualize_util import plot
def data_process(size, batch_size_train, batch_size_val):
path = os.path.abspath(os.path.join(os.path.dirname("__file__"), os.path.pardir))
datagen1 = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
rotation_range=90,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True) #图片生成器
datagen2 = ImageDataGenerator(rescale=1. / 255)
train_generator = datagen1.flow_from_directory(
path + '//data//train',
target_size=(size, size),
batch_size=batch_size_train,
class_mode='binary') #以文件夹路径为参数,生成经过数据提升/归一化后的数据
validation_generator = datagen2.flow_from_directory(
path + '//data//validation',
target_size=(size, size),
batch_size=batch_size_val,
class_mode='binary')
return train_generator, validation_generator
模型训练函数如下所示，我们在训练的过程中引入了EarlyStopping，保证模型在准确度不再上升的时候自动结束训练。
def train(model, epochs, batch_size_train, batch_size_val, size):
train_generator, validation_generator = data_process(size, batch_size_train, batch_size_val)
earlyStopping = EarlyStopping(monitor='val_loss', patience=50, verbose=1, mode='auto') #当监测值不再改善时，该回调函数将中止训练
hist = model.fit_generator(
train_generator,
nb_epoch=epochs,
samples_per_epoch=batch_size_train,
validation_data=validation_generator,
nb_val_samples=batch_size_val,
callbacks=[earlyStopping])
df = pd.DataFrame.from_dict(hist.history) #记录了损失函数和其他指标的数值随epoch变化的情况，如果有验证集的话，也包含了验证集的这些指标变化情况
df.to_csv('hist.csv', encoding='utf-8', index=False)
model.save('weights.h5')
结果
运行下列命令，即可对video文件夹中保存的文件进行处理。
python track.py --file "car.flv"
效果如下图所示：
image
