Python Opencv-contrib Camshift&kalman卡尔曼滤波&CSRT算法 目标跟踪实现

本次课题实现目标跟踪一共用到了三个算法，分别是Camshift、Kalman、CSRT，基于Python语言的Tkinter模块实现GUI与接口设计，项目一共包含三个文件：

main.py：

 # coding:utf-8
 # 主模块

 import Tkinter
 import tkFileDialog
 import cv2
 import time
 from PIL import ImageTk
 # 导入自定义模块
 import track
 import utils

 # 设置窗口800*480
 root = Tkinter.Tk()
 root.title("基于视频的实时行人追踪")
 root.geometry("800x480")

 # 设置背景
 canvas = Tkinter.Canvas(root, width=800, height=480, highlightthickness=0, borderwidth=0)
 background_image = ImageTk.PhotoImage(file="background.jpg")  # 项目本地路径（背景图片）
 canvas.create_image(0, 0, anchor="nw", image=background_image)
 canvas.pack()

 # 显示提示
 label_a = Tkinter.Label(root, text="基于视频的实时行人追踪", font=("KaiTi", 20), height=2)
 label_a.pack()
 canvas.create_window(400, 100, height=25, window=label_a)

 # 显示路径
 show_path = Tkinter.StringVar()
 show_path.set("请选择一个文件夹")

 # 显示路径标签
 label_b = Tkinter.Label(root, textvariable=show_path, font=("Times New Roman", 15), height=2)
 label_b.pack()
 canvas.create_window(400, 150, window=label_b)

 # 坐标库
 ROI = utils.ROI()
 # 路径库
 path = utils.Path()

 # 选择序列
 def hit_button_a():
     path.init(tkFileDialog.askdirectory(title="Select Folder"))
     # 显示路径
     if path.img_path != "":
         show_path.set("文件路径：" + str(path.img_path)[:-1] + "\n序列总数：" + str(path.sum))
     else:
         show_path.set("路径错误！")

 button_a = Tkinter.Button(root, text="选择序列", font=("KaiTi", 15), height=2, command=hit_button_a)
 button_a.pack()
 canvas.create_window(400, 200, height=20, window=button_a)

 # ROI
 def hit_button_b():
     # 读取首帧图像
     first_image = cv2.imread(path.pics_list[0])
     # ROI
     ROI.init_window(cv2.selectROI(windowName="ROI", img=first_image, showCrosshair=True, fromCenter=False))
     cv2.destroyAllWindows()

 button_b = Tkinter.Button(root, text="标记目标", font=("KaiTi", 15), heigh=2, command=hit_button_b)
 button_b.pack()
 canvas.create_window(400, 250, height=20, window=button_b)

 # 目标追踪

 def hit_button_c():
     global camshift, kcf, csrt
     index = utils.index(path.groundtruth_path)  # 读取真值
     firstframe = True
     kalman_xy = track.KalmanFilter()
     kalman_size = track.KalmanFilter()
     bbox = [0, 0, 0, 0]

     for i in range(0, path.sum):
         start = time.time()  # 开始计时
         frame = cv2.imread(path.pics_list[i])  # 读取
         if firstframe:
             camshift = track.Camshift(frame, ROI.window)
             kcf = track.KCFtracker(frame, ROI.window)
             firstframe = False
             continue
         # camshift.update(frame)
         ok = kcf.update(frame)
         if not ok:
             mes = (bbox[0], bbox[1], bbox[2], bbox[3])
             print mes
             kcf.tracker.init(frame, mes)
             ok = kcf.update(frame)
         end = time.time()  # 结束计时
         seconds = end - start  # 处理用时
         groundtruth = index.groundtruth(i)  # 真值
         window = camshift.window
         window = kcf.window

         A = window[0] - ROI.window[0]
         B = window[1] - ROI.window[1]
         C = window[2] - ROI.window[2]
         D = window[3] - ROI.window[3]
         xy = kalman_xy.predict(A, B)
         size = kalman_size.predict(C, D)  # 卡尔曼滤波

         bbox[0] = int(ROI.window[0] + xy[0])
         bbox[1] = int(ROI.window[1] + xy[1])
         bbox[2] = int(ROI.window[2] + size[0])
         bbox[3] = int(ROI.window[3] + size[1])

         ape = index.APE(bbox, groundtruth)  # 像素误差
         aor = index.AOR(bbox, groundtruth)  # 重叠率
         # 绘制数据曲线
         # eva.draw(FPS, ape, aor, i)
         frame = utils.display(seconds, frame, bbox, ape, aor, groundtruth, truth=False)  # 跟踪框
         # 显示
         cv2.imshow("Track", frame)
         t = cv2.waitKey(20) & 0xff
         # 按空格键停止
         if t == ord(" "):
             cv2.waitKey(0)
         # 按ESC键退出
         if t == 27:
             cv2.destroyAllWindows()
             break
     cv2.destroyAllWindows()
     print ("跟踪结束!\n")

 button_c = Tkinter.Button(root, text="开始追踪", font=("KaiTi", 15), heigh=2, command=hit_button_c)
 button_c.pack()
 canvas.create_window(400, 300, height=20, window=button_c)

 root.mainloop()

