Generate suggestions using max point displacement threshold

sleap/config/suggestions.yaml

@@ -3,7 +3,7 @@ main:
     label: Method
     type: stacked
     default: " "
-    options: " ,image features,sample,prediction score,velocity,frame chunk"
+    options: " ,image features,sample,prediction score,velocity,frame chunk,max point displacement"
     " ":
 
     sample:
@@ -175,6 +175,12 @@ main:
         type: double
         default: 0.1
         range: 0.1,1.0
+
+    "max point displacement":
+      - name: per_video
+        label: Threshold
+        type: int
+        default: 10
 
   - name: target
     label: Target

sleap/gui/suggestions.py

@@ -61,6 +61,7 @@ def suggest(cls, params: dict, labels: "Labels" = None) -> List[SuggestionFrame]
             prediction_score=cls.prediction_score,
             velocity=cls.velocity,
             frame_chunk=cls.frame_chunk,
+            max_point_displacement=cls.max_point_displacement,
         )
 
         method = str.replace(params["method"], " ", "_")
@@ -213,6 +214,7 @@ def _prediction_score_video(
     ):
         lfs = labels.find(video)
         frames = len(lfs)
+
         # initiate an array filled with -1 to store frame index (starting from 0).
         idxs = np.full((frames), -1, dtype="int")
 
@@ -291,6 +293,86 @@ def _velocity_video(
 
         return cls.idx_list_to_frame_list(frame_idxs, video)
 
+    @classmethod
+    def max_point_displacement(
+        cls,
+        labels: "Labels",
+        videos: List[Video],
+        displacement_threshold: float,
+        **kwargs,
+    ):
+        """Finds frames with maximum point displacement above a threshold."""
+
+        proposed_suggestions = []
+        for video in videos:
+            proposed_suggestions.extend(
+                cls._max_point_displacement_video(video, labels, displacement_threshold)
+            )
+
+        suggestions = VideoFrameSuggestions.filter_unique_suggestions(
+            labels, videos, proposed_suggestions
+        )
+
+        return suggestions
+
+    @classmethod
+    def _max_point_displacement_video(
+        cls, video: Video, labels: "Labels", displacement_threshold: float
+    ):
+        # ONCE labels.numpy works: delete lfs ~322 - 328
+        lfs = labels.find(video)
+        frames = len(lfs)
+
+        if frames < 2:
+            return []
+
+
+        video_instances = labels.numpy(video=video, all_frames=True, untracked=False)
+        frames = len(video_instances)
+
+        if frames < 2:
+            return []
+
+        # ONCE labels.numpy works: delete print statements ~336 - 340
+        print('type of video_instances: ', type(video_instances))
+        print(video_instances[0])
+        print('type of video_instances[0]: ', type(video_instances[0]))
+        print(f"Number of elements returned by labels.numpy(): {video_instances.shape}")
+        print(f"Number of elements returned by labels.numpy(): {len(video_instances)}")
+
+
+        print('type of video_instances: ', type(video_instances))
+        print('type of video_instances[0]: ', type(video_instances[0]))
+
+
+        displacements = []
+        for idx in range(1, frames):
+            prev_points = video_instances[idx-1]
+            curr_points = video_instances[idx]
+
+
+            if prev_points.shape != curr_points.shape:
+                continue
+
+            # Mask to identify non-nan values
+            valid_mask = ~np.isnan(prev_points) & ~np.isnan(curr_points)
+            # Filter out nan values
+            valid_prev_points = prev_points[valid_mask].reshape(-1, 2)
+            valid_curr_points = curr_points[valid_mask].reshape(-1, 2)
+
+            if valid_prev_points.size == 0 or valid_curr_points.size == 0:
+                continue
+
+            displacement = np.linalg.norm(valid_curr_points - valid_prev_points, axis=1).sum()
+            displacements.append((displacement, idx))
+
+        frame_idxs = [
+            frame_idx for displacement, frame_idx in displacements if displacement > displacement_threshold
+        ]
+
+        return cls.idx_list_to_frame_list(frame_idxs, video)
+
+
     @classmethod
     def frame_chunk(
         cls,

tests/gui/test_suggestions.py

@@ -23,6 +23,19 @@ def test_velocity_suggestions(centered_pair_predictions):
     assert suggestions[0].frame_idx == 21
     assert suggestions[1].frame_idx == 45
 
+# something like this?
+def test_max_point_displacement_suggestions(centered_pair_predictions):
+    suggestions = VideoFrameSuggestions.suggest(
+        labels=centered_pair_predictions,
+        params=dict(
+            videos=centered_pair_predictions.videos,
+            method="max_point_displacement",
+            displacement_threshold = 300
+        ),
+    )
+    assert len(suggestions) == 6
+    assert suggestions[0].frame_idx == 2117
+    assert suggestions[1].frame_idx == 4937
 
 def test_frame_increment(centered_pair_predictions: Labels):
     # Testing videos that have less frames than desired Samples per Video (stride)