def run_demo(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
logger.info('Starting tracking...')
data_loader = datasets.LoadVideo(opt.input_video, opt.img_size)
result_file_name = os.path.join(result_root, 'results.txt')
frame_rate = data_loader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(result_root, 'frame')
try: # 视频推断的入口函数
eval_seq(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
save_dir=frame_dir,
show_image=False,
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 track(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# run tracking
timer = Timer()
accs = []
n_frame = 0
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=False,
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 -c:v copy {}'.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,
)
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)
re_mkdir(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=False,
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')
output_video_path = osp.join('/workspace/FairMOT/result-videos',
opt.input_video.split('/')[-1])
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.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 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):
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...')
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 track(opt):
if opt.AVA:
if opt.ov:
if opt.skip:
outPath = '../../output/trmot_ov/{}'.format(opt.skip)
else:
outPath = '../../output/trmot_ov'
elif opt.cpu:
if opt.skip:
outPath = '../../output/trmot_cpu/{}'.format(opt.skip)
else:
outPath = '../../output/trmot_cpu'
else:
if opt.skip:
outPath = '../../output/trmot_gpu/{}'.format(opt.skip)
else:
outPath = '../../output/trmot_gpu'
if opt.skip==0:
opt.skip=1
if not os.path.exists(outPath):
os.makedirs(outPath)
if opt.video_path!=0:
countFileName = '{}/{}.csv'.format(outPath, opt.video_path.split('/')[-1].split('.mp4')[0])
else:
countFileName = '{}/results_live_cam.csv'.format(outPath)
countFile = open(countFileName, 'w')
countFile.close()
result_root = opt.output_root if opt.output_root!='' else '.'
mkdir_if_missing(result_root)
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# run tracking
timer = Timer()
accs = []
n_frame = 0
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(opt.video_path, 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, countFileName, save_dir=frame_dir, show_image=False, 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 -c:v copy {}'.format(osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
def track(opt):
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# run tracking
timer = Timer()
accs = []
n_frame = 0
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:
ob = eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate)
o = ob[3][1:] #bd{
i = ob[4]
l_count = 0
l_count = ob[5]
ai = sum(i) / len(i)
ao = sum(o) / len(o)
print("\nAverage Inflow=", ai)
print("\nAverage Outflow=", ao)
if (ai > ao):
print(
"\n Congratulations!! The ROI is proving to be a hotspot !!!\n"
)
elif (ao > ai):
print(
"\n The ROI is losing people attention !!!\n"
)
else:
print(
"\n The ROI has a moderate people attention !!!\n"
) #bd}
print(
"\n The ROI has a current crowd of %d people !!!\n"
% l_count)
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 -c:v copy {}'.format(
osp.join(result_root, 'frame'), output_video_path)
os.system(cmd_str)
return o, i, l_count
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 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 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 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 track(opt):
result_root = opt.output_root if opt.output_root!='' else '.'
mkdir_if_missing(result_root)
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# run tracking
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)
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 track(opt):
# set saving dir
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
# set configuration
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
logger.info('Starting tracking...')
# use camera to track
dataloader = datasets.LoadCamera(img_size=opt.img_size)
result_filename = os.path.join(result_root, 'results.txt')
try:
# start tracking
eval_seq(opt,
dataloader,
'mot',
result_filename,
save_dir=result_root,
show_image=True)
except Exception as e:
logger.info(e)
def run_demo(opt):
"""
:param opt:
:return:
"""
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
# clear existing frame results
frame_res_dir = result_root + '/frames'
if os.path.isdir(frame_res_dir):
shutil.rmtree(frame_res_dir)
os.makedirs(frame_res_dir)
else:
os.makedirs(frame_res_dir)
if opt.input_mode == 'video':
logger.info('Starting tracking...')
data_loader = datasets.LoadVideo(opt.input_video, opt.img_size)
elif opt.input_mode == 'image_dir':
logger.info('Starting detection...')
data_loader = datasets.LoadImages(opt.input_img, opt.img_size)
elif opt.input_mode == 'img_path_list_txt':
if not os.path.isfile(opt.input_img):
print('[Err]: invalid image file path list.')
return
with open(opt.input_img, 'r', encoding='utf-8') as r_h:
logger.info('Starting detection...')
paths = [x.strip() for x in r_h.readlines()]
print('Total {:d} image files.'.format(len(paths)))
data_loader = datasets.LoadImages(path=paths,
img_size=opt.img_size)
result_file_name = os.path.join(result_root, 'results.txt')
frame_rate = data_loader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
opt.device = device
try: # 视频推断的入口函数
if opt.id_weight > 0:
eval_seq(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
mode='track')
else:
# eval_seq(opt=opt,
# data_loader=data_loader,
# data_type='mot',
# result_f_name=result_file_name,
# save_dir=frame_dir,
# show_image=False,
# frame_rate=frame_rate,
# mode='detect')
# only for tmp detection evaluation...
output_dir = '/users/duanyou/c5/results_new/results_all/mcmot_hrnet18_deconv_ep3'
eval_seq_and_output_dets(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
out_dir=output_dir,
save_dir=frame_dir,
show_image=False)
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 run_demo(opt):
"""
:param opt:
:return:
"""
result_root = opt.output_root if opt.output_root != '' else '.'
mkdir_if_missing(result_root)
# clear existing frame results
frame_res_dir = result_root + '/frame'
if os.path.isdir(frame_res_dir):
shutil.rmtree(frame_res_dir)
os.makedirs(frame_res_dir)
else:
os.makedirs(frame_res_dir)
if opt.input_mode == 'video':
if opt.id_weight > 0:
logger.info('Starting tracking...')
else:
logger.info('Starting detection...')
if not os.path.isfile(opt.input_video):
print('[Err]: invalid input video file.')
return
data_loader = datasets.LoadVideo(opt.input_video,
opt.img_size) # load video as input
f_name = os.path.split(opt.input_video)[-1][:-4]
elif opt.input_mode == 'image_dir':
logger.info('Starting detection...')
data_loader = datasets.LoadImages(opt.input_img,
opt.img_size) # load images as input
f_name = os.path.split(opt.input_video)[-1]
opt.id_weight = 0 # only do detection in this mode
elif opt.input_mode == 'img_path_list_txt':
logger.info('Starting detection...')
if not os.path.isfile(opt.input_img):
print('[Err]: invalid image file path list.')
return
opt.id_weight = 0 # only do detection in this mode
with open(opt.input_img, 'r', encoding='utf-8') as r_h:
logger.info('Starting detection...')
paths = [x.strip() for x in r_h.readlines()]
print('Total {:d} image files.'.format(len(paths)))
data_loader = datasets.LoadImages(path=paths,
img_size=opt.img_size)
result_file_name = os.path.join(result_root, 'results.txt')
frame_rate = data_loader.frame_rate
frame_dir = None if opt.output_format == 'text' else osp.join(
result_root, 'frame')
# Set device
# opt.device = device
# set device
opt.device = str(FindFreeGPU())
print('Using gpu: {:s}'.format(opt.device))
device = select_device(
device='cpu' if not torch.cuda.is_available() else opt.device)
opt.device = device
try:
if opt.input_mode == 'video':
if opt.id_weight > 0:
eval_seq(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
mode='track')
else: # input video, do detection
eval_seq(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
save_dir=frame_dir,
show_image=False,
frame_rate=frame_rate,
mode='detect')
else:
# only for tmp detection evaluation...
output_dir = '/users/duanyou/c5/results_new/results_all/tmp'
eval_imgs_output_dets(opt=opt,
data_loader=data_loader,
data_type='mot',
result_f_name=result_file_name,
out_dir=output_dir,
save_dir=frame_dir,
show_image=False)
except Exception as e:
logger.info(e)
if opt.output_format == 'video':
output_video_path = 'result.mp4'
if opt.input_mode == 'video':
if opt.id_weight > 0:
output_video_path = osp.join(result_root,
f_name + '_track.mp4')
else:
output_video_path = osp.join(result_root, f_name + '_det.mp4')
elif opt.input_mode == 'image_dir':
output_video_path = osp.join(result_root, f_name + '_det.mp4')
cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -b 5000k -c:v mpeg4 {}' \
.format(osp.join(result_root, 'frame'), output_video_path)
print(cmd_str)
os.system(cmd_str)