自定义跟踪器模块track.py：

 # coding:utf-8
 # 追踪器模块

 import cv2
 import numpy as np

 # 得到中心点
 def center(points):
     x = (points[0][0] + points[1][0] + points[2][0] + points[3][0]) / 4
     y = (points[0][1] + points[1][1] + points[2][1] + points[3][1]) / 4
     return np.array([np.float32(x), np.float32(y)], np.float32)

 class Camshift:
     def __init__(self, frame, ROI):
         x, y, w, h = ROI
         self.window = ROI
         roi = frame[y:y + h, x:x + w]  # ROI裁剪
         hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)  # HSV转换
         mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.)))  # 设置阈值
         self.hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])  # 直方图
         cv2.normalize(self.hist, self.hist, 0, 255, cv2.NORM_MINMAX)  # 归一化

     def update(self, frame):
         term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 1, 10)  # 迭代终止标准(最多十次迭代)
         hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)  # HSV转换
         dst = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1)  # 反向投影
         # cv2.imshow("dst", dst)
         # cv2.waitKey(10)
         x, y, w, h = self.window  # 跟踪框
         ret, (x, y, w, h) = cv2.CamShift(dst, (x, y, w, h), term_crit)
         self.window = (x, y, w, h)

 class MILtracker:
     def __init__(self, frame, ROI):
         self.window = ROI
         self.tracker = cv2.TrackerMIL_create()
         self.tracker.init(frame, self.window)

     def update(self, frame):
         ok, self.window = self.tracker.update(frame)

 class KCFtracker:
     def __init__(self, frame, ROI):
         self.window = ROI
         self.tracker = cv2.TrackerKCF_create()
         self.tracker = cv2.TrackerCSRT_create()
         self.tracker.init(frame, self.window)

     def update(self, frame):
         ok, self.window = self.tracker.update(frame)
         return ok

 class CSRTtracker:
     def __init__(self, frame, ROI):
         self.window = ROI
         self.tracker = cv2.TrackerCSRT_create()
         self.tracker.init(frame, self.window)

     def update(self, frame):
         ok, self.window = self.tracker.update(frame)

 class KalmanFilter:
     def __init__(self):
         self.kalman = cv2.KalmanFilter(4, 2)
         self.kalman.measurementMatrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0]], np.float32)
         self.kalman.transitionMatrix = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]], np.float32)
         self.kalman.processNoiseCov = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]],
                                                np.float32) * 0.003
         self.kalman.measurementNoiseCov = np.array([[1, 0], [0, 1]], np.float32) * 0.01

     def predict(self, x, y):
         current_mes = np.array([[np.float32(x)], [np.float32(y)]])
         self.kalman.correct(current_mes)
         current_pre = self.kalman.predict()
         return current_pre

