随着计算机技术的飞速发展以及视频采集设备的大规模应用，对于计算机视觉的研究也受到越来越多的关注。目标跟踪作为计算机视觉领域中的关键技术之一，被广泛地应用于军事制导，视觉导航，机器人，智能交通，公共安全等领域。在本文中我使用了三种算法综合实现了对多车辆的跟踪任务。
Github：https://github.com/xiaochus/Vehicle_Tracking
PS:文章中代码可能不够完全，完整的代码结构参考github给出的文件。
算法
- 目标检测: MOG2
- 目标跟踪: KCF
- 物体分类: CNN
环境
- Python 3.6
- OpenCV 3.2 + contrib
- Tensorflow-gpu 1.0
- Keras 1.2
目标检测
我们使用MOG2进行当前帧的目标检测任务。MOG2是一种背景减除算法，在之前的文章中进行了介绍。目标检测的代码如下所示：
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
history = 20 # MOG2训练使用的帧数
frames = 0 # 当前帧数
counter = 0 # 当前目标id
cv2.namedWindow("detection", cv2.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]
th = cv2.erode(th, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=2)
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)
在遍历检测框时，我们使用面积3000作为阈值对检测框进行过滤，去掉过小的检测框，以减轻分类模型运行的次数。
在提取目标之后，我们先对其进行重置大小，去均值等操作，然后将其送入CNN模型，判断是否为车辆。如果当前目标为车辆，那么就与跟踪列表中的对象进行对比。这里我们对比两者的IOU，即重叠度，只有当前目标与列表中所有的目标的重叠度都很小时，才会将当前目标加入跟踪列表。
for c in contours:
x, y, w, h = cv2.boundingRect(c)
if cv2.contourArea(c) > 3000:
# 提取目标
img = frame[y: y + h, x: x + w, :]
rimg = cv2.resize(img, (64, 64), interpolation=cv2.INTER_CUBIC)
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:
count += 1
if count == num:
track_list.append(e)
else:
track_list.append(e)
counter += 1
矩形框重叠度函数：
def overlap(box1, box2):
"""
检查两个矩形框的重叠程度.
"""
endx = max(box1[0] + box1[2], box2[0] + box2[2])
startx = min(box1[0], box2[0])
width = box1[2] + box2[2] - (endx - startx)
endy = max(box1[1] + box1[3], box2[1] + box2[3])
starty = min(box1[1], box2[1])
height = box1[3] + box2[3] - (endy - starty)
if (width <= 0 or height <= 0):
return 0
else:
Area = width * height
Area1 = box1[2] * box1[3]
Area2 = box2[2] * box2[3]
ratio = Area / (Area1 + Area2 - Area)
return ratio
在处理完新的物体后，我们对跟踪列表中的对象进行处理。如果对象的中心接近帧边界，那么就将其从列表中移除。如果没有，那么就对该对象进行更新操作，激活其跟踪器。
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
self.windows = windows
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
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)
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与池化层组成。如下图：
model.png
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)))
model.add(BatchNormalization())
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())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.2))
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)
df.to_csv('hist.csv', encoding='utf-8', index=False)
model.save('weights.h5')
结果
运行下列命令，即可对video文件夹中保存的文件进行处理。
python track.py --file "car.flv"
效果如下图所示：
show.png
