目标追踪 ByteTrack 算法详细流程分析
原理介绍
ByteTrack是字节跳动与2021年10月份公开的一个全新的多目标跟踪算法，原论文是《ByteTrack: Multi-Object Tracking by Associating Every Detection Box》。
ByteTrak的MOTA和FPS等指标上都实现了较好的性能，要优于现有的大多数MOT（多目标追踪）算法。
github地址：https://github.com/ifzhang/ByteTrack
演示：
ByteTrack介绍
先前的多目标追踪算法一般在完成当前帧的目标检测后只会保留置信度比较大的检测框用于进行目标跟踪，比如图中置信度为0.9和0.8的目标框。
而在ByteTrack中，作者保留了所有的检测框并且通过阈值将它们分成了高置信度检测框和低置信度检测框。ByteTrack 可以有效解决一些遮挡，且能够保持较低的 ID Switch。因为目标会因为被遮挡检测置信度有所降低，当重新出现时，置信度会有所升高。算法特点在于：
- 当目标逐渐被遮挡时，跟踪目标与低置信度检测目标匹配。
- 当目标遮挡逐渐重现时，跟踪目标与高置信度检测目标匹配。
算法基本原理
ByteTrack 并不是连接所有检测框形成一个追踪轨迹，而是通过预测和验证的方法来确定追踪轨迹。对于每一个轨迹使用卡尔曼滤波来预测轨迹下一个位置（预测框），然后计算检测框和预测框的IOU，最后通过匈牙利算法匹配IOU，返回匹配成功和失败的轨迹。
追踪算法的详细步骤：
- 在开始追踪之前给每一目标创建追踪轨迹
- 通过卡尔曼滤波预测每一个追踪轨迹的下一帧边界框
- 通过检测器获得目标的检测框，根据置信度将检测框分为高分框和低分框
- 首先针对高分框，计算高分框和预测框的IOU ，使用匈牙利算法匹配IOU，获得3个结果：已匹配的轨迹与高分框，未成功匹配的轨迹，未成功匹配的高分框。匹配成功后将追踪轨迹中的框更新为高分检测框
- 然后针对低分框，计算低分框和上一步未匹配上的预测框的IOU，使用匈牙利算法匹配IOU，获得3个结果：已匹配的轨迹与低分框，未成功匹配的轨迹，未成功匹配的低分框。匹配成功后将追踪轨迹中的框更新为检测框
- 最后针对未匹配上的高分检测框，将其和状态未激活的轨迹匹配，获得3个结果：匹配、未匹配轨迹、未匹配检测框。对于匹配更新状态，对于未匹配轨迹标记为删除，对于未匹配检测框，置信度大于高阈值+0.1新建一个跟踪轨迹，小于则丢弃。
代码实现
在介绍代码之前首先要了解基础概念。ByteTrack 主要由两个类组成，一个是轨迹管理类STrack，一个轨迹匹配逻辑处理类BYTETracker。
- STrack：轨迹的创建，更新，删除
- BYTETracker：匹配流程处理，置信度高低划分、轨迹匹配等
STrack
Strack 是轨迹的类，每一个实例都是一个轨迹。Strack拥有核心方法包括：
- multi_predict 卡尔曼滤波预测
- activate 轨迹创建
- re_activate 轨迹重新激活
- update 轨迹更新
# 这个类是用来存放轨迹的，每个轨迹都有一些自己的属性，例如id、边界框、预测框、状态等等
class STrack(BaseTrack):
# 单例模式
shared_kalman = KalmanFilter()
def __init__(self, tlwh, score):
self._tlwh = np.asarray(tlwh, dtype=np.float)
self.kalman_filter = None
# 保存卡尔曼滤波对这个轨迹的平均值和协方差
self.mean, self.covariance = None, None
# 是否是激活状态
self.is_activated = False
# 轨迹分数
self.score = score
# 轨迹追踪的帧数，每次追踪成功都会+1
self.tracklet_len = 0
def predict(self):
mean_state = self.mean.copy()
if self.state != TrackState.Tracked:
mean_state[7] = 0
self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
@staticmethod
def multi_predict(stracks):
if len(stracks) > 0:
multi_mean = np.asarray([st.mean.copy() for st in stracks])
multi_covariance = np.asarray([st.covariance for st in stracks])
for i, st in enumerate(stracks):
if st.state != TrackState.Tracked:
multi_mean[i][7] = 0
multi_mean, multi_covariance = STrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
stracks[i].mean = mean
stracks[i].covariance = cov
def activate(self, kalman_filter, frame_id):
"""Start a new tracklet"""
self.kalman_filter = kalman_filter
self.track_id = self.next_id()
self.mean, self.covariance = self.kalman_filter.initiate(self.tlwh_to_xyah(self._tlwh))
self.tracklet_len = 0
self.state = TrackState.Tracked
if frame_id == 1:
self.is_activated = True
# self.is_activated = True
self.frame_id = frame_id
self.start_frame = frame_id
def re_activate(self, new_track, frame_id, new_id=False):
self.mean, self.covariance = self.kalman_filter.update(
self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh)
)
self.tracklet_len = 0
self.state = TrackState.Tracked
self.is_activated = True
self.frame_id = frame_id
if new_id:
self.track_id = self.next_id()
self.score = new_track.score
def update(self, new_track, frame_id):
"""
Update a matched track
:type new_track: STrack
:type frame_id: int
:type update_feature: bool
:return:
"""
self.frame_id = frame_id
self.tracklet_len += 1
new_tlwh = new_track.tlwh
self.mean, self.covariance = self.kalman_filter.update(
self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh))
self.state = TrackState.Tracked
self.is_activated = True
self.score = new_track.score
@property
# @jit(nopython=True)
def tlwh(self):
"""Get current position in bounding box format `(top left x, top left y,
width, height)`.
"""
if self.mean is None:
return self._tlwh.copy()
ret = self.mean[:4].copy()
ret[2] *= ret[3]
ret[:2] -= ret[2:] / 2
return ret
@property
# @jit(nopython=True)
def tlbr(self):
"""Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
`(top left, bottom right)`.
"""
ret = self.tlwh.copy()
ret[2:] += ret[:2]
return ret
@staticmethod
# @jit(nopython=True)
def tlwh_to_xyah(tlwh):
"""Convert bounding box to format `(center x, center y, aspect ratio,
height)`, where the aspect ratio is `width / height`.
"""
ret = np.asarray(tlwh).copy()
ret[:2] += ret[2:] / 2
ret[2] /= ret[3]
return ret
def to_xyah(self):
return self.tlwh_to_xyah(self.tlwh)
@staticmethod
# @jit(nopython=True)
def tlbr_to_tlwh(tlbr):
ret = np.asarray(tlbr).copy()
ret[2:] -= ret[:2]
return ret
@staticmethod
# @jit(nopython=True)
def tlwh_to_tlbr(tlwh):
ret = np.asarray(tlwh).copy()
ret[2:] += ret[:2]
return ret
def __repr__(self):
return 'OT_{}_({}-{})'.format(self.track_id, self.start_frame, self.end_frame)
BYTETracker
BYTETracker 是轨迹创建、更新、删除等流程类。拥有一个主要的方法，那就是update。通过预测框和已存在轨迹的运算不断更新轨迹路线。代码实现的流程图如下：
下面分析代码实现流程
初始化参数，包括需要保存的追踪轨迹、丢失轨迹、删除轨迹、高低分阈值等。追踪的工作原理是对每一帧进行判断处理，同时也需要对连续帧判断，所以这里定义的就是全局保存的轨迹。
class BYTETracker(object):
def __init__(self, args, frame_rate=30):
# 已追踪的轨迹
self.tracked_stracks = [] # type: list[STrack]
# 丢失的轨迹
self.lost_stracks = [] # type: list[STrack]
# 删除的轨迹
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.args = args
#self.det_thresh = args.track_thresh
# 区分高低分检测框的阈值
self.det_thresh = args.track_thresh + 0.1
# 最大丢失时间
self.buffer_size = int(frame_rate / 30.0 * args.track_buffer)
self.max_time_lost = self.buffer_size
# 卡尔曼滤波器
self.kalman_filter = KalmanFilter()
定义每一帧流程处理之后的结果，包括追踪到的轨迹、重新追踪到的轨迹、丢失的轨迹等
def update(self, output_results):
self.frame_id += 1
# 以下列表是本轮匹配中临时结果存放的列表
# 保存当前帧标记为追踪到轨迹
activated_starcks = []
# 保存当前帧标记为追踪到之前丢失的轨迹
refind_stracks = []
# 保存当前帧标记为丢失的目标轨迹
lost_stracks = []
# 保存当前帧标记为丢失的轨迹
removed_stracks = []
筛选出高分框和低分框
# 高分框
remain_inds = scores > self.args.track_thresh
# 低分框0.1-阈值之间
inds_low = scores > 0.1
inds_high = scores < self.args.track_thresh
# 筛选分数处于0.1<分数<阈值
inds_second = np.logical_and(inds_low, inds_high)
dets_second = bboxes[inds_second]
scores_second = scores[inds_second]
# 筛选分数超过阈值
dets = bboxes[remain_inds]
scores_keep = scores[remain_inds]
筛选出正常追踪轨迹和第一次追踪轨迹
# 处于追踪阶段但是未激活的，也就是只追上了一帧的目标。也就是第一次追踪的轨迹
unconfirmed = []
tracked_stracks = [] # type: list[STrack]
for track in self.tracked_stracks:
if not track.is_activated:
unconfirmed.append(track)
else:
tracked_stracks.append(track)
高分匹配，并根据三种匹配结果分别做不同的处理
"""------------第一次匹配，高分检测框匹配-----------"""
# 将追踪状态为激活和标记为丢失的轨迹合并得到track_pool
strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
# 将strack_pool送入muti_predict进行预测（卡尔曼滤波）
STrack.multi_predict(strack_pool)
# 计算strack_pool中轨迹的预测框和detections检测框的iou_distance(代价矩阵)
dists = matching.iou_distance(strack_pool, detections)
if not self.args.mot20:
dists = matching.fuse_score(dists, detections)
# 用匹配阈值match_thresh=0.8过滤较小的iou，利用匈牙利算法进行匹配，得到匹配成功的轨迹, 未匹配成功的轨迹, 未匹配成功的检测框
matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.args.match_thresh)
# 遍历matches，轨迹之前状态为Tracked，调用update方法，并加入到activated_stracks。
# 轨迹之前的状态不是Tracked的，调用re_activate，并加入refind_stracks
# matches = [itracked, idet] itracked是轨迹的索引，idet是当前检测框的索引，意思是第几个轨迹匹配第几个目标框
for itracked, idet in matches:
track = strack_pool[itracked]
det = detections[idet]
if track.state == TrackState.Tracked:
# 更新轨迹预测框为当前检测框
track.update(detections[idet], self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
# refind_stracks是重新追踪到的轨迹
refind_stracks.append(track)
低分匹配，并做不同的处理。
"""-------------第二次匹配：低分检测框匹配-----------------"""
if len(dets_second) > 0:
detections_second = [STrack(STrack.tlbr_to_tlwh(tlbr), s) for
(tlbr, s) in zip(dets_second, scores_second)]
else:
detections_second = []
# 找出第一次匹配后没匹配到的轨迹
r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
# 第一次未匹配的轨迹和低置信度检测框的匹配
dists = matching.iou_distance(r_tracked_stracks, detections_second)
# 用匹配阈值match_thresh = 0.5 过滤较小的iou，利用匈牙利算法进行匹配，得到matches, u_track, u_detection
matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
# 遍历matches，轨迹之前状态为Tracked，调用update方法，并加入到activated_stracks。
# 轨迹之前的状态不是Tracked的，调用re_activate，并加入refind_stracks
for itracked, idet in matches:
track = r_tracked_stracks[itracked]
det = detections_second[idet]
if track.state == TrackState.Tracked:
track.update(det, self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
refind_stracks.append(track)
# 遍历u_track（第二次匹配也没匹配到的轨迹），将state不是Lost的轨迹，调用mark_losk方法，并加入lost_stracks，等待下一帧匹配（本流程开始时会合并追踪状态轨迹和丢失状态轨迹）。
# 一个轨迹既没有被高分检测框匹配，也没有被低分检测框匹配，那么就会被当作丢失轨迹
for it in u_track:
track = r_tracked_stracks[it]
if not track.state == TrackState.Lost:
track.mark_lost()
# lost_stracks：上一帧还在持续追踪但是这一帧两次匹配不到的轨迹
lost_stracks.append(track)
第三次匹配，将未匹配的高分框和第一次追踪的轨迹匹配。
"""----------第三次匹配，处理之前没有匹配上的高分检测框-------------"""
# 没有匹配上的高分检测框
detections = [detections[i] for i in u_detection]
# unconfirmed是第一次出现的目标，生成了轨迹但是不是激活状态。计算第一次出现的目标和没有匹配上的高分检测框的iou_distance
dists = matching.iou_distance(unconfirmed, detections)
if not self.args.mot20:
dists = matching.fuse_score(dists, detections)
# 用阈值match_thresh=0.8过滤较小的iou，利用匈牙利算法进行匹配，得到matches, u_track, u_detection
matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.8)
# 遍历匹配的轨迹，更新状态为激活，并将轨迹保存到当前活跃轨迹中
for itracked, idet in matches:
unconfirmed[itracked].update(detections[idet], self.frame_id)
activated_starcks.append(unconfirmed[itracked])
# 遍历未匹配轨迹，调用mark_removd方法，并加入removed_stracks
for it in u_unconfirmed:
# 中途出现一次的轨迹和当前目标框匹配失败，删除该轨迹，认为是检测器误判
track = unconfirmed[it]
track.mark_removed()
removed_stracks.append(track)
最后将未匹配上的高分检测框再次判断，符合条件就设置成新轨迹
# 遍历未匹配上的高分检测框，对于score大于self.det_thresh，调用activate方法，并加入activated_stracks
for inew in u_detection:
track = detections[inew]
if track.score < self.det_thresh:
continue
# 新建轨迹并调用activate。新建轨迹的激活状态：如果视频开始第一帧就新建轨迹那么激活状态为True，剩下帧新建轨迹激活状态都是False
track.activate(self.kalman_filter, self.frame_id)
#把新的轨迹加入到当前活跃轨迹中
activated_starcks.append(track)
最后就是将每一帧匹配的结果更新到全局结果中，然后进行一轮匹配。
小结
可以匹配的流程图上看出来，ByteTrack 不仅对高分框感兴趣，而且对低分框有关注。将低分框当作疑似遮挡的目标，将高分框当作匹配的轨迹或者新轨迹，这样有效追踪遮挡的物体，提高追踪的准确性。
完整代码：
class BYTETracker(object):
def __init__(self, args, frame_rate=30):
# 已追踪的轨迹
self.tracked_stracks = [] # type: list[STrack]
# 丢失的轨迹
self.lost_stracks = [] # type: list[STrack]
# 删除的轨迹
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.args = args
#self.det_thresh = args.track_thresh
# 区分高低分检测框的阈值
self.det_thresh = args.track_thresh + 0.1
# 最大丢失时间
self.buffer_size = int(frame_rate / 30.0 * args.track_buffer)
self.max_time_lost = self.buffer_size
# 卡尔曼滤波器
self.kalman_filter = KalmanFilter()
def update(self, output_results):
self.frame_id += 1
# 以下列表是本轮匹配中临时结果存放的列表
# 保存当前帧标记为追踪到轨迹
activated_starcks = []
# 保存当前帧标记为追踪到之前丢失的轨迹
refind_stracks = []
# 保存当前帧标记为丢失的目标轨迹
lost_stracks = []
# 保存当前帧标记为丢失的轨迹
removed_stracks = []
# 第一步：将objects转换为x1，y1，x2，y2，score的格式，并构建strack
if output_results.shape[1] == 5:
scores = output_results[:, 4]
bboxes = output_results[:, :4]
else:
output_results = output_results.cpu().numpy()
scores = output_results[:, 4] * output_results[:, 5]
bboxes = output_results[:, :4] # x1y1x2y2
# 根据传入的阈值将检测框分为高分框和低分框
# 高分框
remain_inds = scores > self.args.track_thresh
# 低分框0.1-阈值之间
inds_low = scores > 0.1
inds_high = scores < self.args.track_thresh
# 筛选分数处于0.1<分数<阈值
inds_second = np.logical_and(inds_low, inds_high)
dets_second = bboxes[inds_second]
scores_second = scores[inds_second]
# 筛选分数超过阈值
dets = bboxes[remain_inds]
scores_keep = scores[remain_inds]
# 初始化追踪轨迹
if len(dets) > 0:
'''Detections'''
detections = [STrack(STrack.tlbr_to_tlwh(tlbr), s) for (tlbr, s) in zip(dets, scores_keep)]
else:
detections = []
''' Add newly detected tracklets to tracked_stracks'''
# 遍历保存state为Tracked的数组self.tracked_stracks，每一个元素代表一个轨迹，每个轨迹的state为Tracked，但是有激活状态的区分
# is_activated: 追踪状态为激活的轨迹，也就是至少追上了两帧以上的轨迹
# 处于追踪阶段但是未激活的，也就是只追上了一帧的目标。也就是第一次追踪的轨迹
unconfirmed = []
tracked_stracks = [] # type: list[STrack]
for track in self.tracked_stracks:
if not track.is_activated:
unconfirmed.append(track)
else:
tracked_stracks.append(track)
"""------------第一次匹配，高分检测框匹配-----------"""
# 将追踪状态为激活和标记为丢失的轨迹合并得到track_pool
strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
# 将strack_pool送入muti_predict进行预测（卡尔曼滤波）
STrack.multi_predict(strack_pool)
# 计算strack_pool中轨迹的预测框和detections检测框的iou_distance(代价矩阵)
dists = matching.iou_distance(strack_pool, detections)
if not self.args.mot20:
dists = matching.fuse_score(dists, detections)
# 用匹配阈值match_thresh=0.8过滤较小的iou，利用匈牙利算法进行匹配，得到匹配成功的轨迹, 未匹配成功的轨迹, 未匹配成功的检测框
matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.args.match_thresh)
# 遍历matches，轨迹之前状态为Tracked，调用update方法，并加入到activated_stracks。
# 轨迹之前的状态不是Tracked的，调用re_activate，并加入refind_stracks
# matches = [itracked, idet] itracked是轨迹的索引，idet是当前检测框的索引，意思是第几个轨迹匹配第几个目标框
for itracked, idet in matches:
track = strack_pool[itracked]
det = detections[idet]
if track.state == TrackState.Tracked:
# 更新轨迹预测框为当前检测框
track.update(detections[idet], self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
# refind_stracks是重新追踪到的轨迹
refind_stracks.append(track)
"""-------------第二次匹配：低分检测框匹配-----------------"""
if len(dets_second) > 0:
detections_second = [STrack(STrack.tlbr_to_tlwh(tlbr), s) for
(tlbr, s) in zip(dets_second, scores_second)]
else:
detections_second = []
# 找出第一次匹配后没匹配到的轨迹
r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
# 第一次未匹配的轨迹和低置信度检测框的匹配
dists = matching.iou_distance(r_tracked_stracks, detections_second)
# 用匹配阈值match_thresh = 0.5 过滤较小的iou，利用匈牙利算法进行匹配，得到matches, u_track, u_detection
matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
# 遍历matches，轨迹之前状态为Tracked，调用update方法，并加入到activated_stracks。
# 轨迹之前的状态不是Tracked的，调用re_activate，并加入refind_stracks
for itracked, idet in matches:
track = r_tracked_stracks[itracked]
det = detections_second[idet]
if track.state == TrackState.Tracked:
track.update(det, self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
refind_stracks.append(track)
# 遍历u_track（第二次匹配也没匹配到的轨迹），将state不是Lost的轨迹，调用mark_losk方法，并加入lost_stracks，等待下一帧匹配（本流程开始时会合并追踪状态轨迹和丢失状态轨迹）。
# 一个轨迹既没有被高分检测框匹配，也没有被低分检测框匹配，那么就会被当作丢失轨迹
for it in u_track:
track = r_tracked_stracks[it]
if not track.state == TrackState.Lost:
track.mark_lost()
# lost_stracks：上一帧还在持续追踪但是这一帧两次匹配不到的轨迹
lost_stracks.append(track)
"""----------第三次匹配，处理之前没有匹配上的高分检测框-------------"""
# 没有匹配上的高分检测框
detections = [detections[i] for i in u_detection]
# unconfirmed是第一次出现的目标，生成了轨迹但是不是激活状态。计算第一次出现的目标和没有匹配上的高分检测框的iou_distance
dists = matching.iou_distance(unconfirmed, detections)
if not self.args.mot20:
dists = matching.fuse_score(dists, detections)
# 用阈值match_thresh=0.8过滤较小的iou，利用匈牙利算法进行匹配，得到matches, u_track, u_detection
matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.8)
# 遍历匹配的轨迹，更新状态为激活，并将轨迹保存到当前活跃轨迹中
for itracked, idet in matches:
unconfirmed[itracked].update(detections[idet], self.frame_id)
activated_starcks.append(unconfirmed[itracked])
# 遍历未匹配轨迹，调用mark_removd方法，并加入removed_stracks
for it in u_unconfirmed:
# 中途出现一次的轨迹和当前目标框匹配失败，删除该轨迹，认为是检测器误判
track = unconfirmed[it]
track.mark_removed()
removed_stracks.append(track)
# 遍历未匹配上的高分检测框，对于score大于self.det_thresh，调用activate方法，并加入activated_stracks
for inew in u_detection:
track = detections[inew]
if track.score < self.det_thresh:
continue
# 新建轨迹并调用activate。新建轨迹的激活状态：如果视频开始第一帧就新建轨迹那么激活状态为True，剩下帧新建轨迹激活状态都是False
track.activate(self.kalman_filter, self.frame_id)
#把新的轨迹加入到当前活跃轨迹中
activated_starcks.append(track)
# 遍历lost_stracks，对于丢失超过max_time_lost(30)的轨迹，调用mark_removed方法，并加入removed_stracks
for track in self.lost_stracks:
if self.frame_id - track.end_frame > self.max_time_lost:
track.mark_removed()
removed_stracks.append(track)
# 收集所有状态为Tracked的轨迹，包括本轮更新的activated_starcks和refind_stracks，以及上一轮的self.tracked_stracks
# 遍历tracked_stracks，筛选出state为Tracked的轨迹，保存到tracked_stracks。self.tracked_stracks中在本轮匹配中如果两轮都没有匹配上会被置为lost状态
self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
# 将activated_stracks，refind_stracks合并到track_stracks
self.tracked_stracks = joint_stracks(self.tracked_stracks, activated_starcks)
self.tracked_stracks = joint_stracks(self.tracked_stracks, refind_stracks)
# 更新self.lost_stracks保存的轨迹，从self.lost_stracks中剔除变成追踪状态的轨迹
self.lost_stracks = sub_stracks(self.lost_stracks, self.tracked_stracks)
self.lost_stracks.extend(lost_stracks)
# 更新self.removed_stracks保存的轨迹， 从self.removed_stracks中剔除变成追踪状态的轨迹
self.lost_stracks = sub_stracks(self.lost_stracks, self.removed_stracks)
self.removed_stracks.extend(removed_stracks)
# 调用remove_duplicate_stracks函数，计算tracked_stracks，lost_stracks的iou_distance，对于iou_distance<0.15的认为是同一个轨迹，
# 对比该轨迹在track_stracks和lost_stracks的跟踪帧数和长短，仅保留长的那个
self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
# 遍历self.tracked_stracks，将所有的is_activated为true的轨迹输出
output_stracks = [track for track in self.tracked_stracks if track.is_activated]
return output_stracks
def joint_stracks(tlista, tlistb):
exists = {}
res = []
for t in tlista:
exists[t.track_id] = 1
res.append(t)
for t in tlistb:
tid = t.track_id
if not exists.get(tid, 0):
exists[tid] = 1
res.append(t)
return res
def sub_stracks(tlista, tlistb):
stracks = {}
for t in tlista:
stracks[t.track_id] = t
for t in tlistb:
tid = t.track_id
if stracks.get(tid, 0):
del stracks[tid]
return list(stracks.values())
def remove_duplicate_stracks(stracksa, stracksb):
pdist = matching.iou_distance(stracksa, stracksb)
pairs = np.where(pdist < 0.15)
dupa, dupb = list(), list()
for p, q in zip(*pairs):
timep = stracksa[p].frame_id - stracksa[p].start_frame
timeq = stracksb[q].frame_id - stracksb[q].start_frame
if timep > timeq:
dupb.append(q)
else:
dupa.append(p)
resa = [t for i, t in enumerate(stracksa) if not i in dupa]
resb = [t for i, t in enumerate(stracksb) if not i in dupb]
return resa, resb
参考：
https://blog.csdn.net/wentinghappyday/article/details/128376299
https://blog.csdn.net/weixin_43731103/article/details/123665507
csdn付费文档，惠存
目标跟踪之 MOT 经典算法：ByteTrack 算法原理以及多类别跟踪-CSDN博客.pdf
多目标跟踪（MOT）中的卡尔曼滤波（Kalman filter）和匈牙利(Hungarian)算法详解_mot 卡尔曼滤波-CSDN博客.pdf
目标追踪 ByteTrack 算法详细流程分析的更多相关文章
- POJ 3461 Oulipo[附KMP算法详细流程讲解]
E - Oulipo Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%I64d & %I64u Submit ...
- Php中文件下载功能实现超详细流程分析
浏览器发送一个请求,请求访问服务器中的某个网页(如:down.php),该网页的代码如下 客户端从服务端下载文件的流程分析: 浏览器发送一个请求,请求访问服务器中的某个网页(如:down.php) ...
- 第2章 rsync算法原理和工作流程分析
本文通过示例详细分析rsync算法原理和rsync的工作流程,是对rsync官方技术报告和官方推荐文章的解释. 以下是本文的姊妹篇: 1.rsync(一):基本命令和用法 2.rsync(二):ino ...
- rsync算法原理和工作流程分析
本文通过示例详细分析rsync算法原理和rsync的工作流程,是对rsync官方技术报告和官方推荐文章的解释.本文不会介绍如何使用rsync命令(见rsync基本用法),而是详细解释它如何实现高效的增 ...
- rsync（三）算法原理和工作流程分析
在开始分析算法原理之前,简单说明下rsync的增量传输功能. 假设待传输文件为A,如果目标路径下没有文件A,则rsync会直接传输文件A,如果目标路径下已存在文件A,则发送端视情况决定是否要传输文件A ...
- Openck_Swift源代码分析——添加、删除设备时算法详细的实现过程
1 初始加入设备后.上传Object的详细流程 前几篇博客中,我们讲到环的基本原理即详细的实现过程,加入我们在初始创建Ring是执行例如以下几条命令: •swift-ring-builder obj ...
- Unity动态构建mesh绘制多边形算法流程分析和实践
前言 先说一下,写这篇博文的动机,原文的博主代码写的十分潇洒,以至于代码说明和注释都没有,最近恰逢看到,所以以此博文来分析其中的算法和流程 参考博文:https://blog.csdn.net/lin ...
- 【机器学习实战】第11章 使用 Apriori 算法进行关联分析
第 11 章 使用 Apriori 算法进行关联分析 关联分析 关联分析是一种在大规模数据集中寻找有趣关系的任务. 这些关系可以有两种形式: 频繁项集(frequent item sets): 经常出 ...
- 论文笔记：目标追踪-CVPR2014-Adaptive Color Attributes for Real-time Visual Tracking
基于自适应颜色属性的目标追踪 Adaptive Color Attributes for Real-Time Visual Tracking 基于自适应颜色属性的实时视觉追踪 3月讲的第一篇论文,个人 ...
- u-boot 流程分析
u-boot 介绍: 对于计算机来说 , 从一开始上机通电是无法直接启动操作系统的 , 这中间需要一个引导过程 , 嵌入式Linux系统同样离不开引导程序 , 这个启动程序就叫启动加载程序(Boot ...
随机推荐
- hive第二课：Hive3.1.2分区与排序以及分桶（内置函数）
Hive3.1.2分区与排序(内置函数) 1.Hive分区(十分重要!!) 分区的目的:避免全表扫描,加快查询速度! 在大数据中,最常见的一种思想就是分治,我们可以把大的文件切割划分成一个个的小的文件 ...
- Linux进程退出：SIGINT、SIGTERM 和 SIGKILL 有关信号 区别
背景 学习 海思SDK,查看例程的时候发现了类似下面的代码: int main(int argc, char *argv[]) { if(argc != 2) { printf("Usage ...
- 【Zabbix】Zabbix5.0安装部署问题汇总
报错信息:No package 'oniguruma' found 解决方法:https://www.limstash.com/articles/202003/1563 报错信息: PHP bcmat ...
- .Net Core 访问 appsettings.json
1.添加 NuGet 包 Microsoft.Extensions.Configuration 2.通过注入获取 Configuration 注意:注入获取的必须提前在 StartUp 里面提前注册 ...
- JavaScript -- 变量 --手稿
- Spring的xml和注解对比
常用注解 bean定义 XML方式:<bean></bean> 注解方式:@Component 通用组件 @Controller(web层) @Service(service层 ...
- SpringBoot 1.x 2.x配置文件指定服务项目名
SpringBoot版本1.x: server.context-path=/demo SpringBoot版本2.x: server.servlet.context-path=/demo
- redis出现错误提示MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Commands that may modify the data set are disabled. Please check Redis logs for......
某天,redis出现了这样一个错误提示: MISCONF Redis is configured to save RDB snapshots, but is currently not able to ...
- SQL注入漏洞攻击
l-> 对于用户登录的实现,提供SQL语句 •-> select * from 表名 where uid=- and pwd=- •-> 使用字符串拼接 l-> 提供密码为:' ...
- [oeasy]python0070_动态类型_静态类型_编译_运行_匈牙利命名法
动态类型_静态类型 回忆上次内容 上次了解了 帮助文档的 生成 开头的三引号注释 可以生成 帮助文档 文档 可以写成网页 python3 本身 也有 在线的帮助手册 目前的程序 提高了 可 ...