def run_mot_16(opt):
list_vid = [
'MOT16-02'
] #,'MOT16-04','MOT16-05','MOT16-09','MOT16-10','MOT16-11','MOT16-13'
for vid in list_vid:
result_root = '../results/' + vid
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
out_size = (1920, 1080) if vid != 'MOT16-05' else (640, 480)
dataloader = datasets.LoadImages(
'../MOT16_Data/train/' + vid + '/img1',
'../MOT16_Data/generate_detection/' + vid,
out_size=out_size)
result_filename = os.path.join(result_root, 'iou.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
bbox_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'bbox_detection')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
bbox_dir=bbox_dir,
show_image=False,
frame_rate=frame_rate)
if opt.output_format == 'video':
output_video_path = osp.join(result_root, 'result.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}'.format(
osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
use_cuda=opt.gpus != [-1])
if opt.output_format == 'video':
output_video_path = osp.join(result_root, 'MOT16-03-results.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}'.format(
osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
def demo(opt, ROS_Img, frame_id):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
# dataloader = datasets.LoadVideo(input_file, opt.img_size)
# print(init)
img, img0 = preprocessing(ROS_Img)
result_filename = os.path.join(result_root, 'results.txt')
#frame_rate = dataloader.frame_rate
frame_rate = 10
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
#frame_dir = "../demos/img_results"
print(opt.output_root)
eval_seq_single(
opt,
img,
img0,
tracker,
results,
frame_id,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
)
def demo(opt):
result_root = opt.output_root if opt.output_root != "" else "."
mkdir_if_missing(result_root)
logger.info("Starting tracking...")
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_filename = os.path.join(result_root, "results.txt")
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == "text" else osp.join(
result_root, "frame")
eval_seq(
opt,
dataloader,
"mot",
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
)
if opt.output_format == "video":
output_video_path = osp.join(result_root, "result.mp4")
cmd_str = "ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}".format(
osp.join(result_root, "frame"), output_video_path)
os.system(cmd_str)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
print('OPT: {}'.format(opt.input_video))
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
try:
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=True,
frame_rate=frame_rate)
except Exception as e:
logger.info(e)
if opt.output_format == 'video':
output_video_path = osp.join(result_root, 'result.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}'.format(
osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
assert osp.exists(opt.input_video), f'{opt.input_video} does NOT exist !'
file_name, file_ext = osp.splitext(opt.input_video)
if file_ext in ['.mp4', 'avi']:
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
else:
dataloader = datasets.LoadImages(opt.input_video, opt.img_size)
dataloader.frame_rate = int(round(opt.frame_rate))
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
use_cuda=opt.gpus != [-1])
if opt.output_format == 'video':
output_video_path = osp.join(result_root, 'MOT16-03-results.mp4')
frame_path = osp.join(result_root, 'frame')
cmd_str = f'ffmpeg -framerate {opt.frame_rate} -f image2 -i {frame_path}/%05d.jpg -b 5000k -c:v mpeg4 {output_video_path}'
os.system(cmd_str)
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30,
use_cuda=True):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
#for path, img, img0 in dataloader:
for i, (path, img, img0) in enumerate(dataloader):
#if i % 8 != 0:
#continue
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# run tracking
timer.tic()
if use_cuda:
blob = torch.from_numpy(img).cuda().unsqueeze(0)
else:
blob = torch.from_numpy(img).unsqueeze(0)
online_targets = tracker.update(blob, img0)
online_tlwhs = []
online_ids = []
#online_scores = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
#online_scores.append(t.score)
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids))
#results.append((frame_id + 1, online_tlwhs, online_ids, online_scores))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
write_results(result_filename, results, data_type)
#write_results_score(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
dataloader = datasets.LoadImages(
opt.input_path, opt.input_detection_path) #, out_size = (640,480)
result_filename = os.path.join(result_root, 'baseline.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
bbox_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'bbox_detection')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
bbox_dir=bbox_dir,
show_image=False,
frame_rate=frame_rate)
if opt.output_format == 'video':
output_video_path = osp.join(result_root, 'result.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}'.format(
osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
file_name = osp.basename(opt.input_video).split('.')[0].replace(' ', '_')
model_name = osp.basename(opt.load_model).split('.')[0]
base_name = f'{file_name}_{model_name}_{opt.conf_thres}'
logger.info('Starting tracking...')
logger.info(f'Working on: {opt.input_video}')
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_filename = os.path.join(result_root, f'{base_name}_results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, f'{file_name}-frames')
eval_seq(opt,
dataloader,
'kitti',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate)
if opt.output_format == 'video':
output_video_path = osp.join(result_root, f'{base_name}_result.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}'.format(
osp.join(result_root, f'{file_name}-frames'), output_video_path)
os.system(cmd_str)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
# dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
# result_filename = os.path.join(result_root, 'results.txt')
# frame_rate = dataloader.frame_rate
eval_seq_realtime(opt)
def main(opt, data_root='/data/MOT16/train', det_root=None, seqs=('MOT16-05',), exp_name='demo',
save_images=False, save_videos=False, show_image=True):
logger.setLevel(logging.INFO)
result_root = os.path.join(data_root, '..', 'results', exp_name)
mkdir_if_missing(result_root)
data_type = 'bdd'
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join(data_root, '..', 'outputs', exp_name, seq) if save_images or save_videos else None
logger.info('start seq: {}'.format(seq))
# dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size)
dataloader = datasets.LoadImages(data_root, opt.img_size)
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
gt_filename = os.path.join(result_root, '{}_gt.txt'.format(seq))
frame_rate = 30
# eval_det(opt, dataloader, data_type, result_filename,
# save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)
nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename, gt_filename,
save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)
n_frame += nf
timer_avgs.append(ta)
timer_calls.append(tc)
# eval
logger.info('Evaluate seq: {}'.format(seq))
evaluator = Evaluator(data_root, seq, data_type, gt_filename)
# accs.append(evaluator.eval_file(result_filename))
for i in range(len(class_names_valid)):
accs.append(evaluator.eval_file_sp(i, result_filename))
if save_videos:
output_video_path = osp.join(output_dir, '{}.mp4'.format(seq))
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(output_dir, output_video_path)
os.system(cmd_str)
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = np.dot(timer_avgs, timer_calls)
avg_time = all_time / np.sum(timer_calls)
logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(all_time, 1.0 / avg_time))
# get summary
metrics = mm.metrics.motchallenge_metrics
mh = mm.metrics.create()
summary = Evaluator.get_summary(accs, names=class_names_valid, metrics=metrics)
strsummary = mm.io.render_summary(
summary,
formatters=mh.formatters,
namemap=mm.io.motchallenge_metric_names
)
print(strsummary)
print('mMOTA:', summary['mota'].mean())
def main(opt, data_root='/data/MOT16/train', det_root=None, seqs=('MOT16-05',), exp_name='demo',
save_images=False, save_videos=False, show_image=True):
logger.setLevel(logging.INFO)
result_root = os.path.join(data_root, '..', 'results', exp_name)
mkdir_if_missing(result_root)
data_type = 'mot'
print(opt)
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join(data_root, '..', 'outputs', exp_name, seq) if save_images or save_videos else None
logger.info('start seq: {}'.format(seq))
# print(osp.join(data_root, seq, 'img1'))
dataloader = datasets.LoadImages(osp.join(data_root, seq), opt.img_size)
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
meta_info = None #open(os.path.join(data_root, seq, 'seqinfo.ini')).read()
frame_rate = 15 #int(meta_info[meta_info.find('frameRate') + 10:meta_info.find('\nseqLength')])
nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename,
save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)
n_frame += nf
timer_avgs.append(ta)
timer_calls.append(tc)
# eval
logger.info('Evaluate seq: {}'.format(seq))
evaluator = Evaluator(data_root, seq, data_type)
accs.append(evaluator.eval_file(result_filename))
if save_videos:
output_video_path = osp.join(output_dir, '{}.mp4'.format(seq))
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(output_dir, output_video_path)
os.system(cmd_str)
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = np.dot(timer_avgs, timer_calls)
avg_time = all_time / np.sum(timer_calls)
logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(all_time, 1.0 / avg_time))
# get summary
metrics = mm.metrics.motchallenge_metrics
mh = mm.metrics.create()
summary = Evaluator.get_summary(accs, seqs, metrics)
strsummary = mm.io.render_summary(
summary,
formatters=mh.formatters,
namemap=mm.io.motchallenge_metric_names
)
print(strsummary)
Evaluator.save_summary(summary, os.path.join(result_root, 'summary_{}.xlsx'.format(exp_name)))
def eval_det(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
for path, img, img0 in dataloader:
if frame_id < 302:
frame_id += 1
continue
elif frame_id > 302:
break
else:
print(frame_id)
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# if frame_id>20:
# break
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
dets = tracker.detect(blob, img0)
# print(path, dets)
tlbrs = []
scores = []
class_ids = []
for det in dets:
tlbrs.append(det[:4])
scores.append(det[4])
class_ids.append(int(det[5] - 1))
# print(class_ids)
if show_image or save_dir is not None:
online_im = vis.plot_detections(img0,
tlbrs,
scores=None,
ids=class_ids)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
def eval_seq(opt,
data_path,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30):
tracker = JDETracker(opt)
# timer = Timer()
results = []
frame_id = 0
frame_nums = 60 #len(os.listdir(data_path))//2
#np_res = []
for _ in range(frame_nums):
frame_id += 1
dets = np.loadtxt(os.path.join(data_path,
str(frame_id) + '.txt'),
dtype=np.float32,
delimiter=',')
online_targets = tracker.update(dets)
online_tlwhs = []
online_ids = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
if tlwh[2] * tlwh[3] > opt.min_box_area and tlwh[2] / tlwh[3] < 1.6:
online_tlwhs.append(tlwh)
online_ids.append(tid)
# np_res.append([frame_id,tid,tlwh[0],tlwh[1],tlwh[2],tlwh[3],1,0])
## save results
results.append((frame_id, online_tlwhs, online_ids))
if show_image or save_dir is not None:
if save_dir:
mkdir_if_missing(save_dir)
img = cv2.imread(os.path.join(data_path, str(frame_id) + '.jpg'))
online_im = vis.plot_tracking(img,
online_tlwhs,
online_ids,
frame_id=frame_id)
# if show_image:
# cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
# save results
write_results(result_filename, results, data_type)
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
tracklist = os.listdir(opt.data_root)
for tra in tracklist:
data_path = os.path.join(opt.data_root, tra)
result_filename = os.path.join(result_root, tra + '.txt')
frame_dir = osp.join(result_root, tra)
eval_seq(opt,
data_path,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False)
BaseTrack.clear_id()
def demo(opt):
paths = pickle.load(open(opt.paths_pkl, 'rb'))
gpu_list = opt.custom_gpus.split(',')
if opt.range[1] == -1:
opt.range[1] = len(paths)
tasks = paths[opt.range[0]:opt.range[1]]
to_del_list = []
for idx, path in enumerate(tasks):
video_name = osp.splitext(osp.split(path)[1])[0]
result_root = opt.output_root if opt.output_root != '' else '.'
result_filename = os.path.join(result_root, '%s.txt' % video_name)
if os.path.exists(result_filename):
to_del_list.append(idx)
deleted_tasks = [
tasks[idx] for idx in range(len(tasks)) if idx not in to_del_list
]
opt.range[0] = 0
opt.range[1] = len(deleted_tasks)
if len(gpu_list) > 1:
pickle.dump(deleted_tasks, open('cache.pkl', 'wb'))
opt.paths_pkl = 'cache.pkl'
multiproc(opt, gpu_list, len(deleted_tasks))
else:
for idx, path in enumerate(deleted_tasks):
video_name = osp.splitext(osp.split(path)[1])[0]
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
result_filename = os.path.join(result_root, '%s.txt' % video_name)
if os.path.exists(result_filename):
continue
# logger.info('Starting tracking...')
# dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
dataloader = datasets.LoadVideo(path, opt.img_size)
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
tasks_num=len(deleted_tasks),
idx=idx)
def recogniton():
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
print("start tracking")
dataloader = datasets.LoadVideo(0, opt.img_size)
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else os.path.join(
result_root, 'frame')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=True,
frame_rate=frame_rate)
def main(opt,
data_root='/data/MOT16/train',
det_root=None,
seqs=('MOT16-05', ),
exp_name='demo',
save_images=False,
save_videos=False,
show_image=True):
logger.setLevel(logging.INFO)
result_root = os.path.join(data_root, '..', 'results', exp_name)
mkdir_if_missing(result_root)
data_type = 'bdd'
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join(data_root, '..', 'outputs', exp_name,
seq) if save_images or save_videos else None
logger.info('start seq: {}'.format(seq))
# dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size)
dataloader = datasets.LoadImages(data_root, opt.img_size)
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
# meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read()
# frame_rate = int(meta_info[meta_info.find('frameRate') + 10:meta_info.find('\nseqLength')])
frame_rate = 30
# eval_det(opt, dataloader, data_type, result_filename,
# save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)
nf, ta, tc = eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=output_dir,
show_image=show_image,
frame_rate=frame_rate)
n_frame += nf
timer_avgs.append(ta)
timer_calls.append(tc)
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = np.dot(timer_avgs, timer_calls)
avg_time = all_time / np.sum(timer_calls)
logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(
all_time, 1.0 / avg_time))
def demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate)
def eval_seq(opt,
dataloader,
data_type,
save_dir=None,
show_image=True,
frame_rate=30):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
writer = VideoWriter(save_dir, dataloader)
for path, img, img0 in dataloader:
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
online_targets = tracker.update(blob, img0)
online_tlwhs = []
online_ids = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
# cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)), online_im)
writer.write(online_im)
frame_id += 1
print("***************************** DONE *****************************")
def recogniton(opt):
print("start tracking")
if opt.input_stream == '':
dataloader = datasets.LoadVideo(opt.input_camera, opt.img_size)
else:
dataloader = datasets.LoadVideo(opt.input_stream, opt.img_size)
frame_rate = dataloader.frame_rate
if opt.save:
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
result_filename = os.path.join(result_root, 'results.txt')
frame_dir = None if opt.output_format == 'text' else os.path.join(
result_root, 'frame')
eval_seq(opt, dataloader, 'mot', result_filename,
save_dir=frame_dir, show_image=opt.show, frame_rate=frame_rate,
use_cuda=opt.gpus != [-1])
else:
eval_seq(opt, dataloader, 'mot', show_image=opt.show,
frame_rate=frame_rate, use_cuda=opt.gpus != [-1])
def demo(opt, polygon1, polygon2, prepath=None, cam_id=None):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(opt.input_video, opt.img_size)
polygon, paths = load_zone_anno(opt.input_meta)
if prepath is not None:
paths = prepath
polygon = np.int32(polygon1)
#line1,line2=[polygon[4],polygon[3]],[polygon[1],polygon[2]]
polygon2, _ = np.int32(polygon2), None
result_filename = os.path.join(result_root, 'results.txt')
frame_rate = dataloader.frame_rate
print(cam_id)
frame_tracking_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame_tracking')
bbox_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'bbox_detection')
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame_dir')
eval_seq(opt,
dataloader,
polygon,
paths,
'mot',
result_filename,
frame_dir=frame_dir,
save_dir=frame_tracking_dir,
bbox_dir=bbox_dir,
show_image=False,
frame_rate=frame_rate,
polygon2=polygon2,
line1=None,
line2=None,
cam_id=cam_id)
def main(opt, data_root='/data/MOT16/train', det_root=None, seqs=('MOT16-05',), exp_name='demo',
save_images=False, save_videos=False, show_image=True):
logger.setLevel(logging.INFO)
# result_root = os.path.join(data_root, '..', 'results', exp_name)
result_root = os.path.join('/home/liujierui/proj/FairMOT-master/outputs', exp_name)
mkdir_if_missing(result_root)
data_type = 'mot'
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join('/home/liujierui/proj/FairMOT-master/outputs', exp_name, seq) if save_images or save_videos else None
video_dir = os.path.join('/home/liujierui/proj/FairMOT-master/outputs', exp_name) if save_images or save_videos else None
mkdir_if_missing(output_dir)
mkdir_if_missing(video_dir)
logger.info('start seq: {}'.format(seq))
dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size)
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
# meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read()
# frame_rate = int(meta_info[meta_info.find('frameRate') + 10:meta_info.find('\nseqLength')])
frame_rate = 15
nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename,
save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)
n_frame += nf
timer_avgs.append(ta)
timer_calls.append(tc)
# # eval
# logger.info('Evaluate seq: {}'.format(seq))
# evaluator = Evaluator(data_root, seq, data_type)
# accs.append(evaluator.eval_file(result_filename))
if save_videos:
# output_video_path = osp.join(video_dir, '{}.mp4'.format(seq))
# cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(output_dir, output_video_path)
# # cmd_str = 'ffmpeg -f image2 -i {}/%d.jpg -c:v copy {}'.format(output_dir, output_video_path)
# os.system(cmd_str)
path=output_dir
# path=join(self.video_path,str(id_video),'img1')
filelist_0 = os.listdir(path) #获取该目录下的所有文件名
filelist=[str(i) for i in range(1,len(filelist_0)+1)]
avi_name = join(video_dir,seq + ".avi")#导出路径
item = path + '/1.jpg'
ori_im = cv2.imread(item)
video = cv2.VideoWriter(avi_name, cv2.VideoWriter_fourcc('M','J','P','G'), 15, (ori_im .shape[1],ori_im.shape[0]))
for id_img in filelist:
item = path + '/' + id_img+'.jpg'
ori_im = cv2.imread(item)
video.write(ori_im)
video.release()
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = np.dot(timer_avgs, timer_calls)
avg_time = all_time / np.sum(timer_calls)
logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(all_time, 1.0 / avg_time))
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30):
#verifica che sia presente la cartella di salvataggio e in caso non lo sia la crea
if save_dir:
mkdir_if_missing(save_dir)
#crea il JDETracker che esegue le seguenti operazioni (che vengono trovate in src/lib/tracker/multitracker.py nella funzione init)
#1) Verifica se il programma va eseguito con CPU o GPU
#2) Crea il modello e lo valuta
#3) Applica un Kalman Filter: e’ uno strumento per stimare lo stato di un sistema dinamico lineare perturbato da rumore, sulla base di misure (o osservazioni) linearmente dipendenti
tracker = JDETracker(opt, frame_rate=frame_rate)
#viene inizializzato il timer per monitorare il tempo di elaborazione
timer = Timer()
#inizializzazione array dei risultati
results = []
#identificatore del frame
frame_id = 0
#scorriamo gli elementi all'interno del dataloader che erano le immagini del database caricate nel main
for path, img, img0 in dataloader:
#visualizza il frame rate dopo 20 frame elaborati
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# run tracking
timer.tic()
#questa funzione è specifica per le GPU NVIDIA, infatti usa CUDA, si può sostituire con CPU nel caso si voglia eseguire il programma con CPU
#crea una matrice multidimensionale di almeno 3 elementi per rappresentare l'immagine img
blob = torch.from_numpy(img).cuda().unsqueeze(0)
#viene applicata la funzione update del JDETracker che svolge le seguenti funzioni (src/lib/tracker/multitracker.py)
#1) Vengono passati come parametri gli elementi blob e img0
#2) Da entrambi si estraggono altezza e larghezza e vengono memorizzate in una variabile
#3) viene creata una variabile c che memorizza un array di float che contiene come due elementi altezza e larghezza dimezzata di img0
#4) viene creata una variabile s che memorizza il massimo fra max(float(inp_width) (blob) / float(inp_height) (blob) * height (img0), width (img0)) * 1.0
#5) Network forward, get detections & embeddings: rileva gli oggetti e gli aggiunge a una pila di tracklet
#6) Prima associazione con Embedding: Da Paper, il ruolo dell'embedding è quello di distinguere diversi tipi di oggetti
#7) Seconda associazione con IoU
#8) Inizializza nuovi Stracks
#9) Aggiorna lo stato
#10) Ritorna nella variabile il valore degli stracks attivi
online_targets = tracker.update(blob, img0)
online_tlwhs = []
online_ids = []
#vengono iterati i vari stracks
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
write_results(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def main(opt,
data_root='/data/MOT16/train',
det_root=None,
seqs=('MOT16-05', ),
exp_name='demo',
save_images=False,
save_videos=False,
show_image=True):
logger.setLevel(logging.INFO)
result_root = os.path.join(data_root, '..', 'results', exp_name)
mkdir_if_missing(result_root)
data_type = 'mot'
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
#scorre tutti gli elementi della sequenza di frame previsti dal MOT passato come parametro
for seq in seqs:
#stabilisce la cartella in cui dovrà salvare gli output elaborati
output_dir = os.path.join(data_root, '..', 'outputs', exp_name,
seq) if save_images or save_videos else None
#messaggio che viene restituito all'utente per aggiornarlo sull'andamento dell'esecuzione
logger.info('start seq: {}'.format(seq))
#carica l'immagine contenuta all'interno del dataset passato come parametro da seq
dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'),
opt.img_size)
#Il file testuale con il risultato dell'elaborazione è salvato in result_filename
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
#legge un file per seguire le indicazioni
meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read()
#qui avviene il calcolo del frame rate, per comprendere quanti frame fa nell'unità di tempo
frame_rate = int(meta_info[meta_info.find('frameRate') +
10:meta_info.find('\nseqLength')])
#esecuzione di eval_seq
nf, ta, tc = eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=output_dir,
show_image=show_image,
frame_rate=frame_rate)
n_frame += nf
timer_avgs.append(ta)
timer_calls.append(tc)
# eval
logger.info('Evaluate seq: {}'.format(seq))
evaluator = Evaluator(data_root, seq, data_type)
accs.append(evaluator.eval_file(result_filename))
if save_videos:
output_video_path = osp.join(output_dir, '{}.mp4'.format(seq))
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(
output_dir, output_video_path)
os.system(cmd_str)
timer_avgs = np.asarray(timer_avgs)
timer_calls = np.asarray(timer_calls)
all_time = np.dot(timer_avgs, timer_calls)
avg_time = all_time / np.sum(timer_calls)
logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(
all_time, 1.0 / avg_time))
# get summary
metrics = mm.metrics.motchallenge_metrics
mh = mm.metrics.create()
summary = Evaluator.get_summary(accs, seqs, metrics)
strsummary = mm.io.render_summary(summary,
formatters=mh.formatters,
namemap=mm.io.motchallenge_metric_names)
print(strsummary)
Evaluator.save_summary(
summary, os.path.join(result_root, 'summary_{}.xlsx'.format(exp_name)))
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30,
use_cuda=True):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
#for path, img, img0 in dataloader:
out_queue = Deque(maxlen=6)
for i, (path, img, img0) in enumerate(dataloader):
#if i % 8 != 0:
#continue
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# run tracking
timer.tic()
time_clean()
time_sync('tracker all')
if use_cuda:
blob = torch.from_numpy(img).cuda().unsqueeze(0)
else:
blob = torch.from_numpy(img).unsqueeze(0)
with torch.no_grad():
time_sync('forward_half and queue')
out = tracker.model.backend.forward_half(
blob, roi_num=tracker.model.backend.roi_top_k)
out_ref = {}
out_ref.update(out)
out_ref['rois'], _ = tracker.model.backend.get_rois(
out['rpn_map'], 300)
refs = tracker.model.backend.forward_rois(out_ref)
out_queue.append(refs)
while len(out_queue) < out_queue.maxlen:
out_queue.append(refs)
time_sync('forward_half and queue')
time_sync('forward_all')
output, stuffs, _ = tracker.model.forward_half(out, out_queue)
time_sync('forward_all')
# info_debug(output)
# jj = output['rois'][0] % out['rpn_map'].shape[-1]
# ii = output['rois'][0] // out['rpn_map'].shape[-1]
# u = output['rpn_map'][:, :, ii, jj]
# print(output['hm'][:20])
# input()
# import pickle
# print(u.shape)
# print(u.flatten().sigmoid())
# print((u.flatten().sigmoid() - output['hm'].flatten().sigmoid()).abs().max())
# with open('two_none.pkll', 'wb') as fd:
# pickle.dump(output, fd)
# input()
time_sync('tracker update')
online_targets = tracker.update(blob, img0, output)
time_sync('tracker update')
online_tlwhs = []
online_ids = []
#online_scores = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
#online_scores.append(t.score)
time_sync('tracker all')
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids))
#results.append((frame_id + 1, online_tlwhs, online_ids, online_scores))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
import pickle
with open(result_filename + '.dets.pkl', 'wb') as fd:
pickle.dump(tracker.raw_dets, fd)
write_results(result_filename, results, data_type)
#write_results_score(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30,
conf_thres=0.3):
if save_dir:
mkdir_if_missing(save_dir)
tracker = GNNTracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
for i, (path, img, img0, p_img_path, p_img) in enumerate(dataloader):
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
if i == 0:
p_boxes, init_img_path, p_img = dataloader.initialize(
use_letter_box=opt.use_letter_box)
else:
p_boxes, p_img = prepare_prev_img(dataloader, online_targets, opt,
p_img)
if opt.use_roi_align:
p_crops = p_boxes.clone()
_, h, w = p_img.shape
p_crops = p_crops.cuda()
p_crops_lengths = [len(p_crops)]
edge_index = create_inference_time_graph(opt, p_boxes, p_crops,
p_img)
# convert boxes from xyxy to normalized according to p_img dimensions
p_crops[:, 0] = p_crops[:, 0] / w
p_crops[:, 1] = p_crops[:, 1] / h
p_crops[:, 2] = p_crops[:, 2] / w
p_crops[:, 3] = p_crops[:, 3] / h
online_targets = tracker.update(
blob,
img0,
p_crops,
p_crops_lengths,
edge_index,
gnn_output_layer=opt.inference_gnn_output_layer,
p_imgs=p_img.unsqueeze(0).cuda(),
conf_thres=conf_thres)
else:
p_crops = torchvision.ops.roi_align(input=p_img.unsqueeze(0),
boxes=[p_boxes],
output_size=opt.crop_size)
p_crops = p_crops.cuda()
p_crops_lengths = [len(p_crops)]
edge_index = create_inference_time_graph(opt, p_boxes, p_crops,
p_img)
online_targets = tracker.update(
blob,
img0,
p_crops,
p_crops_lengths,
edge_index,
gnn_output_layer=opt.inference_gnn_output_layer,
p_imgs=None,
conf_thres=conf_thres)
online_tlwhs = []
online_ids = []
online_confs = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
t_conf = t.score
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
online_confs.append(t_conf)
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids, online_confs))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
scores=online_confs,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
write_results(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir='.',
show_image=True,
frame_rate=25):
tracker = JDETracker(opt, frame_rate=frame_rate)
p = path_root_index[5]
if save_dir:
save_dir = osp.join(save_dir, p)
mkdir_if_missing(save_dir)
image_path = getimage_path(path_root + p)
timer = Timer()
results = []
frame_id = -1
result_array_list = []
result = []
for path in image_path:
# img=cv2.imread(path)
img0 = cv2.imread(path) # BGR
# assert img0 is not None, 'Failed to load ' + img_path
img_height = img0.shape[0]
img_width = img0.shape[1]
# print(img_height,img_width)
# print(img0.shape)
# Padded resize
img, _, _, _ = letterbox(img0, height=608, width=1088)
# Normalize RGB
img = img[:, :, ::-1].transpose(2, 0, 1)
img = np.ascontiguousarray(img, dtype=np.float32)
img /= 255.0
frame_id += 1
# if frame_id % 20 == 0:
# logger.info('Processing frame {} ({:.2f} fps)'.format(frame_id, 1. / max(1e-5, timer.average_time)))
# if frame_id==2:
# break
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
online_targets = tracker.update(blob, img0)
online_tlwhs = []
online_ids = []
online_cref = []
# result_array_list=[]
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
confidence = t.score
vertical = tlwh[2] / tlwh[3] > 1.6
if confidence < 0.3:
if tlwh[2] * tlwh[3] > 2700 and not vertical and tlwh[
2] * tlwh[3] < 100000:
res = [frame_id, tid]
res += list(tlwh)
res += [1, 0]
online_tlwhs.append(tlwh)
result_array_list.append(res)
online_cref.append(confidence)
# print(confidence)
# result_array_list.append(tlwh)
online_ids.append(tid)
elif confidence >= 0.3:
if tlwh[2] * tlwh[3] > 1000 and not vertical and tlwh[
2] * tlwh[3] < 100000:
# print(tlwh[2] * tlwh[3])
res = [frame_id, tid]
res += list(tlwh)
res += [1, 0]
online_tlwhs.append(tlwh)
result_array_list.append(res)
online_cref.append(confidence)
# print(confidence)
# result_array_list.append(tlwh)
online_ids.append(tid)
# if frame_id==2:
# break
timer.toc()
# save results
print(frame_id)
# if result_array_list:
online_tlwhs = np.array(online_tlwhs)
online_ids = np.array(online_ids)
online_cref = np.array(online_cref)
# print(online_tlwhs)
# print(online_tlwhs.shape)
# print(online_ids.shape)
# pick=non_max_suppression(online_tlwhs,0.7,online_cref)
# online_tlwhsnms=online_tlwhs[pick]
# online_idsnms=online_ids[pick]
# online_crefnms=online_cref[pick]
# result_array_list2=np.array(result_array_list).copy()[pick]
# result+=list(result_array_list2)
# print(result)
# print(frame_id,online_idsnms)
# result.append(online_tlwhsnms)
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
scores=online_cref,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
cv2.waitKey(1)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
res_array = np.array(result_array_list)
# print(res_array)
# print(res_array.shape)
tmp_data1 = np.where(res_array[:, [2]] < 0,
res_array[:, [2]] + res_array[:, [4]], res_array[:,
[4]])
res_array[:, [4]] = tmp_data1
tmp_data = np.where(res_array[:, [3]] < 0,
res_array[:, [3]] + res_array[:, [5]], res_array[:,
[5]])
res_array[:, [5]] = tmp_data
res_array[:, [2, 3]] = np.maximum(res_array[:, [2, 3]], 0)
# print(res_array)
res_array = np.round(res_array, 0)
# res_array=cutmorecord(res_array,img_width,img_height)
# print(res_array)
np.savetxt("{}.txt".format(p),
res_array,
fmt='%d,%d,%d,%d,%d,%d,%d,%d',
delimiter=',')
# save results
# write_results(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
tid_max, tid_temp = 1, 1
for path, img, img0 in dataloader:
if frame_id < 300:
frame_id += 1
continue
elif frame_id > 302:
break
else:
print(frame_id)
filename = path.split('/')[-1]
if '0000001' in path:
tid_max = tid_temp + 1
print(path, tid_max)
tracker = JDETracker(opt, frame_rate=frame_rate)
if frame_id % 100 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# if frame_id >20:
# break
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
online_targets = tracker.update_sep3(
blob,
img0,
conf_thres=[0.4, 0.3, 0.4, 0.4, 0.4, 0.4, 0.4, 0.5, 0.5])
# print(online_targets)
online_tlwhs = []
online_ids = []
online_cids = [] #class id
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id + tid_max
tcid = t.class_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area: # and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
online_cids.append(tcid)
tid_temp = max(tid, tid_temp)
timer.toc()
# save results
results.append((filename, online_tlwhs, online_ids, online_cids))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
write_results(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
def eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=None,
show_image=True,
frame_rate=30):
if save_dir:
mkdir_if_missing(save_dir)
tracker = JDETracker(opt, frame_rate=frame_rate)
timer = Timer()
results = []
frame_id = 0
'''
img: Normalized RGB image
img0: BGR image
'''
for path, img, img0 in dataloader:
if frame_id % 20 == 0:
logger.info('Processing frame {} ({:.2f} fps)'.format(
frame_id, 1. / max(1e-5, timer.average_time)))
# run tracking
timer.tic()
blob = torch.from_numpy(img).cuda().unsqueeze(0)
# print("\n==> blob.size", blob.size()) 1, 3, 608, 1088
'''
tracker update
'''
online_targets = tracker.update(blob, img0)
online_tlwhs = []
online_ids = []
for t in online_targets:
tlwh = t.tlwh
tid = t.track_id
vertical = tlwh[2] / tlwh[3] > 1.6
if tlwh[2] * tlwh[3] > opt.min_box_area and not vertical:
online_tlwhs.append(tlwh)
online_ids.append(tid)
'''
print("==> [track.eval_seq] tracker's output-> online_targets:", online_targets)
try:
print("==> [track.eval_seq] len(online_tlwhs):", len(online_tlwhs))
print("==> [track.eval_seq] online_tlwhs[0]:", online_tlwhs[0])
print("==> [track.eval_seq] online_ids[0]:", online_ids[0])
except:
pass
partial output:
==> [multi-tracker.update] len(output_stracks): 5
==> [track.eval_seq] tracker's output-> online_targets: [OT_1_(1-13), OT_2_(1-13), OT_3_(1-13), OT_20_(10-13), OT_7_(2-13)]
==> [track.eval_seq] len(online_tlwhs): 5
==> [track.eval_seq] online_tlwhs[0]: [ 802.38 163.64 24.074 57.376]
==> [track.eval_seq] online_ids[0]: 1
==> [multi-tracker.update] len(output_stracks): 7
==> [track.eval_seq] tracker's output-> online_targets: [OT_1_(1-14), OT_2_(1-14), OT_3_(1-14), OT_20_(10-14), OT_7_(2-14), OT_23_(13-14), OT_13_(4-14)]
==> [track.eval_seq] len(online_tlwhs): 7
==> [track.eval_seq] online_tlwhs[0]: [ 809.96 163.69 25.305 60.319]
==> [track.eval_seq] online_ids[0]: 1
==> [multi-tracker.update] len(output_stracks): 7
==> [track.eval_seq] tracker's output-> online_targets: [OT_1_(1-15), OT_2_(1-15), OT_3_(1-15), OT_20_(10-15), OT_7_(2-15), OT_23_(13-15), OT_19_(10-15)]
==> [track.eval_seq] len(online_tlwhs): 7
==> [track.eval_seq] online_tlwhs[0]: [ 818.46 164.4 26.832 63.971]
==> [track.eval_seq] online_ids[0]: 1
'''
timer.toc()
# save results
results.append((frame_id + 1, online_tlwhs, online_ids))
if show_image or save_dir is not None:
online_im = vis.plot_tracking(img0,
online_tlwhs,
online_ids,
frame_id=frame_id,
fps=1. / timer.average_time)
if show_image:
cv2.imshow('online_im', online_im)
if save_dir is not None:
cv2.imwrite(os.path.join(save_dir, '{:05d}.jpg'.format(frame_id)),
online_im)
frame_id += 1
# save results
write_results(result_filename, results, data_type)
return frame_id, timer.average_time, timer.calls
