def test_multivideo_tracks():
vid_a = Video.from_filename("foo.mp4")
vid_b = Video.from_filename("bar.mp4")
skeleton = Skeleton.load_json("tests/data/skeleton/fly_skeleton_legs.json")
track_a = Track(spawned_on=2, name="A")
track_b = Track(spawned_on=3, name="B")
inst_a = Instance(track=track_a, skeleton=skeleton)
inst_b = Instance(track=track_b, skeleton=skeleton)
lf_a = LabeledFrame(vid_a, frame_idx=2, instances=[inst_a])
lf_b = LabeledFrame(vid_b, frame_idx=3, instances=[inst_b])
labels = Labels(labeled_frames=[lf_a, lf_b])
# Try setting video B instance to track used in video A
labels.track_swap(vid_b, new_track=track_a, old_track=track_b, frame_range=(3, 4))
assert inst_b.track == track_a
def test_labels_merge():
dummy_video = Video(backend=MediaVideo)
dummy_skeleton = Skeleton()
dummy_skeleton.add_node("node")
labels = Labels()
dummy_frames = []
# Add 10 instances with different points (so they aren't "redundant")
for i in range(10):
instance = Instance(skeleton=dummy_skeleton, points=dict(node=Point(i, i)))
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[instance])
dummy_frames.append(dummy_frame)
labels.labeled_frames.extend(dummy_frames)
assert len(labels) == 10
assert len(labels.labeled_frames[0].instances) == 1
labels.merge_matching_frames()
assert len(labels) == 1
assert len(labels.labeled_frames[0].instances) == 10
def test_labels_append_hdf5(multi_skel_vid_labels, tmpdir):
labels = multi_skel_vid_labels
filename = os.path.join(tmpdir, "test.h5")
# Save each frame of the Labels dataset one by one in append
# mode
for label in labels:
# Just do the first 20 to speed things up
if label.frame_idx > 20:
break
Labels.save_hdf5(filename=filename,
labels=Labels([label]),
append=True)
# Now load the dataset and make sure we get the same thing we started
# with.
loaded_labels = Labels.load_hdf5(filename=filename)
_check_labels_match(labels, loaded_labels)
def test_remove_predictions_with_new_labels(removal_test_labels):
labels = removal_test_labels
assert len(labels) == 3
new_labels = Labels(
[
LabeledFrame(
video=labels.video,
frame_idx=1,
instances=[PredictedInstance(skeleton=labels.skeleton)],
)
]
)
labels.remove_predictions(new_labels=new_labels)
assert len(labels) == 2
assert labels[0].frame_idx == 0
assert labels[0].has_user_instances
assert not labels[0].has_predicted_instances
assert labels[1].frame_idx == 2
assert labels[1].has_user_instances
assert labels[1].has_predicted_instances
def test_save_labels_with_images(min_labels_slp, tmpdir):
labels = Labels(min_labels_slp.labeled_frames)
labels.append(LabeledFrame(video=labels.video, frame_idx=1))
labels.suggestions.append(SuggestionFrame(video=labels.video, frame_idx=2))
fn = os.path.join(tmpdir, "test_user_only.slp")
labels.save(
fn,
with_images=True,
embed_all_labeled=False,
embed_suggested=False,
)
assert Labels.load_file(fn).video.embedded_frame_inds == [0]
fn = os.path.join(tmpdir, "test_all_labeled.slp")
labels.save(
fn,
with_images=True,
embed_all_labeled=True,
embed_suggested=False,
)
assert Labels.load_file(fn).video.embedded_frame_inds == [0, 1]
fn = os.path.join(tmpdir, "test_suggested.slp")
labels.save(
fn,
with_images=True,
embed_all_labeled=False,
embed_suggested=True,
)
assert Labels.load_file(fn).video.embedded_frame_inds == [0, 2]
fn = os.path.join(tmpdir, "test_all.slp")
labels.save(
fn,
with_images=True,
embed_all_labeled=True,
embed_suggested=True,
)
assert Labels.load_file(fn).video.embedded_frame_inds == [0, 1, 2]
def test_unify_skeletons():
vid = Video.from_filename("foo.mp4")
skeleton_a = Skeleton.load_json(
"tests/data/skeleton/fly_skeleton_legs.json")
skeleton_b = Skeleton.load_json(
"tests/data/skeleton/fly_skeleton_legs.json")
lf_a = LabeledFrame(vid, frame_idx=2, instances=[Instance(skeleton_a)])
lf_b = LabeledFrame(vid, frame_idx=3, instances=[Instance(skeleton_b)])
labels = Labels()
labels.extend_from([lf_a], unify=True)
labels.extend_from([lf_b], unify=True)
ids = skeleton_ids_from_label_instances(labels)
# Make sure that skeleton_b got replaced with skeleton_a when we
# added the frame with "unify" set
assert len(set(ids)) == 1
# Make sure we can serialize this
labels.to_dict()
def test_deserialize_suggestions(small_robot_mp4_vid, tmpdir):
dummy_video = small_robot_mp4_vid
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
suggestions = VideoFrameSuggestions.suggest(
labels=labels, params=dict(method="sample", per_video=13)
)
labels.set_suggestions(suggestions)
filename = os.path.join(tmpdir, "new_suggestions.h5")
Labels.save_file(filename=filename, labels=labels)
new_suggestion_labels = Labels.load_file(filename)
assert len(suggestions) == len(new_suggestion_labels.suggestions)
assert [frame.frame_idx for frame in suggestions] == [
frame.frame_idx for frame in new_suggestion_labels.suggestions
]
def __init__(self, labels_path: Optional[str] = None, *args, **kwargs):
"""Initialize the app.
Args:
labels_path: Path to saved :class:`Labels` dataset.
Returns:
None.
"""
super(MainWindow, self).__init__(*args, **kwargs)
self.state = GuiState()
self.labels = Labels()
self.commands = CommandContext(state=self.state,
app=self,
update_callback=self.on_data_update)
self._menu_actions = dict()
self._buttons = dict()
self._child_windows = dict()
self.overlays = dict()
self.state.connect("filename", self.setWindowTitle)
self.state["skeleton"] = Skeleton()
self.state["labeled_frame"] = None
self.state["filename"] = None
self.state["show labels"] = True
self.state["show edges"] = True
self.state["edge style"] = "Line"
self.state["fit"] = False
self.state["color predicted"] = prefs["color predicted"]
self._initialize_gui()
if labels_path:
self.loadProjectFile(labels_path)
def test_load_file(tmpdir):
labels = Labels()
filename = os.path.join(tmpdir, "test.h5")
labels.add_video(Video.from_filename("small_robot.mp4"))
Labels.save_hdf5(filename=filename, labels=labels)
# Fix video path from full path
labels = load_file(filename,
search_paths="tests/data/videos/small_robot.mp4")
assert Path(
labels.video.filename).samefile("tests/data/videos/small_robot.mp4")
# No auto-detect
labels = load_file(filename, detect_videos=False)
assert labels.video.filename == "small_robot.mp4"
# Fix video path by searching in the labels folder
tmpvid = tmpdir.join("small_robot.mp4")
tmpvid.write("") # dummy file
assert load_file(filename).video.filename == tmpvid
assert load_file(filename,
search_paths=str(tmpdir)).video.filename == tmpvid
assert load_file(filename,
search_paths=str(tmpvid)).video.filename == tmpvid
def test_makedirs(tmpdir):
labels = Labels()
filename = os.path.join(tmpdir, "new/dirs/test.h5")
Labels.save_file(filename=filename, labels=labels)
def test_complex_merge():
dummy_video_a = Video.from_filename("foo.mp4")
dummy_video_b = Video.from_filename("foo.mp4")
dummy_skeleton_a = Skeleton()
dummy_skeleton_a.add_node("node")
dummy_skeleton_b = Skeleton()
dummy_skeleton_b.add_node("node")
dummy_instances_a = []
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(1, 1))))
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(2, 2))))
labels_a = Labels()
labels_a.append(
LabeledFrame(dummy_video_a, frame_idx=0, instances=dummy_instances_a))
dummy_instances_b = []
dummy_instances_b.append(
Instance(skeleton=dummy_skeleton_b, points=dict(node=Point(1, 1))))
dummy_instances_b.append(
Instance(skeleton=dummy_skeleton_b, points=dict(node=Point(3, 3))))
labels_b = Labels()
labels_b.append(
LabeledFrame(dummy_video_b, frame_idx=0,
instances=dummy_instances_b)) # conflict
labels_b.append(
LabeledFrame(dummy_video_b, frame_idx=1,
instances=dummy_instances_b)) # clean
merged, extra_a, extra_b = Labels.complex_merge_between(labels_a, labels_b)
# Check that we have the cleanly merged frame
assert dummy_video_a in merged
assert len(merged[dummy_video_a]) == 1 # one merged frame
assert len(merged[dummy_video_a][1]) == 2 # with two instances
# Check that labels_a includes redundant and clean
assert len(labels_a.labeled_frames) == 2
assert len(labels_a.labeled_frames[0].instances) == 1
assert labels_a.labeled_frames[0].instances[0].points[0].x == 1
assert len(labels_a.labeled_frames[1].instances) == 2
assert labels_a.labeled_frames[1].instances[0].points[0].x == 1
assert labels_a.labeled_frames[1].instances[1].points[0].x == 3
# Check that extra_a/b includes the appropriate conflicting instance
assert len(extra_a) == 1
assert len(extra_b) == 1
assert len(extra_a[0].instances) == 1
assert len(extra_b[0].instances) == 1
assert extra_a[0].instances[0].points[0].x == 2
assert extra_b[0].instances[0].points[0].x == 3
# Check that objects were unified
assert extra_a[0].video == extra_b[0].video
# Check resolving the conflict using new
Labels.finish_complex_merge(labels_a, extra_b)
assert len(labels_a.labeled_frames) == 2
assert len(labels_a.labeled_frames[0].instances) == 2
assert labels_a.labeled_frames[0].instances[1].points[0].x == 3
def test_label_mutability():
dummy_video = Video(backend=MediaVideo)
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video,
frame_idx=0,
instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
assert dummy_video in labels.videos
assert dummy_video in labels
assert dummy_skeleton in labels.skeletons
assert dummy_skeleton in labels
assert dummy_frame in labels.labeled_frames
assert dummy_frame in labels
assert (dummy_video, 0) in labels
assert (dummy_video, 1) not in labels
dummy_video2 = Video(backend=MediaVideo)
dummy_skeleton2 = Skeleton(name="dummy2")
dummy_instance2 = Instance(dummy_skeleton2)
dummy_frame2 = LabeledFrame(dummy_video2,
frame_idx=0,
instances=[dummy_instance2])
assert dummy_video2 not in labels
assert dummy_skeleton2 not in labels
assert dummy_frame2 not in labels
labels.append(dummy_frame2)
assert dummy_video2 in labels
assert dummy_frame2 in labels
labels.remove_video(dummy_video2)
assert dummy_video2 not in labels
assert dummy_frame2 not in labels
assert len(labels.find(dummy_video2)) == 0
assert len(labels) == 1
labels.append(LabeledFrame(dummy_video, frame_idx=0))
assert len(labels) == 1
dummy_frames = [LabeledFrame(dummy_video, frame_idx=i) for i in range(10)]
dummy_frames2 = [
LabeledFrame(dummy_video2, frame_idx=i) for i in range(10)
]
for f in dummy_frames + dummy_frames2:
labels.append(f)
assert len(labels) == 20
labels.remove_video(dummy_video2)
assert len(labels) == 10
assert len(labels.find(dummy_video)) == 10
assert dummy_frame in labels
assert all([label in labels for label in dummy_frames[1:]])
assert dummy_video2 not in labels
assert len(labels.find(dummy_video2)) == 0
assert all([label not in labels for label in dummy_frames2])
labels.remove_video(dummy_video)
assert len(labels.find(dummy_video)) == 0
