def __init__(self, bbox):
           # 定义等速模型
           # 内部使用KalmanFilter，7个状态变量和4个观测输入
           self.kf = KalmanFilter(dim_x=7, dim_z=4)
           # F是状态变换模型，为7*7的方阵
           self.kf.F = np.array(
               [[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0],
                [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
           # H是量测矩阵，是4*7的矩阵
           self.kf.H = np.array(
               [[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]])
           # R是测量噪声的协方差，即真实值与测量值差的协方差
           self.kf.R[2:, 2:] *= 10.
           # P是先验估计的协方差
           self.kf.P[4:, 4:] *= 1000.  # give high uncertainty to the unobservable initial velocities
           self.kf.P *= 10.
           # Q是过程激励噪声的协方差
           self.kf.Q[-1, -1] *= 0.01
           self.kf.Q[4:, 4:] *= 0.01
           # 状态估计
           self.kf.x[:4] = convert_bbox_to_z(bbox)
           # 参数的更新
           self.time_since_update = 0
           self.id = KalmanBoxTracker.count
           KalmanBoxTracker.count += 1
           self.history = []
           self.hits = 0
           self.hit_streak = 0
           self.age = 0

 def update(self, bbox):
        # 重置
        self.time_since_update = 0
        # 清空history
        self.history = []
        # hits计数加1
        self.hits += 1
        self.hit_streak += 1
        # 根据观测结果修改内部状态x
        self.kf.update(convert_bbox_to_z(bbox))

    def predict(self):
        # 推进状态变量
        if (self.kf.x[6] + self.kf.x[2]) <= 0:
            self.kf.x[6] *= 0.0
        # 进行预测
        self.kf.predict()
        # 卡尔曼滤波的次数
        self.age += 1
        # 若过程中未更新过，将hit_streak置为0
        if self.time_since_update > 0:
            self.hit_streak = 0
        self.time_since_update += 1
        # 将预测结果追加到history中
        self.history.append(convert_x_to_bbox(self.kf.x))
        return self.history[-1]

class KalmanBoxTracker(object):
    count = 0

    def __init__(self, bbox):
        """
        初始化边界框和跟踪器
        :param bbox:
        """
        # 定义等速模型
        # 内部使用KalmanFilter，7个状态变量和4个观测输入
        self.kf = KalmanFilter(dim_x=7, dim_z=4)
        self.kf.F = np.array(
            [[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0],
             [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
        self.kf.H = np.array(
            [[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]])
        self.kf.R[2:, 2:] *= 10.
        self.kf.P[4:, 4:] *= 1000.  # give high uncertainty to the unobservable initial velocities
        self.kf.P *= 10.
        self.kf.Q[-1, -1] *= 0.01
        self.kf.Q[4:, 4:] *= 0.01
        self.kf.x[:4] = convert_bbox_to_z(bbox)
        self.time_since_update = 0
        self.id = KalmanBoxTracker.count
        KalmanBoxTracker.count += 1
        self.history = []
        self.hits = 0
        self.hit_streak = 0
        self.age = 0

    def update(self, bbox):
        """
        使用观察到的目标框更新状态向量。filterpy.kalman.KalmanFilter.update 会根据观测修改内部状态估计self.kf.x。
        重置self.time_since_update，清空self.history。
        :param bbox:目标框
        :return:
        """
        self.time_since_update = 0
        self.history = []
        self.hits += 1
        self.hit_streak += 1
        self.kf.update(convert_bbox_to_z(bbox))

    def predict(self):
        """
        推进状态向量并返回预测的边界框估计。
        将预测结果追加到self.history。由于 get_state 直接访问 self.kf.x，所以self.history没有用到
        :return:
        """
        if (self.kf.x[6] + self.kf.x[2]) <= 0:
            self.kf.x[6] *= 0.0
        self.kf.predict()
        self.age += 1
        if self.time_since_update > 0:
            self.hit_streak = 0
        self.time_since_update += 1
        self.history.append(convert_x_to_bbox(self.kf.x))
        return self.history[-1]

    def get_state(self):
        """
        返回当前边界框估计值
        :return:
        """
        return convert_x_to_bbox(self.kf.x)

from filterpy.kalman import KalmanFilter
import numpy as np

def convert_bbox_to_z(bbox):
    """
    将[x1,y1,x2,y2]形式的检测框转为滤波器的状态表示形式[x,y,s,r]。
    其中x、y是框的中心坐标点，s 是面积尺度，r 是宽高比w/h
    :param bbox: [x1,y1,x2,y2] 分别是左上角坐标和右下角坐标 即 [左上角的x坐标，左上角的y坐标，右下角的x坐标，右下角的y坐标]
    :return: [ x, y, s, r ] 4行1列，其中x、y是box中心位置的坐标，s是面积，r是纵横比w/h
    """
    w = bbox[2] - bbox[0] #右下角的x坐标 - 左上角的x坐标 = 检测框的宽
    h = bbox[3] - bbox[1] #右下角的y坐标 - 左上角的y坐标 = 检测框的高
    x = bbox[0] + w / 2.  #左上角的x坐标 + 宽/2 = 检测框中心位置的x坐标
    y = bbox[1] + h / 2.  #左上角的y坐标 + 高/2 = 检测框中心位置的y坐标
    s = w * h   #检测框的宽 * 高 = 检测框面积
    r = w / float(h) #检测框的宽w / 高h = 宽高比
    #因为卡尔曼滤波器的输入格式要求为4行1列，因此该[x, y, s, r]的形状要转换为4行1列再输入到卡尔曼滤波器
    return np.array([x, y, s, r]).reshape((4, 1))

"""
将候选框从中心面积的形式[x,y,s,r] 转换为 坐标的形式[x1,y1,x2,y2]
"""
def convert_x_to_bbox(x, score=None):
    """
    将[cx，cy，s，r]的目标框表示转为[x_min，y_min，x_max，y_max]的形式
    :param x:[ x, y, s, r ],其中x,y是box中心位置的坐标，s是面积，r是纵横比w/h
    :param score: 置信度
    :return:[x1,y1,x2,y2],左上角坐标和右下角坐标
    """
    """
    x[2]：s是面积，原公式s的来源为s = w * h，即检测框的宽 * 高 = 检测框面积。
    x[3]：r是纵横比w/h，原公式r的来源为r = w / float(h)，即检测框的宽w / 高h = 宽高比。
    x[2] * x[3]：s*r 即(w * h) * (w / float(h)) = w^2
    sqrt(x[2] * x[3])：sqrt(w^2) = w
    """
    w = np.sqrt(x[2] * x[3]) #sqrt(w^2) = w
    h = x[2] / w #w * h / w = h
    if score is None:
        return np.array([x[0] - w / 2., #检测框中心位置的x坐标 - 宽 / 2 = 左上角的x坐标
                         x[1] - h / 2., #检测框中心位置的y坐标 - 高 / 2 = 左上角的y坐标
                         x[0] + w / 2., #检测框中心位置的x坐标 + 宽 / 2 = 右下角的x坐标
                         x[1] + h / 2.] #检测框中心位置的y坐标 + 高 / 2 = 右下角的y坐标
                        ).reshape((1, 4))
    else:
        return np.array([x[0] - w / 2.,
                         x[1] - h / 2.,
                         x[0] + w / 2.,
                         x[1] + h / 2.,
                         score]).reshape((1, 5))

"""
卡尔曼滤波器进行跟踪的相关内容的实现
    目标估计模型：
        1.根据上一帧的目标框结果来预测当前帧的目标框状态，预测边界框(目标框)的模型定义为一个等速运动/匀速运动模型。
        2.每个目标框都有对应的一个卡尔曼滤波器(KalmanBoxTracker实例对象)，
          KalmanBoxTracker类中的实例属性专门负责记录其对应的一个目标框中各种统计参数，
          并且使用类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象)。  
        3.yoloV3、卡尔曼滤波器预测/更新流程步骤
            1.第一步：
                yoloV3目标检测阶段：
                    --> 1.检测到目标则创建检测目标链/跟踪目标链，反之检测不到目标则重新循环目标检测。
                    --> 2.检测目标链/跟踪目标链不为空则进入卡尔曼滤波器predict预测阶段，反之为空则重新循环目标检测。
            2.第二步：
                卡尔曼滤波器predict预测阶段：
                    连续多次预测而不进行一次更新操作，那么代表了每次预测之后所进行的“预测目标和检测目标之间的”相似度匹配都不成功，
                    所以才会出现连续多次的“预测然后相似度匹配失败的”情况，导致不会进入一次更新阶段。
                    如果一次预测然后相似度匹配成功的话，那么然后就会进入更新阶段。
                   
                    --> 1.目标位置预测
                                1.kf.predict()：目标位置预测
                                2.目标框预测总次数：age+=1。
                                3.if time_since_update > 0:
                                     hit_streak = 0
                                  time_since_update += 1
                                  1.连续预测的次数，每执行predict一次即进行time_since_update+=1。
                                  2.在连续预测(连续执行predict)的过程中，一旦执行update的话，time_since_update就会被重置为0。
                                  3.在连续预测(连续执行predict)的过程中，只要连续预测的次数time_since_update大于0的话，
                                    就会把hit_streak(连续更新的次数)重置为0，表示连续预测的过程中没有出现过一次更新状态更新向量x(状态变量x)的操作，
                                    即连续预测的过程中没有执行过一次update。
                                  4.在连续更新(连续执行update)的过程中，一旦开始连续执行predict两次或以上的情况下，
                                    当连续第一次执行predict时，因为time_since_update仍然为0，并不会把hit_streak重置为0，
                                    然后才会进行time_since_update+=1；
                                    当连续第二次执行predict时，因为time_since_update已经为1，那么便会把hit_streak重置为0，
                                    然后继续进行time_since_update+=1。
                    --> 2.预测的目标和检测的目标之间的相似度匹配成功则进入update更新阶段，反之匹配失败则删除跟踪目标。
            3.第三步：
                卡尔曼滤波器update更新阶段：
                    如果一次预测然后“预测目标和检测目标之间的”相似度匹配成功的话，那么然后就会进入更新阶段。
                    kf.update([x,y,s,r])：使用的是通过yoloV3得到的“并且和预测框相匹配的”检测框来更新预测框。
                   
                    --> 1.目标位置信息更新到检测目标链/跟踪目标链
                                1.目标框更新总次数：hits+=1。
                                2.history = []
                                  time_since_update = 0
                                  hit_streak += 1
                                    1.history列表用于在预测阶段保存单个目标框连续预测的多个结果，一旦执行update就会清空history列表。
                                    2.连续更新的次数，每执行update一次即进行hit_streak+=1。
                                    3.在连续预测(连续执行predict)的过程中，一旦执行update的话，time_since_update就会被重置为0。
                                    4.在连续预测(连续执行predict)的过程中，只要连续预测的次数time_since_update大于0的话，
                                      就会把hit_streak(连续更新的次数)重置为0，表示连续预测的过程中没有出现过一次更新状态更新向量x(状态变量x)的操作，
                                      即连续预测的过程中没有执行过一次update。
                                    5.在连续更新(连续执行update)的过程中，一旦开始连续执行predict两次或以上的情况下，
                                      当连续第一次执行predict时，因为time_since_update仍然为0，并不会把hit_streak重置为0，
                                      然后才会进行time_since_update+=1；
                                      当连续第二次执行predict时，因为time_since_update已经为1，那么便会把hit_streak重置为0，
                                      然后继续进行time_since_update+=1。
                    --> 2.目标位置修正。
                                1.kf.update([x,y,s,r])：
                                        使用观测到的目标框bbox更新状态变量x(状态更新向量x)。
                                        使用的是通过yoloV3得到的“并且和预测框相匹配的”检测框来更新卡尔曼滤波器得到的预测框。
 
    1.初始化、预测、更新
        1.__init__(bbox)：
            初始化卡尔曼滤波器的状态更新向量x(状态变量x)、观测输入[x,y,s,r](通过[x1,y1,x2,y2]转化而来)、状态转移矩阵F、
            量测矩阵H(观测矩阵H)、测量噪声的协方差矩阵R、先验估计的协方差矩阵P、过程激励噪声的协方差矩阵Q。
        2.update(bbox)：根据观测输入来对状态更新向量x(状态变量x)进行更新
        3.predict()：根据状态更新向量x(状态变量x)更新的结果来预测目标的边界框

    2.状态变量、状态转移矩阵F、量测矩阵H(观测矩阵H)、测量噪声的协方差矩阵R、先验估计的协方差矩阵P、过程激励噪声的协方差矩阵Q
        1.状态更新向量x(状态变量x)
            状态更新向量x(状态变量x)的设定是一个7维向量：x=[u,v,s,r,u^,v^,s^]T。
            u、v分别表示目标框的中心点位置的x、y坐标，s表示目标框的面积，r表示目标框的纵横比/宽高比。
            u^、v^、s^分别表示横向u(x方向)、纵向v(y方向)、面积s的运动变化速率。
            u、v、s、r初始化：根据第一帧的观测结果进行初始化。
            u^、v^、s^初始化：当第一帧开始的时候初始化为0，到后面帧时会根据预测的结果来进行变化。
        2.状态转移矩阵F
            定义的是一个7*7的方阵(其对角线上的值都是1)。。
            运动形式和转换矩阵的确定都是基于匀速运动模型，状态转移矩阵F根据运动学公式确定，跟踪的目标假设为一个匀速运动的目标。
            通过7*7的状态转移矩阵F 乘以 7*1的状态更新向量x(状态变量x)即可得到一个更新后的7*1的状态更新向量x，
            其中更新后的u、v、s即为当前帧结果。
        3.量测矩阵H(观测矩阵H)
            量测矩阵H(观测矩阵H)，定义的是一个4*7的矩阵。
            通过4*7的量测矩阵H(观测矩阵H) 乘以 7*1的状态更新向量x(状态变量x) 即可得到一个 4*1的[u,v,s,r]的估计值。
        4.测量噪声的协方差矩阵R、先验估计的协方差矩阵P、过程激励噪声的协方差矩阵Q
            1.测量噪声的协方差矩阵R：diag([1,1,10,10]T)
            2.先验估计的协方差矩阵P：diag([10,10,10,10,1e4,1e4,1e4]T)。1e4：1x10的4次方。
            3.过程激励噪声的协方差矩阵Q：diag([1,1,1,1,0.01,0.01,1e-4]T)。1e-4：1x10的-4次方。
            4.1e数字的含义
                1e4：1x10的4次方
                1e-4：1x10的-4次方
            5.diag表示对角矩阵，写作为diag(a1，a2,...,an)的对角矩阵实际表示为主对角线上的值依次为a1，a2,...,an，
              而主对角线之外的元素皆为0的矩阵。
              对角矩阵(diagonal matrix)是一个主对角线之外的元素皆为0的矩阵，常写为diag（a1，a2,...,an) 。
              对角矩阵可以认为是矩阵中最简单的一种，值得一提的是：对角线上的元素可以为 0 或其他值，对角线上元素相等的对角矩阵称为数量矩阵；
              对角线上元素全为1的对角矩阵称为单位矩阵。对角矩阵的运算包括和、差运算、数乘运算、同阶对角阵的乘积运算，且结果仍为对角阵。
"""
#目标估计模型-卡尔曼滤波
class KalmanBoxTracker(object):
    """
    每个目标框都有对应的一个卡尔曼滤波器(KalmanBoxTracker实例对象)，
    KalmanBoxTracker类中的实例属性专门负责记录其对应的一个目标框中各种统计参数，
    并且使用类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象)。
    """
    count = 0 #类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象

    """
    __init__(bbox)
        使用目标框bbox为卡尔曼滤波的状态进行初始化。初始化时传入bbox，即根据观测到的检测框的结果来进行初始化。
        每个目标框都有对应的一个卡尔曼滤波器(KalmanBoxTracker实例对象)，
        KalmanBoxTracker类中的实例属性专门负责记录其对应的一个目标框中各种统计参数，
        并且使用类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象)。
       
        1.kf = KalmanFilter(dim_x=7, dim_z=4)
                定义一个卡尔曼滤波器，利用这个卡尔曼滤波器对目标的状态进行估计。
                dim_x=7定义是一个7维的状态更新向量x(状态变量x)：x=[u,v,s,r,u^,v^,s^]T。
                dim_z=4定义是一个4维的观测输入，即中心面积的形式[x,y,s,r]，即[检测框中心位置的x坐标,y坐标,面积,宽高比]。
        2.kf.F = np.array(7*7的方阵)
                状态转移矩阵F，定义的是一个7*7的方阵其(对角线上的值都是1)。
                通过7*7的状态转移矩阵F 乘以 7*1的状态更新向量x(状态变量x)即可得到一个更新后的7*1的状态更新向量x，
                其中更新后的u、v、s即为当前帧结果。
                通过状态转移矩阵对当前的观测结果进行估计获得预测的结果，然后用当前的预测的结果来作为下一次估计预测的基础。
        3.kf.H = np.array(4*7的矩阵)
                量测矩阵H(观测矩阵H)，定义的是一个4*7的矩阵。
                通过4*7的量测矩阵H(观测矩阵H) 乘以 7*1的状态更新向量x(状态变量x) 即可得到一个 4*1的[u,v,s,r]的估计值。
        4.相应的协方差参数的设定，根据经验值进行设定。
                1.R是测量噪声的协方差矩阵，即真实值与测量值差的协方差。
                  R=diag([1,1,10,10]T)
                        kf.R[2:, 2:] *= 10.
                2.P是先验估计的协方差矩阵
                  diag([10,10,10,10,1e4,1e4,1e4]T)。1e4：1x10的4次方。
                        kf.P[4:, 4:] *= 1000.  # 设置了一个较大的值，给无法观测的初始速度带来很大的不确定性
                        kf.P *= 10.
                3.Q是过程激励噪声的协方差矩阵
                  diag([1,1,1,1,0.01,0.01,1e-4]T)。1e-4：1x10的-4次方。
                        kf.Q[-1, -1] *= 0.01
                        kf.Q[4:, 4:] *= 0.01
        5.kf.x[:4] = convert_bbox_to_z(bbox)
                convert_bbox_to_z负责将[x1,y1,x2,y2]形式的检测框bbox转为中心面积的形式[x,y,s,r]。
                状态更新向量x(状态变量x)设定是一个七维向量：x=[u,v,s,r,u^,v^,s^]T。
                x[:4]即表示 u、v、s、r初始化为第一帧bbox观测到的结果[x,y,s,r]。
        6.单个目标框对应的单个卡尔曼滤波器中的统计参数的更新
            每个目标框都有对应的一个卡尔曼滤波器(KalmanBoxTracker实例对象)，
            KalmanBoxTracker类中的实例属性专门负责记录其对应的一个目标框中各种统计参数，
            并且使用类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象)。
            1.卡尔曼滤波器的个数
                有多少个目标框就有多少个卡尔曼滤波器，每个目标框都会有一个卡尔曼滤波器，即每个目标框都会有一个KalmanBoxTracker实例对象。
                count = 0：类属性负责记录卡尔曼滤波器的创建个数，增加一个目标框就增加一个卡尔曼滤波器(KalmanBoxTracker实例对象。
                id = KalmanBoxTracker.count：卡尔曼滤波器的个数，即目标框的个数。
                KalmanBoxTracker.count += 1：每增加一个目标框，即增加一个KalmanBoxTracker实例对象(卡尔曼滤波器)，那么类属性count+=1。
               
            2.统计一个目标框对应的卡尔曼滤波器中各参数统计的次数
                1.age = 0：
                    该目标框进行预测的总次数。每执行predict一次，便age+=1。
                2.hits = 0：
                    该目标框进行更新的总次数。每执行update一次，便hits+=1。
                3.time_since_update = 0
                    1.连续预测的次数，每执行predict一次即进行time_since_update+=1。
                    2.在连续预测(连续执行predict)的过程中，一旦执行update的话，time_since_update就会被重置为0。
                    3.在连续预测(连续执行predict)的过程中，只要连续预测的次数time_since_update大于0的话，
                      就会把hit_streak(连续更新的次数)重置为0，表示连续预测的过程中没有出现过一次更新状态更新向量x(状态变量x)的操作，
                      即连续预测的过程中没有执行过一次update。
                4.hit_streak = 0
                    1.连续更新的次数，每执行update一次即进行hit_streak+=1。
                    2.在连续更新(连续执行update)的过程中，一旦开始连续执行predict两次或以上的情况下，
                      当连续第一次执行predict时，因为time_since_update仍然为0，并不会把hit_streak重置为0，
                      然后才会进行time_since_update+=1；
                      当连续第二次执行predict时，因为time_since_update已经为1，那么便会把hit_streak重置为0，
                      然后继续进行time_since_update+=1。
        7.history = []：
                保存单个目标框连续预测的多个结果到history列表中，一旦执行update就会清空history列表。
                将预测的候选框从中心面积的形式[x,y,s,r]转换为坐标的形式[x1,y1,x2,y2] 的bbox 再保存到 history列表中。
    """
    def __init__(self, bbox):
        # 定义等速模型
        # 内部使用KalmanFilter，7个状态变量和4个观测输入
        self.kf = KalmanFilter(dim_x=7, dim_z=4)
        # F是状态变换模型，为7*7的方阵
        self.kf.F = np.array([[1, 0, 0, 0, 1, 0, 0],
                              [0, 1, 0, 0, 0, 1, 0],
                              [0, 0, 1, 0, 0, 0, 1],
                              [0, 0, 0, 1, 0, 0, 0],
                              [0, 0, 0, 0, 1, 0, 0],
                              [0, 0, 0, 0, 0, 1, 0],
                              [0, 0, 0, 0, 0, 0, 1]])
        # H是量测矩阵，是4*7的矩阵
        self.kf.H = np.array([[1, 0, 0, 0, 0, 0, 0],
                              [0, 1, 0, 0, 0, 0, 0],
                              [0, 0, 1, 0, 0, 0, 0],
                              [0, 0, 0, 1, 0, 0, 0]])
        # R是测量噪声的协方差，即真实值与测量值差的协方差
        self.kf.R[2:, 2:] *= 10.
        # P是先验估计的协方差
        self.kf.P[4:, 4:] *= 1000.  # 给无法观测的初始速度带来很大的不确定性
        self.kf.P *= 10.
        # Q是过程激励噪声的协方差
        self.kf.Q[-1, -1] *= 0.01
        self.kf.Q[4:, 4:] *= 0.01
        # 状态估计
        self.kf.x[:4] = convert_bbox_to_z(bbox)
        # 参数的更新
        self.time_since_update = 0
        self.id = KalmanBoxTracker.count
        KalmanBoxTracker.count += 1
        self.history = []
        self.hits = 0
        self.hit_streak = 0
        self.age = 0

    """
    update(bbox)：使用观测到的目标框bbox更新状态更新向量x(状态变量x)
 
    1.time_since_update = 0
            1.连续预测的次数，每执行predict一次即进行time_since_update+=1。
            2.在连续预测(连续执行predict)的过程中，一旦执行update的话，time_since_update就会被重置为0。
            2.在连续预测(连续执行predict)的过程中，只要连续预测的次数time_since_update大于0的话，
              就会把hit_streak(连续更新的次数)重置为0，表示连续预测的过程中没有出现过一次更新状态更新向量x(状态变量x)的操作，
              即连续预测的过程中没有执行过一次update。
    2.history = []      
           清空history列表。
           history列表保存的是单个目标框连续预测的多个结果([x,y,s,r]转换后的[x1,y1,x2,y2])，一旦执行update就会清空history列表。
    3.hits += 1：
            该目标框进行更新的总次数。每执行update一次，便hits+=1。
    4.hit_streak += 1
            1.连续更新的次数，每执行update一次即进行hit_streak+=1。
            2.在连续更新(连续执行update)的过程中，一旦开始连续执行predict两次或以上的情况下，
              当连续第一次执行predict时，因为time_since_update仍然为0，并不会把hit_streak重置为0，
              然后才会进行time_since_update+=1；
              当连续第二次执行predict时，因为time_since_update已经为1，那么便会把hit_streak重置为0，
              然后继续进行time_since_update+=1。
    5.kf.update(convert_bbox_to_z(bbox))
            convert_bbox_to_z负责将[x1,y1,x2,y2]形式的检测框转为滤波器的状态表示形式[x,y,s,r]，那么传入的为kf.update([x,y,s,r])。
            然后根据观测结果修改内部状态x(状态更新向量x)。
            使用的是通过yoloV3得到的“并且和预测框相匹配的”检测框来更新卡尔曼滤波器得到的预测框。
    """
    #更新状态变量，使用观测到的目标框bbox更新状态变量
    def update(self, bbox):
        """
        使用观察到的目标框更新状态向量。filterpy.kalman.KalmanFilter.update 会根据观测修改内部状态估计self.kf.x。
        重置self.time_since_update，清空self.history。
        :param bbox:目标框
        :return:
        """
        # 重置
        self.time_since_update = 0
        # 清空history
        self.history = []
        # hits计数加1
        self.hits += 1
        self.hit_streak += 1
        # 根据观测结果修改内部状态x。
        #convert_bbox_to_z负责将[x1,y1,x2,y2]形式的检测框转为滤波器的状态表示形式[x,y,s,r]，那么update传入的为(x,y,s,r)
        self.kf.update(convert_bbox_to_z(bbox))

    """
    predict：进行目标框的预测并返回预测的边界框结果
   
    1.if(kf.x[6] + kf.x[2]) <= 0:
            self.kf.x[6] *= 0.0
            状态更新向量x(状态变量x)为[u,v,s,r,u^,v^,s^]T，那么x[6]为s^，x[2]为s。
            如果x[6]+x[2]<= 0，那么x[6] *= 0.0，即把s^置为0.0。
    2.kf.predict()
            进行目标框的预测。
    3.age += 1
            该目标框进行预测的总次数。每执行predict一次，便age+=1。
    4.if time_since_update > 0:
        hit_streak = 0
      time_since_update += 1
            1.连续预测的次数，每执行predict一次即进行time_since_update+=1。
            2.在连续预测(连续执行predict)的过程中，一旦执行update的话，time_since_update就会被重置为0。
            3.在连续预测(连续执行predict)的过程中，只要连续预测的次数time_since_update大于0的话，
              就会把hit_streak(连续更新的次数)重置为0，表示连续预测的过程中没有出现过一次更新状态更新向量x(状态变量x)的操作，
              即连续预测的过程中没有执行过一次update。
            4.在连续更新(连续执行update)的过程中，一旦开始连续执行predict两次或以上的情况下，
              当连续第一次执行predict时，因为time_since_update仍然为0，并不会把hit_streak重置为0，
              然后才会进行time_since_update+=1；
              当连续第二次执行predict时，因为time_since_update已经为1，那么便会把hit_streak重置为0，
              然后继续进行time_since_update+=1。
    5.history.append(convert_x_to_bbox(kf.x))
            convert_x_to_bbox(kf.x)：将目标框所预测的结果从中心面积的形式[x,y,s,r] 转换为 坐标的形式[x1,y1,x2,y2] 的bbox。
            history列表保存的是单个目标框连续预测的多个结果([x,y,s,r]转换后的[x1,y1,x2,y2])，一旦执行update就会清空history列表。
    6.predict 返回值：history[-1]
            把目标框当前该次的预测的结果([x,y,s,r]转换后的[x1,y1,x2,y2])进行返回输出。
    """
    #进行目标框的预测，推进状态变量并返回预测的边界框结果
    def predict(self):
        """
        推进状态向量并返回预测的边界框估计。
        将预测结果追加到self.history。由于 get_state 直接访问 self.kf.x，所以self.history没有用到
        :return:
        """
        # 推进状态变量
        if (self.kf.x[6] + self.kf.x[2]) <= 0:
            self.kf.x[6] *= 0.0
        # 进行预测
        self.kf.predict()
        # 卡尔曼滤波的次数
        self.age += 1
        # 若过程中未更新过，将hit_streak置为0
        if self.time_since_update > 0:
            self.hit_streak = 0
        self.time_since_update += 1
        # 将预测结果追加到history中
        self.history.append(convert_x_to_bbox(self.kf.x))
        return self.history[-1]

    """
    get_state()：
        获取当前目标框预测的结果([x,y,s,r]转换后的[x1,y1,x2,y2])。
        return convert_x_to_bbox(kf.x)：将候选框从中心面积的形式[x,y,s,r] 转换为 坐标的形式[x1,y1,x2,y2] 的bbox并进行返回输出。
        直接访问 kf.x并进行返回，所以history没有用到。
    """
    def get_state(self):
        """
        返回当前边界框估计值。
        由于 get_state 直接访问 self.kf.x，所以self.history没有用到。
        :return:
        """
        #将候选框从中心面积的形式[x,y,s,r] 转换为 坐标的形式[x1,y1,x2,y2] 的bbox
        return convert_x_to_bbox(self.kf.x)