def run_vot2020_LT(tracker_name,
tracker_param,
run_id=None,
gpu_id=0,
debug=0,
visdom_info=None):
if gpu_id is not None:
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
tracker = Tracker(tracker_name, tracker_param, run_id)
name = 'vot'
DatasetInfo = namedtuple('DatasetInfo', ['module', 'class_name', 'kwargs'])
pt = "pytracking.evaluation.%sdataset" # Useful abbreviations to reduce the clutter
dataset_dict = dict(vot=DatasetInfo(
module=pt % "vot", class_name="VOTDataset", kwargs=dict()))
dset_info = dataset_dict.get(name)
if dset_info is None:
raise ValueError('Unknown dataset \'%s\'' % name)
m = importlib.import_module(dset_info.module)
dataset = getattr(m, dset_info.class_name)(**dset_info.kwargs)
dataset_path = dataset.base_path
print(dataset_path)
if 'sequences' in dataset_path:
dataset_path_all = dataset_path.split('/')
final_path = ''
for x in dataset_path_all:
if x != 'sequences':
final_path = os.path.join(final_path, x)
final_path = '/' + final_path
else:
final_path = dataset_path
tracker.run_vot2020_LT(debug, visdom_info, final_path)
def run_sequence(seq: Sequence, tracker: Tracker, debug=False):
"""Runs a tracker on a sequence."""
base_results_path = '{}/{}'.format(tracker.results_dir, seq.name)
results_path = '{}.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name, tracker.parameter_name, tracker.run_id, seq.name))
if debug:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
else:
try:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
except Exception as e:
print(e)
return
tracked_bb = np.array(tracked_bb).astype(float)
exec_times = np.array(exec_times).astype(float)
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
if not debug:
np.savetxt(results_path, tracked_bb, delimiter=',', fmt='%f')
np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
def __init__(self, rf_model_code, enable_rf=True):
_tracker_name, _tracker_param, model_name = self._get_setting()
model_name = model_name.format(rf_model_code)
if not enable_rf:
model_name = model_name.replace(RF_type.format(rf_model_code), '')
super(Pytracking_RF, self).__init__(name=model_name)
self.enable_rf = enable_rf
# create tracker
tracker_info = Tracker(_tracker_name, _tracker_param, None)
params = tracker_info.get_parameters()
params.visualization = False
params.debug = False
params.visdom_info = {
'use_visdom': False,
'server': '127.0.0.1',
'port': 8097
}
self.tracker = tracker_info.tracker_class(params)
# create Refinement module
if self.enable_rf:
self.RF_module = RefineModule(refine_path.format(rf_model_code),
selector_path,
search_factor=sr,
input_sz=input_sz)
def uav_test():
# Run ATOM and ECO on the UAV dataset
trackers = [Tracker('atom', 'default', i) for i in range(1)] + \
[Tracker('eco', 'default', i) for i in range(1)]
dataset = UAVDataset()
return trackers, dataset
def run_sequence(seq: Sequence,
tracker: Tracker,
debug=False,
visdom_info=None):
"""Runs a tracker on a sequence."""
visdom_info = {} if visdom_info is None else visdom_info
base_results_path = '{}/{}'.format(tracker.results_dir, seq.name)
results_path = '{}.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, seq.name))
if debug:
output = tracker.run(seq, debug=debug, visdom_info=visdom_info)
else:
try:
output = tracker.run(seq, debug=debug, visdom_info=visdom_info)
except Exception as e:
print(e)
return
tracked_bb = np.array(output['target_bbox']).astype(int)
exec_times = np.array(output['time']).astype(float)
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
if not debug:
np.savetxt(results_path, tracked_bb, delimiter='\t', fmt='%d')
np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
def __init__(self,
tracker_name='dimp',
para_name='dimp50_vot19',
refine_model_name='ARcm_coco_seg',
threshold=0.15):
self.THRES = threshold
'''create tracker'''
'''DIMP'''
tracker_info = Tracker(tracker_name, para_name, None)
params = tracker_info.get_parameters()
params.visualization = False
params.debug = False
params.visdom_info = {
'use_visdom': False,
'server': '127.0.0.1',
'port': 8097
}
self.dimp = tracker_info.tracker_class(params)
'''Alpha-Refine'''
project_path = os.path.join(os.path.dirname(__file__), '..', '..')
refine_root = os.path.join(project_path,
'ltr/checkpoints/ltr/ARcm_seg/')
refine_path = os.path.join(refine_root, refine_model_name)
'''2020.4.25 input size: 384x384'''
self.alpha = ARcm_seg(refine_path, input_sz=384)
def all():
# Run ATOM and ECO on the MobiFace dataset
trackers = [Tracker('atom', 'default', i) for i in range(1)] + \
[Tracker('eco', 'default', i) for i in range(1)]
dataset = MobifaceDatasetAll()
return trackers, dataset
def run_sequence(seq: Sequence, tracker: Tracker, debug=False):
"""Runs a tracker on a sequence."""
base_results_path = '{}/baseline/{}'.format(tracker.results_dir, seq.name)
results_path = '{}.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, seq.name))
if debug:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
else:
try:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
except Exception as e:
print(e)
return
path = base_results_path.split('/')
path = path[-1]
if not isdir(base_results_path): makedirs(base_results_path)
results_path = join(base_results_path, '{:s}_001.txt').format(path)
#'{}.txt'.format(base_results_path)
with open(results_path, "w") as fin:
for x in tracked_bb:
fin.write("{:d}\n".format(x)) if isinstance(x, int) else \
fin.write(','.join([vot_float2str("%.4f", i) for i in x]) + '\n')
# tracked_bb = np.array(tracked_bb).astype(int)
exec_times = np.array(exec_times).astype(float)
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
def run_tracker_pytracking(frame_path, sequence_path, tracking_results_path,
sequence_ID, overwrite):
# frames_path = os.path.join(
# args.path, args.YT_ID + '_' + str(args.ID), "frames")
frame_list = [
frame for frame in os.listdir(frame_path) if frame.endswith(".png")
]
frame_list.sort(key=lambda f: int(f[:-4]))
frames_list = [os.path.join(frame_path, frame) for frame in frame_list]
anno_path = os.path.join(sequence_path, "initial_BB.txt")
ground_truth_rect = np.loadtxt(str(anno_path),
delimiter=',',
dtype=np.float64).reshape(-1, 4)
my_yt_sequence = Sequence(sequence_ID, frames_list, ground_truth_rect)
#Result folder
os.makedirs(tracking_results_path, exist_ok=True)
for my_trackers in tqdm(['atom', 'eco']):
# for my_trackers in tqdm(['atom']):
my_tracker = Tracker(f"{my_trackers}", "default")
#Path of the Result folder
my_tracker.results_dir = os.path.join(tracking_results_path,
my_trackers)
os.makedirs(my_tracker.results_dir, exist_ok=True)
run_sequence(my_yt_sequence, my_tracker)
def run_vot2020(tracker_name,
tracker_param,
run_id=None,
debug=None,
visdom_info=None):
tracker = Tracker(tracker_name, tracker_param, run_id)
tracker.run_vot2020(debug, visdom_info)
def run_sequence(seq: Sequence,
tracker: Tracker,
debug=False,
visdom_info=None,
noise=False,
noise_mag=None):
"""Runs a tracker on a sequence."""
def _results_exist():
if seq.object_ids is None:
bbox_file = '{}/{}.txt'.format(tracker.results_dir, seq.name)
return os.path.isfile(bbox_file)
else:
bbox_files = [
'{}/{}_{}.txt'.format(tracker.results_dir, seq.name, obj_id)
for obj_id in seq.object_ids
]
missing = [not os.path.isfile(f) for f in bbox_files]
return sum(missing) == 0
visdom_info = {} if visdom_info is None else visdom_info
if _results_exist() and not debug:
print('FPS: {}'.format(-1))
return
print('Tracker: {} {} {} , Sequence: {}, Using noise: {} with mag {}'.
format(tracker.name, tracker.parameter_name, tracker.run_id,
seq.name, noise, noise_mag))
if debug:
output = tracker.run_sequence(seq,
debug=debug,
visdom_info=visdom_info,
noise=noise,
noise_mag=noise_mag)
else:
# try:
output = tracker.run_sequence(seq,
debug=debug,
visdom_info=visdom_info,
noise=noise,
noise_mag=noise_mag)
# except Exception as e:
# print(e)
# return
sys.stdout.flush()
if isinstance(output['time'][0], (dict, OrderedDict)):
exec_time = sum([sum(times.values()) for times in output['time']])
num_frames = len(output['time'])
else:
exec_time = sum(output['time'])
num_frames = len(output['time'])
print('FPS: {}'.format(num_frames / exec_time))
if not debug:
_save_tracker_output(seq, tracker, output)
def __init__(self, tracker_name='dimp', para_name='super_dimp', threshold=0.65):
self.THRES = threshold
'''create tracker'''
tracker_info = Tracker(tracker_name, para_name, None)
params = tracker_info.get_parameters()
params.visualization = False
params.debug = False
params.visdom_info = {'use_visdom': False, 'server': '127.0.0.1', 'port': 8097}
self.base_tracker = tracker_info.tracker_class(params)
def run_webcam(tracker_name, tracker_param, debug=None):
"""Run the tracker on your webcam.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
debug: Debug level.
"""
tracker = Tracker(tracker_name, tracker_param)
tracker.run_webcam(debug)
def run_video(tracker_name, tracker_param, videofile, optional_box=None, debug=None, save_results=False):
"""Run the tracker on your webcam.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
debug: Debug level.
"""
tracker = Tracker(tracker_name, tracker_param)
tracker.run_video(videofilepath=videofile, optional_box=optional_box, debug=debug, save_results=save_results)
def run_sequence(seq: Sequence,
tracker: Tracker,
debug=False,
visdom_info=None):
"""Runs a tracker on a sequence."""
def _results_exist():
if not tracker.if_rt:
bbox_file = '{}/{}.txt'.format(tracker.results_dir, seq.name)
else:
bbox_file = '{}/{}.pkl'.format(tracker.results_dir_rt, seq.name)
return os.path.isfile(bbox_file)
visdom_info = {} if visdom_info is None else visdom_info
if _results_exist() and not debug:
print('FPS: {}'.format(-1))
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, seq.name))
if debug:
output = tracker.run_sequence(seq,
debug=debug,
visdom_info=visdom_info)
else:
try:
output = tracker.run_sequence(seq,
debug=debug,
visdom_info=visdom_info)
except Exception as e:
print(e)
return
sys.stdout.flush()
if not tracker.if_rt:
if isinstance(output['time'][0], (dict, OrderedDict)):
exec_time = sum([sum(times.values()) for times in output['time']])
num_frames = len(output['time'])
else:
exec_time = sum(output['time'])
num_frames = len(output['time'])
else:
if isinstance(output['runtime'][0], (dict, OrderedDict)):
exec_time = sum(
[sum(times.values()) for times in output['runtime']])
num_frames = len(output['runtime'])
else:
exec_time = sum(output['runtime'])
num_frames = len(output['runtime'])
print('FPS: {}'.format(num_frames / exec_time))
if not debug:
_save_tracker_output(seq, tracker, output)
def run_webcam(tracker_name, tracker_param, debug=None, visdom_info=None):
"""Run the tracker on your webcam.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
debug: Debug level.
visdom_info: Dict optionally containing 'use_visdom', 'server' and 'port' for Visdom visualization.
"""
visdom_info = {} if visdom_info is None else visdom_info
tracker = Tracker(tracker_name, tracker_param)
tracker.run_webcam(debug, visdom_info)
def local_init(self, image, init_bbox):
local_tracker = Tracker('segm', 'default_params')
params = local_tracker.get_parameters()
debug_ = getattr(params, 'debug', 0)
params.debug = debug_
params.tracker_name = local_tracker.name
params.param_name = local_tracker.parameter_name
self.local_Tracker = local_tracker.tracker_class(params)
self.local_Tracker.initialize(image, init_bbox)
def local_init(self, image, init_bbox):
local_tracker = Tracker('dimp', 'dimp50')
params = local_tracker.get_parameters()
debug_ = getattr(params, 'debug', 0)
params.debug = debug_
params.tracker_name = local_tracker.name
params.param_name = local_tracker.parameter_name
self.local_Tracker = local_tracker.tracker_class(params)
init_box = dict()
init_box['init_bbox'] = init_bbox
self.local_Tracker.initialize(image, init_box)
def run_tracker(tracker_name,
tracker_param,
run_id=None,
dataset_name='otb',
sequence=None,
debug=0,
threads=0,
visdom_info=None):
"""Run tracker on sequence or dataset.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
run_id: The run id.
dataset_name: Name of dataset (otb, nfs, uav, tpl, vot, tn, gott, gotv, lasot).
sequence: Sequence number or name.
debug: Debug level.
threads: Number of threads.
visdom_info: Dict optionally containing 'use_visdom', 'server' and 'port' for Visdom visualization.
"""
visdom_info = {} if visdom_info is None else visdom_info
dataset = get_dataset(dataset_name)
if sequence is not None:
dataset = [dataset[sequence]]
trackers = [Tracker(tracker_name, tracker_param, run_id)]
run_dataset(dataset, trackers, debug, threads, visdom_info=visdom_info)
def run_vot(tracker_name,
tracker_param,
run_id=None,
debug=0,
visdom_info=None):
# initSeed = 1
# torch.manual_seed(initSeed)
# torch.cuda.manual_seed(initSeed)
# torch.cuda.manual_seed_all(initSeed)
# np.random.seed(initSeed)
# torch.backends.cudnn.benchmark = False
# torch.backends.cudnn.deterministic = True
# os.environ['PYTHONHASHSEED'] = str(initSeed)
tracker = Tracker(tracker_name, tracker_param, run_id)
tracker.run_vot(debug, visdom_info)
def run_sequence_vot(seq: Sequence, tracker: Tracker, debug=False):
"""Runs a tracker on a sequence."""
base_results_path = '{}/{}/{}/{}'.format(tracker.results_dir, 'baseline',
seq.name, seq.name)
results_path = '{}_001.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if not os.path.exists('{}/{}'.format(tracker.results_dir, 'baseline')):
os.mkdir('{}/{}'.format(tracker.results_dir, 'baseline'))
if not os.path.exists('{}/{}/{}'.format(tracker.results_dir, 'baseline',
seq.name)):
os.mkdir('{}/{}/{}'.format(tracker.results_dir, 'baseline', seq.name))
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, seq.name))
if debug:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
else:
try:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
except Exception as e:
print(e)
return
#tracked_bb = np.array(tracked_bb).astype(int)
exec_times = np.array(exec_times).astype(float)
with open(results_path, "w") as fin:
for x in tracked_bb:
if isinstance(x, int):
fin.write("{:d}\n".format(x))
else:
p_bbox = x.copy()
fin.write(','.join([str(i) for i in x]) + '\n')
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
if not debug:
#np.savetxt(results_path, tracked_bb, delimiter='\t', fmt='%d')
np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
def run_tracker(tracker_name, tracker_param, run_id=None, dataset_name='otb', sequence=None, debug=0, threads=0):
"""Run tracker on sequence or dataset."""
dataset = LaSOTDataset()
if sequence is not None:
dataset = [dataset[sequence]]
trackers = [Tracker(tracker_name, tracker_param, run_id)]
run_dataset(dataset, trackers, dataset_name,debug, threads)
def run_sequence(seq: Sequence, tracker: Tracker, debug=False):
"""Runs a tracker on a sequence."""
base_results_path = '{}/{}'.format(tracker.results_dir, 'baseline')
if not os.path.isdir(base_results_path):
os.makedirs(base_results_path)
base_results_path = '{}/{}'.format(base_results_path, seq.name)
results_path = '{}.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, seq.name))
if debug:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
else:
try:
tracked_bb, exec_times = tracker.run(seq, debug=debug)
except Exception as e:
print(e)
return
# tracked_bb = np.array(tracked_bb).astype(int)
exec_times = np.array(exec_times).astype(float)
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
# if not debug:
# np.savetxt(results_path, tracked_bb, delimiter='\t', fmt='%d')
# np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
video_path = base_results_path
if not os.path.isdir(video_path):
os.makedirs(video_path)
result_path = os.path.join(video_path, '{}_001.txt'.format(seq.name))
with open(result_path, 'w') as f:
for x in tracked_bb:
if isinstance(x, int):
f.write("{:d}\n".format(x))
else:
f.write(','.join([vot_float2str("%.4f", i) for i in x]) + '\n')
def run_sequence(seq: Sequence, tracker: Tracker,dataset_name, debug=False):
"""Runs a tracker on a sequence."""
print(dataset_name)
if (dataset_name=="vot"):
file_dir= os.path.join(tracker.results_dir,"baseline",seq.name)
mkdir(file_dir)
else:
file_dir=tracker.results_dir
base_results_path = '{}/{}'.format(file_dir, seq.name)
results_path = '{}_001.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
print(results_path)
print(os.path.isfile(results_path))
if os.path.isfile(results_path) and not debug:
return
print('Tracker: {} {} {} , Sequence: {}'.format(tracker.name, tracker.parameter_name, tracker.run_id, seq.name))
print(tracker)
if debug:
tracked_bb, exec_times = tracker.run(seq,debug=debug)
else:
try:
tracked_bb, exec_times = tracker.run(seq,debug=debug)
except Exception as e:
print(e)
return
tracked_bb = np.array(tracked_bb).astype(int)
exec_times = np.array(exec_times).astype(float)
torch.cuda.empty_cache()
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
#input()
if not debug:
if (dataset_name=="vot"):
np.savetxt(results_path, tracked_bb, delimiter=',', fmt='%d')
np.savetxt(times_path, exec_times, delimiter=',', fmt='%f')
else:
np.savetxt(results_path, tracked_bb, delimiter='\t', fmt='%d')
np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
def run_tracker(tracker_name,
tracker_param,
run_id=None,
dataset_name='otb',
sequence=None,
debug=0,
threads=0,
visdom_info=None):
"""Run tracker on sequence or dataset.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
run_id: The run id.
dataset_name: Name of dataset (otb, nfs, uav, tpl, vot, tn, gott, gotv, lasot).
sequence: Sequence number or name.
debug: Debug level.
threads: Number of threads.
visdom_info: Dict optionally containing 'use_visdom', 'server' and 'port' for Visdom visualization.
"""
visdom_info = {} if visdom_info is None else visdom_info
if dataset_name == 'otb':
dataset = OTBDataset()
elif dataset_name == 'nfs':
dataset = NFSDataset()
elif dataset_name == 'uav':
dataset = UAVDataset()
elif dataset_name == 'tpl':
dataset = TPLDataset()
elif dataset_name == 'tplnootb':
dataset = TPLDatasetNoOtb()
elif dataset_name == 'vot':
dataset = VOTDataset()
elif dataset_name == 'tn':
dataset = TrackingNetDataset()
elif dataset_name == 'gott':
dataset = GOT10KDatasetTest()
elif dataset_name == 'gotv':
dataset = GOT10KDatasetVal()
elif dataset_name == 'gotlv':
dataset = GOT10KDatasetLTRVal()
elif dataset_name == 'lasot':
dataset = LaSOTDataset()
else:
raise ValueError('Unknown dataset name')
if sequence is not None:
dataset = [dataset[sequence]]
trackers = [Tracker(tracker_name, tracker_param, run_id)]
run_dataset(dataset, trackers, debug, threads, visdom_info=visdom_info)
def run_tracker(tracker_name,
tracker_param,
run_id=None,
dataset_name='otb',
sequence=None,
debug=0,
threads=0):
"""Run tracker on sequence or dataset.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
run_id: The run id.
dataset_name: Name of dataset (otb, nfs, uav, tpl, vot, tn, gott, gotv, lasot).
sequence: Sequence number or name.
debug: Debug level.
threads: Number of threads.
"""
if dataset_name == 'otb':
dataset = OTBDataset()
elif dataset_name == 'nfs':
dataset = NFSDataset()
elif dataset_name == 'uav':
dataset = UAVDataset()
elif dataset_name == 'tpl':
dataset = TPLDataset()
elif dataset_name == 'vot':
dataset = VOTDataset()
elif dataset_name == 'vot18':
dataset = VOT18Dataset()
elif dataset_name == 'otb_vot':
dataset = OTB100Dataset()
elif dataset_name == 'tn':
dataset = TrackingNetDataset()
elif dataset_name == 'gott':
dataset = GOT10KDatasetTest()
elif dataset_name == 'gotv':
dataset = GOT10KDatasetVal()
elif dataset_name == 'gotlv':
dataset = GOT10KDatasetLTRVal()
elif dataset_name == 'lasot':
dataset = LaSOTDataset()
else:
raise ValueError('Unknown dataset name')
if sequence is not None:
dataset = [dataset[sequence]]
trackers = [Tracker(tracker_name, tracker_param, run_id)]
run_dataset(dataset, trackers, debug, threads)
def run_survey(tracker_name,
tracker_param,
run_id=None,
vidpath=None,
debug=0,
threads=0):
"""Run tracker on sequence or dataset.
args:
tracker_name: Name of tracking method.
tracker_param: Name of parameter file.
run_id: The run id.
dataset_name: Name of dataset (otb, nfs, uav, tpl, vot, tn, gott, gotv, lasot).
sequence: Sequence number or name.
debug: Debug level.
threads: Number of threads.
"""
trackers = [Tracker(tracker_name, tracker_param, run_id)]
run_stream(vidpath, trackers, debug, threads)
def run_all_videos(tracker_name,
tracker_param,
videofile,
detections,
output_dir,
optional_box=None,
debug=None,
save_results=False):
csv = pd.read_csv(detections)
tracker = Tracker(tracker_name, tracker_param)
files = glob(os.path.join(videofile, "*.mp4"))
for f in tqdm(files, total=len(files), desc="Processing video"):
run_video(tracker,
tracker_param,
f,
csv,
output_dir,
optional_box=None,
debug=None,
save_results=False)
def run_sequence(seq: Sequence, tracker: Tracker, debug=False):
"""Runs a tracker on a sequence."""
def _results_exist():
if seq.object_ids is None:
bbox_file = '{}/{}.txt'.format(tracker.results_dir, seq.name)
return os.path.isfile(bbox_file)
else:
bbox_files = [
'{}/{}_{}.txt'.format(tracker.results_dir, seq.name, obj_id)
for obj_id in seq.object_ids
]
missing = [not os.path.isfile(f) for f in bbox_files]
return sum(missing) == 0
if _results_exist() and not debug:
logging.warning("results exist in not debug mode")
return
logging.info('Sequence: {}'.format(seq.name))
try:
# focus 核心入口，此时的tracker只是一个 pytracking.evaluation.Tracker
output = tracker.run_sequence(seq, debug=debug)
except Exception as e:
print(e)
return
sys.stdout.flush()
# 计算用时
if isinstance(output['time'][0], (dict, OrderedDict)):
exec_time = sum([sum(times.values()) for times in output['time']])
num_frames = len(output['time'])
else:
exec_time = sum(output['time'])
num_frames = len(output['time'])
logging.info('FPS: {}'.format(num_frames / exec_time))
if not debug:
_save_tracker_output(seq, tracker, output)
def run_stream(path, tracker: Tracker, debug=False, threads=0):
if threads == 0:
mode = 'sequential'
else:
mode = 'parallel'
base_results_path = '{}/{}'.format(tracker.results_dir, path)
results_path = '{}.txt'.format(base_results_path)
times_path = '{}_time.txt'.format(base_results_path)
if os.path.isfile(results_path) and not debug:
return
# Run detection and tracking online / nonstop
if mode == 'sequential':
print('Tracker: {} {} {} , Source: {}'.format(tracker.name,
tracker.parameter_name,
tracker.run_id, path))
try:
bboxes, exec_times = tracker.run_vidseq(path, debug=debug)
except Exception as e:
print(e)
return
elif mode == 'parallel':
param_list = [(seq, tracker_info, debug)
for seq, tracker_info in product(dataset, trackers)]
with multiprocessing.Pool(processes=threads) as pool:
pool.starmap(run_sequence, param_list)
bboxes = np.array(bboxes).astype(float)
exec_times = np.array(exec_times).astype(float)
print('FPS: {}'.format(len(exec_times) / exec_times.sum()))
if not debug:
np.savetxt(results_path, bboxes, delimiter=',', fmt='%f')
np.savetxt(times_path, exec_times, delimiter='\t', fmt='%f')
print('Done')
