def do_analysis(config, logger):
from vot.analysis import process_measures
workspace = Workspace(config.workspace)
logger.info("Loaded workspace in '%s'", config.workspace)
global_registry = [os.path.abspath(x) for x in config.registry]
registry = load_trackers(workspace.registry + global_registry,
root=config.workspace)
logger.info("Found data for %d trackers", len(registry))
if not hasattr(config, 'trackers'):
trackers = workspace.list_results()
else:
trackers = config.trackers
try:
trackers = [registry[tracker] for tracker in trackers]
except KeyError as ke:
logger.error("Tracker not found %s", str(ke))
return
if config.output == "dash":
from vot.analysis.dashboard import run_dashboard
run_dashboard(workspace, trackers)
return
elif config.output == "latex":
pass
elif config.output == "html":
pass
elif config.output == "json":
results = process_measures(workspace, trackers)
file_name = os.path.join(
workspace.directory,
"analysis_{:%Y-%m-%dT%H-%M-%S.%f%z}.json".format(datetime.now()))
with open(file_name, "w") as fp:
json.dump(results, fp, indent=2)
logger.info("Analysis successful, results available in %s", file_name)
def do_evaluate(config, logger):
from vot.experiment import run_experiment
workspace = Workspace(config.workspace)
logger.info("Loaded workspace in '%s'", config.workspace)
global_registry = [os.path.abspath(x) for x in config.registry]
registry = load_trackers(workspace.registry + global_registry,
root=config.workspace)
logger.info("Found data for %d trackers", len(registry))
try:
trackers = [registry[t.strip()] for t in config.trackers]
except KeyError as ke:
logger.error("Tracker not found: %s", str(ke))
return
if len(trackers) == 0:
logger.error("Unable to continue without at least on tracker")
logger.error("List of available found trackers: ")
for k, _ in trackers.items():
logger.error(" * %s", k)
return
try:
for tracker in trackers:
logger.info("Evaluating tracker %s", tracker.identifier)
for experiment in workspace.stack:
run_experiment(experiment, tracker, config.force,
config.persist)
logger.info("Evaluation concluded successfuly")
except KeyboardInterrupt:
logger.info("Evaluation interrupted by the user")
except TrackerException as te:
logger.error("Evaluation interrupted by tracker error: {}".format(te))
def do_test(config, logger):
from vot.dataset.dummy import DummySequence
trackers = load_trackers(config.registry)
if not config.tracker:
logger.error("Unable to continue without a tracker")
logger.error("List of available found trackers: ")
for k, _ in trackers.items():
logger.error(" * %s", k)
return
if not config.tracker in trackers:
logger.error("Tracker does not exist")
return
tracker = trackers[config.tracker]
logger.info("Generating dummy sequence")
sequence = DummySequence(50)
logger.info("Obtaining runtime for tracker %s", tracker.identifier)
if config.visualize:
import matplotlib.pylab as plt
from vot.utilities.draw import MatplotlibDrawHandle
figure = plt.figure()
figure.canvas.set_window_title('VOT Test')
axes = figure.add_subplot(1, 1, 1)
axes.set_aspect("equal")
handle = MatplotlibDrawHandle(axes, size=sequence.size)
handle.style(fill=False)
figure.show()
runtime = None
try:
runtime = tracker.runtime(log=True)
for repeat in range(1, 4):
logger.info("Initializing tracker ({}/{})".format(repeat, 3))
region, _, _ = runtime.initialize(sequence.frame(0),
sequence.groundtruth(0))
if config.visualize:
axes.clear()
handle.image(sequence.frame(0).channel())
handle.style(color="green").region(
sequence.frame(0).groundtruth())
handle.style(color="red").region(region)
figure.canvas.draw()
for i in range(1, sequence.length):
logger.info("Updating on frame %d/%d", i, sequence.length - 1)
region, _, _ = runtime.update(sequence.frame(i))
if config.visualize:
axes.clear()
handle.image(sequence.frame(i).channel())
handle.style(color="green").region(
sequence.frame(i).groundtruth())
handle.style(color="red").region(region)
figure.canvas.draw()
logger.info("Stopping tracker")
runtime.stop()
logger.info("Test concluded successfuly")
except TrackerException as te:
logger.error("Error during tracker execution: {}".format(te))
if runtime:
runtime.stop()
except KeyboardInterrupt:
if runtime:
runtime.stop()
def do_pack(config, logger):
import zipfile, io
from shutil import copyfileobj
workspace = Workspace(config.workspace)
logger.info("Loaded workspace in '%s'", config.workspace)
registry = load_trackers(workspace.registry + config.registry)
logger.info("Found data for %d trackers", len(registry))
try:
tracker = registry[config.tracker]
except KeyError as ke:
logger.error("Tracker not found %s", str(ke))
return
logger.info("Packaging results for tracker %s", tracker.identifier)
all_files = []
can_finish = True
progress = Progress(desc="Scanning",
total=len(workspace.dataset) * len(workspace.stack))
for experiment in workspace.stack:
for sequence in workspace.dataset:
transformers = experiment.workspace.stack.transformers(experiment)
for transformer in transformers:
sequence = transformer(sequence)
complete, files, results = experiment.scan(tracker, sequence)
all_files.extend([(f, experiment.identifier, sequence.name,
results) for f in files])
if not complete:
logger.error(
"Results are not complete for experiment %s, sequence %s",
experiment.identifier, sequence.name)
can_finish = False
progress.update_relative(1)
if not can_finish:
logger.error("Unable to continue, experiments not complete")
return
logger.info("Collected %d files, compressing to archive ...",
len(all_files))
archive_name = os.path.join(
workspace.directory,
"{}_{:%Y-%m-%dT%H-%M-%S.%f%z}.zip".format(tracker.identifier,
datetime.now()))
progress = Progress(desc="Compressing", total=len(all_files))
with zipfile.ZipFile(archive_name, 'w') as archive:
for f in all_files:
with io.TextIOWrapper(
archive.open(os.path.join(f[1], f[2], f[0]),
mode="w")) as fout, f[3].read(f[0]) as fin:
copyfileobj(fin, fout)
progress.update_relative(1)
logger.info("Result packaging successful, archive available in %s",
archive_name)