def gather(self, tracker: Tracker, sequence: Sequence):
trajectories = list()
results = self.workspace.results(tracker, self, sequence)
for i in range(1, self._repetitions + 1):
name = "%s_%03d" % (sequence.name, i)
if Trajectory.exists(results, name):
trajectories.append(Trajectory.read(results, name))
return trajectories
def subcompute(self, experiment: Experiment, tracker: Tracker,
sequence: Sequence, dependencies: List[Grid]) -> Tuple[Any]:
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
overlaps_all = []
success_all = []
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(trajectory.regions(),
proxy.groundtruth(),
proxy.size if self.burnin else None)
grace = self.grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self.threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self.grace # subtract since we need actual point of the failure
break
else:
grace = self.grace
success = True
if progress < len(overlaps):
# tracker has failed during this run
overlaps[progress:] = (len(overlaps) - progress) * [float(0)]
success = False
overlaps_all.append(overlaps)
success_all.append(success)
return compute_eao_partial(overlaps_all, success_all, self.high), 1
def execute(self, tracker: Tracker, sequence: Sequence, force: bool = False, callback: Callable = None):
results = self.results(tracker, sequence)
with self._get_runtime(tracker, sequence) as runtime:
for i in range(1, self.repetitions+1):
name = "%s_%03d" % (sequence.name, i)
if Trajectory.exists(results, name) and not force:
continue
if self._can_stop(tracker, sequence):
return
trajectory = Trajectory(sequence.length)
_, properties, elapsed = runtime.initialize(sequence.frame(0), self._get_initialization(sequence, 0))
properties["time"] = elapsed
trajectory.set(0, Special(Special.INITIALIZATION), properties)
for frame in range(1, sequence.length):
region, properties, elapsed = runtime.update(sequence.frame(frame))
properties["time"] = elapsed
trajectory.set(frame, region, properties)
trajectory.write(results, name)
if callback:
callback(i / self.repetitions)
def subcompute(self, experiment: Experiment, tracker: Tracker,
sequence: Sequence):
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if not forward and not backward:
raise RuntimeError("Sequence does not contain any anchors")
robustness = 0
accuracy = 0
total = 0
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(
trajectory.regions(), proxy.groundtruth(),
(proxy.size) if self.burnin else None)
grace = self.grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self.threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self.grace # subtract since we need actual point of the failure
break
else:
grace = self.grace
robustness += progress # simplified original equation: len(proxy) * (progress / len(proxy))
accuracy += sum(overlaps[0:progress])
total += len(proxy)
ar = (robustness / total,
accuracy / robustness if robustness > 0 else 0)
return accuracy / robustness if robustness > 0 else 0, robustness / total, ar, robustness, len(
sequence)
def compute_partial(self, tracker: Tracker, experiment: Experiment,
sequence: Sequence):
from vot.region.utils import calculate_overlaps
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
robustness = 0
accuracy = 0
total = 0
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(trajectory.regions(),
proxy.groundtruth(),
proxy.size if self._burnin else None)
grace = self._grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self._threshold:
grace = grace - 1
if grace == 0:
progress = j + 1 - self._grace # subtract since we need actual point of the failure
break
else:
grace = self._grace
robustness += progress # simplified original equation: len(proxy) * (progress / len(proxy))
accuracy += len(proxy) * (sum(overlaps[0:progress]) /
(progress - 1)) if progress > 1 else 0
total += len(proxy)
return accuracy / total, robustness / total, len(sequence)
def subcompute(self, experiment: Experiment, tracker: Tracker,
sequence: Sequence, dependencies: List[Grid]) -> Tuple[Any]:
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if not forward and not backward:
raise RuntimeError("Sequence does not contain any anchors")
accuracy = []
success = []
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(
trajectory.regions(), proxy.groundtruth(),
(proxy.size) if self.burnin else None)
grace = self.grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self.threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self.grace # subtract since we need actual point of the failure
break
else:
grace = self.grace
success.append((i / len(sequence), progress / len(proxy)))
accuracy.append(
(i / len(sequence), sum(overlaps[0:progress] / len(proxy))))
return success, accuracy
def execute(self,
tracker: Tracker,
sequence: Sequence,
force: bool = False,
callback: Callable = None):
results = self.results(tracker, sequence)
forward, backward = find_anchors(sequence, self.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
total = len(forward) + len(backward)
current = 0
with self._get_runtime(tracker, sequence) as runtime:
for i, reverse in [(f, False)
for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if Trajectory.exists(results, name) and not force:
continue
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory(proxy.length)
_, properties, elapsed = runtime.initialize(
proxy.frame(0), self._get_initialization(proxy, 0))
properties["time"] = elapsed
trajectory.set(0, Special(Special.INITIALIZATION), properties)
for frame in range(1, proxy.length):
region, properties, elapsed = runtime.update(
proxy.frame(frame))
properties["time"] = elapsed
trajectory.set(frame, region, properties)
trajectory.write(results, name)
current = current + 1
if callback:
callback(current / total)
def scan(self, tracker: Tracker, sequence: Sequence):
results = self.workspace.results(tracker, self, sequence)
files = []
complete = True
for i in range(1, self._repetitions + 1):
name = "%s_%03d" % (sequence.name, i)
if Trajectory.exists(results, name):
files.extend(Trajectory.gather(results, name))
elif self._can_stop(tracker, sequence):
break
else:
complete = False
break
return complete, files, results
def scan(self, tracker: Tracker, sequence: Sequence):
files = []
complete = True
results = self.results(tracker, sequence)
forward, backward = find_anchors(sequence, self.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
for i in forward + backward:
name = "%s_%08d" % (sequence.name, i)
if Trajectory.exists(results, name):
files.extend(Trajectory.gather(results, name))
else:
complete = False
return complete, files, results
def execute(self,
tracker: Tracker,
sequence: Sequence,
force: bool = False,
callback: Callable = None):
results = self.workspace.results(tracker, self, sequence)
for i in range(1, self._repetitions + 1):
name = "%s_%03d" % (sequence.name, i)
if Trajectory.exists(results, name) and not force:
continue
if self._can_stop(tracker, sequence):
return
trajectory = Trajectory(sequence.length)
with self._get_runtime(tracker, sequence) as runtime:
frame = 0
while frame < sequence.length:
_, properties, elapsed = runtime.initialize(
sequence.frame(frame),
self._get_initialization(sequence, frame))
properties["time"] = elapsed
trajectory.set(frame, Special(Special.INITIALIZATION),
properties)
frame = frame + 1
while frame < sequence.length:
region, properties, elapsed = runtime.update(
sequence.frame(frame))
properties["time"] = elapsed
if calculate_overlap(
region, sequence.groundtruth(frame),
sequence.size) <= self.failure_overlap:
trajectory.set(frame, Special(Special.FAILURE),
properties)
frame = frame + self.skip_initialize
if self.skip_tags:
while frame < sequence.length:
if not [
t for t in sequence.tags(frame)
if t in self.skip_tags
]:
break
frame = frame + 1
break
else:
trajectory.set(frame, region, properties)
frame = frame + 1
if callback:
callback(i / self._repetitions)
trajectory.write(results, name)
def compute_measure(self, tracker: Tracker, experiment: Experiment):
from vot.region.utils import calculate_overlaps
overlaps_all = []
weights_all = []
success_all = []
frames_total = 0
for sequence in experiment.workspace.dataset:
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
weights_per_run = []
for i, reverse in [(f, False)
for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(
trajectory.regions(), proxy.groundtruth(),
proxy.size if self._burnin else None)
grace = self._grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self._threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self._grace # subtract since we need actual point of the failure
break
else:
grace = self._grace
success = True
if progress < len(overlaps):
# tracker has failed during this run
overlaps[progress:] = (len(overlaps) -
progress) * [float(0)]
success = False
overlaps_all.append(overlaps)
success_all.append(success)
weights_per_run.append(len(proxy))
for w in weights_per_run:
weights_all.append((w / sum(weights_per_run)) * len(sequence))
frames_total += len(sequence)
weights_all = [w / frames_total for w in weights_all]
return compute_eao(overlaps_all, weights_all, success_all,
self._interval_low, self._interval_high)[0]
def subcompute(self, experiment: Experiment, tracker: Tracker,
sequence: Sequence):
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
accuracy_ = Counter()
tags_count_ = Counter()
robustness_ = 0
total_ = 0
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(trajectory.regions(),
proxy.groundtruth(),
proxy.size if self.burnin else None)
grace = self.grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self.threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self.grace # subtract since we need actual point of the failure
break
else:
grace = self.grace
for j in range(progress):
overlap = overlaps[j]
tags = proxy.tags(j)
if len(tags) == 0:
tags = ['empty']
for t in tags:
accuracy_[t] += overlap
tags_count_[t] += 1
robustness_ += progress
total_ += len(proxy)
seq_robustness = robustness_ / total_
seq_accuracy = {}
for t in accuracy_:
seq_accuracy[t] = accuracy_[t] / tags_count_[t]
# calculate weights for each attribute
attribute_counter = Counter()
for frame_idx in range(len(sequence)):
tags = sequence.tags(frame_idx)
if len(tags) == 0:
tags = ['empty']
for t in tags:
attribute_counter[t] += 1
return seq_accuracy, seq_robustness, attribute_counter
def subcompute(self, experiment: Experiment, tracker: Tracker,
sequence: Sequence):
results = experiment.results(tracker, sequence)
forward, backward = find_anchors(sequence, experiment.anchor)
if len(forward) == 0 and len(backward) == 0:
raise RuntimeError("Sequence does not contain any anchors")
tags_count = Counter()
tags_not_failed = Counter()
for i, reverse in [(f, False) for f in forward] + [(f, True)
for f in backward]:
name = "%s_%08d" % (sequence.name, i)
if not Trajectory.exists(results, name):
raise MissingResultsException()
if reverse:
proxy = FrameMapSequence(sequence,
list(reversed(range(0, i + 1))))
else:
proxy = FrameMapSequence(sequence,
list(range(i, sequence.length)))
trajectory = Trajectory.read(results, name)
overlaps = calculate_overlaps(trajectory.regions(),
proxy.groundtruth(),
proxy.size if self.burnin else None)
grace = self.grace
progress = len(proxy)
for j, overlap in enumerate(overlaps):
if overlap <= self.threshold and not proxy.groundtruth(
j).is_empty():
grace = grace - 1
if grace == 0:
progress = j + 1 - self.grace # subtract since we need actual point of the failure
break
else:
grace = self.grace
for j in range(progress):
tags = proxy.tags(j)
if len(tags) == 0:
tags = ['empty']
for t in tags:
tags_count[t] += 1
if progress == len(
proxy) or j < progress - self.fail_interval:
tags_not_failed[t] += 1
attribute_counter = Counter()
for frame_idx in range(len(sequence)):
tags = sequence.tags(frame_idx)
if len(tags) == 0:
tags = ['empty']
for t in tags:
attribute_counter[t] += 1
return tags_not_failed, tags_count, attribute_counter