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)
data_type = 'mot'
result_root = '/home/liujierui/proj/deep_sort_pytorch-master/demo/A-track/ensemble_MOT17_0.75'
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
# eval
logger.info('Evaluate seq: {}'.format(seq))
evaluator = Evaluator(data_root, seq, data_type)
accs.append(evaluator.eval_file(result_filename))
# 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)
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 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))
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import _init_paths
import logging
import os
import os.path as osp
from opts import opts
from tracking_utils.utils import mkdir_if_missing
from tracking_utils.log import logger
import datasets.dataset.jde as datasets
from track import eval_seq
logger.setLevel(logging.INFO)
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,
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 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 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(opt.output_root, opt.exp_id)
mkdir_if_missing(result_root)
data_type = 'mot'
experiment = Experiment(api_key="SK59eWBf9ldDhEMbsQx7IW9G6",
project_name="fairmot",
workspace="noudvdgevel",
auto_param_logging=False,
auto_metric_logging=False,
auto_output_logging=False) #Comet experiment.
hyper_params = {
"conf_thres": opt.conf_thres,
"model": opt.load_model.split('/')[-1],
"data": opt.data_cfg,
"re_id_dim": opt.reid_dim,
"architecture": opt.arch
}
experiment.log_parameters(hyper_params)
experiment.set_name(opt.exp_id)
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join(result_root, 'outputs',
seq) if save_images or save_videos else None
logger.info('start seq: {}'.format(seq))
meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read()
imDir = str(meta_info[meta_info.find('imDir') +
6:meta_info.find('\nframeRate')])
dataloader = datasets.LoadImages(osp.join(data_root, seq, imDir),
opt.img_size)
result_filename = os.path.join(result_root, '{}.txt'.format(seq))
frame_rate = 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)
experiment.log_asset(output_video_path,
file_name="tracking_results.mp4",
copy_to_tmp=False)
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)
summary_items = summary.to_numpy()
for c, seq in enumerate(seqs):
for cc, metric in enumerate(summary):
experiment.log_metric(metric + "_" + seq, summary_items[c][cc])
print(strsummary)
Evaluator.save_summary(
summary, os.path.join(result_root, 'summary_{}.xlsx'.format(exp_name)))
experiment.log_asset(os.path.join(result_root,
'summary_{}.xlsx'.format(exp_name)),
file_name="tracking_results.xlsx",
copy_to_tmp=False)
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 = [], []
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)
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")])
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)))