自定义的工具模块utils.py：

 # coding:utf-8
 # 工具模块

 import cv2
 import os
 import re

 # 目录存储模块
 class Path:
     # 存储文件路径
     def __init__(self):
         self.img_path = ""
         self.groundtruth_path = ""
         # 目录
         self.inpics_list = []
         # 绝对路径目录
         self.pics_list = []
         self.sum = 0

     # 初始化文件路径
     def init(self, path):
         # 请选择包含img和groundtruth的总文件夹
         if path != '':
             self.img_path = path + "/img/"
             self.groundtruth_path = path + "/groundtruth.txt"
             self.inpics_list = os.listdir(self.img_path)
             self.inpics_list.sort()
         # 目录统计
         self.sum = len(self.inpics_list)
         # 绝对路径
         self.pics_list = [self.img_path + x for x in self.inpics_list]

 # 坐标储存模块
 class ROI:
     # 存储坐标
     def __init__(self):
         self.x = 0
         self.y = 0
         self.width = 0
         self.height = 0
         self.window = []

     # 单坐标的初始化
     def init(self, x, y, width, height):
         self.x = x
         self.y = y
         self.width = width
         self.height = height
         self.window = (x, y, width, height)

     # 窗口坐标的初始化
     def init_window(self, window):
         self.x = window[0]
         self.y = window[1]
         self.width = window[2]
         self.height = window[3]
         self.window = (window[0], window[1], window[2], window[3])

 # 评价指标模块
 class index:
     def __init__(self, path):
         self.fps = []
         self.ape = []
         self.aor = []
         self.n = []
         # 载入真值
         self.lines = open(path).readlines()

     # 得到真值
     def groundtruth(self, i):
         line = [x for x in self.lines]
         # 切割
         window = [0, 0, 0, 0]
         for n in range(0, 4):
             window[n] = int(re.split("[,\n\t ]", line[i])[n])
         return window

     # 像素误差
     @staticmethod
     def APE(window, bbox):
         x1, y1, w1, h1 = window
         x2, y2, w2, h2 = bbox
         # 跟踪框中心
         center = [int(x1 + 1 / 2 * w1), int(y1 + 1 / 2 * h1)]
         # 真值中心
         truth_center = [int(x2 + 1 / 2 * w2), int(y2 + 1 / 2 * h2)]
         # 计算像素误差
         ape = pow(pow(center[0] - truth_center[0], 2) + pow(center[1] - truth_center[1], 2), .2)
         ape = round(ape, 2)
         return ape

     # 重叠率
     @staticmethod
     def AOR(window, bbox):
         x1, y1, w1, h1 = window
         x2, y2, w2, h2 = bbox
         col = min(x1 + w1, x2 + w2) - max(x1, x2)
         row = min(y1 + h1, y2 + h2) - max(y1, y2)
         intersection = col * row
         area1 = w1 * h1
         area2 = w2 * h2
         coincide = intersection * 1.0 / (area1 + area2 - intersection) * 100
         aor = round(coincide, 2)
         return aor

     # 绘制数据曲线
     def draw(self, fps, ape, aor, number):
         self.fps.append(fps)
         self.ape.append(ape)
         self.aor.append(aor)
         self.n.append(number)

 # 跟踪框显示模块
 def display(seconds, img, window, ape, aor, groundtruth, truth=False):
     window = [int(x) for x in window]
     x, y, w, h = window
     # 跟踪框
     img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
     if truth:
         a, b, c, d = groundtruth
         img = cv2.rectangle(img, (a, b), (a + c, b + d), (0, 255, 0), 2)
     # 中心点
     xc = (x + w / 2)
     yc = (y + h / 2)
     cv2.circle(img, (xc, yc), 3, (255, 0, 0), -1)
     # 坐标
     text = cv2.FONT_HERSHEY_COMPLEX_SMALL
     size = 1
     # text = cv2.FONT_ITALIC
     cv2.putText(img, ('X=' + str(xc)), (10, 20), text, size, (0, 0, 255), 1, cv2.LINE_AA)
     cv2.putText(img, ('Y=' + str(yc)), (10, 50), text, size, (0, 0, 255), 1, cv2.LINE_AA)
     # FPS
     fps = 1 / seconds
     cv2.putText(img, ('FPS = ' + str(int(fps))), (10, 80), text, size, (0, 255, 0), 1, cv2.LINE_AA)
     cv2.putText(img, ('APE = ' + str(ape)) + 'pixels', (10, 110), text, size, (0, 255, 255), 1, cv2.LINE_AA)
     cv2.putText(img, ('AOR = ' + str(aor) + '%'), (10, 140), text, size, (255, 0, 255), 1, cv2.LINE_AA)
     return img

 def dis(window, img):
     window = [int(x) for x in window]
     x, y, w, h = window
     img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
     return img

注：

1.在项目目录下保存一张GUI界面的背景图像background.jpg。

2.在选择样本序列时，格式为：所选定文件夹包含子文件夹img，保存有0001.jpg～...的所有序列，子文件groundtruth.txt真值文件。

3.务必使用低版本（未知原因）的Opencv-contrib，否则不能使用CSRT跟踪器。

TBD.