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 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 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
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 extract_feature(img_cv):
global features
features = []
img_pil = Image.fromarray(img_cv)
im = transform(img_pil)[None, :, :, :]
model(im.cuda())
return features[0]
tracks = np.load(args.tracks_file)
ftracks = []
dataloader = datasets.LoadVideo(args.video, size)
for frame_id, _, img0 in dataloader:
print(frame_id)
for bbx_id, (x, y, h, w, visibility) in enumerate(tracks[:, frame_id, :]):
if (x < -10000):
continue
bbx_xyhw = np.array([x, y, h, w])
bbx_xyxy = xywh2xyxy(bbx_xyhw)
bbx_xyxy_clipped = clip_to_size_xyxy(bbx_xyxy, size)
img_bbx = img0[bbx_xyxy_clipped[1]:bbx_xyxy_clipped[3],
bbx_xyxy_clipped[0]:bbx_xyxy_clipped[2]]
f = extract_feature(img_bbx)
f = f / np.linalg.norm(f)
ftracks.append([frame_id, bbx_id, bbx_xyxy_clipped, f, 1, visibility])
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.DEBUG)
result_root = os.path.join(".", '..', 'results', exp_name)
mkdir_if_missing(result_root)
data_type = 'mot'
# Read config
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# run tracking
accs = []
n_frame = 0
timer_avgs, timer_calls = [], []
for seq in seqs:
output_dir = os.path.join(".", '..', 'outputs', exp_name,
seq) if save_images or save_videos else None
logger.info('start seq: {}'.format(seq))
dataloader = datasets.LoadVideo(
"/mnt/fileserver/shared/datasets/cameras/Odessa/Duke_on_the_left/set004_2020-02-11/fragment1.mp4"
)
dataloader = datasets.LoadVideo(
"/mnt/fileserver/shared/datasets/cameras/Odessa/Duke_on_the_left/fragments/child/child_set005_00:16:20-00:20:00.mp4"
)
# 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="./vidos",
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='/media/dh/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'
# Read config
cfg_dict = parse_model_cfg(opt.cfg)
opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])]
# 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)
print(osp.join(data_root, seq))
dataloader = datasets.LoadVideo(osp.join(data_root, seq))
# print ("DATALOADER", dataloader.vw)
result_filename = os.path.join(result_root, '{}.csv'.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
nf, ta, tc = eval_seq(opt,
dataloader,
data_type,
result_filename,
save_dir=output_dir,
show_image=show_image,
frame_rate=frame_rate,
vw=dataloader.vw)
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))
key = curr_item.replace('-', '')
if key not in params: params[key] = "1"
elif "--" in curr_item and "--" not in next_item:
key = curr_item.replace('-', '')
if key not in params: params[key] = next_item
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
cfg_dict = parse_model_cfg(path=command_args.cfg)
command_args.img_size = [int(cfg_dict[0]["width"]), int(cfg_dict[0]["height"])]
timer = Timer()
logger.info('Starting tracking...')
dataloader = datasets.LoadVideo(command_args.input_video, command_args.img_size)
frame_rate = dataloader.frame_rate
orig_width = dataloader.vw
orig_height = dataloader.vh
width = dataloader.w
height = dataloader.h
video_writer = cv2.VideoWriter(os.path.join(command_args.output_dir, os.path.splitext(os.path.basename(command_args.input_video))[0] + ".mp4"),
cv2.VideoWriter_fourcc(*"mp4v"), float(frame_rate), (orig_width, orig_height))
tracker = JDETracker(opt=command_args, frame_rate=frame_rate)
video_info = {}
frame_id = 0
for path, img, img0, orig_img in dataloader:
frame_info = {}
