Part of the way to a solution

Author: sevagh

bin/hud.py

@@ -28,12 +28,6 @@ def main():
         type=str,
         help="Override the default face/neck keypoints (default=%(default)s)",
     )
-    parser.add_argument(
-        "--minimum-bop-spacing",
-        type=float,
-        default=0.2,
-        help="Minimum spacing (in seconds) between bops to filter out implausible events (default=%(default)s)",
-    )
     parser.add_argument(
         "--bpm-frame-history",
         type=float,
@@ -152,8 +146,9 @@ def process_first_pass(*args, **kwargs):
     # get head bop locations by indexing into time array
     all_time = numpy.linspace(0, frame_duration * total_frames, int(total_frames))
 
-    peaks, strongest_peaks_index = pose_tracker.find_peaks()
-    bop_locations = all_time[peaks[strongest_peaks_index]]
+    # take top peaks only
+    peaks = pose_tracker.find_peaks()[0][1]
+    bop_locations = all_time[peaks]
 
     event_thresh = args.event_threshold_frames * frame_duration
 
@@ -191,7 +186,6 @@ def process_second_pass(get_frame_fn, frame_time):
         bop_history = bop_locations[
             numpy.where((bop_locations >= frame_min) & (bop_locations <= frame_max))
         ]
-        bop_history = bops_realistic_smoothing(bop_history, args.minimum_bop_spacing)
 
         all_beats_bpm_tmp = bpm_from_beats(all_beat_history)
         bop_bpm_tmp = bpm_from_beats(bop_history)

headbang/motion.py

@@ -1,6 +1,5 @@
 import numpy
 import sys
-import itertools
 import os
 import scipy
 from scipy.signal import find_peaks, find_peaks_cwt, peak_prominences
@@ -14,14 +13,13 @@
 
 import pyopenpose as op
 
-marker = itertools.cycle((",", "+", ".", "o", "*"))
-
 
 class OpenposeDetector:
-    # nose, neck, right eye, left eye, right ear, left ear
-    face_neck_keypoints = [0, 1, 15, 16, 17, 18]
+    # nose, right eye, left eye, right ear, left ear
+    face_neck_keypoints = [0, 15, 16, 17, 18]
     confidence_threshold = 0.5
-    peak_prominence = 0.2
+    peak_prominence = 0.05
+    obj_limit = 2
 
     def __init__(self, n_frames, custom_keypoints=None):
         config = {}
@@ -100,56 +98,52 @@ def process_frame(self, frame):
 
     def find_peaks(self):
         peaks = [
-            find_peaks(
-                numpy.nan_to_num(y_coords), prominence=OpenposeDetector.peak_prominence
-            )
+            find_peaks(y_coords, prominence=OpenposeDetector.peak_prominence)
             for y_coords in self.all_y_coords
         ]
         peaks = [p[0] for p in peaks]
 
         prominences = [
-            peak_prominences(numpy.nan_to_num(y_coords), peaks[i])
+            peak_prominences(y_coords, peaks[i])
             for i, y_coords in enumerate(self.all_y_coords)
         ]
         prominences = [p[1] for p in prominences]
 
-        strongest_peaks_index = prominences.index(max(prominences, key=sum))
+        top_ycoords_and_peaks = [
+            (ycrds, pks)
+            for _, pks, ycrds in sorted(
+                zip(prominences, peaks, self.all_y_coords),
+                key=lambda triplet: sum(triplet[0]),
+                reverse=True,
+            )
+        ]
 
-        return peaks, strongest_peaks_index
+        # only track up to obj_limit objects
+        return top_ycoords_and_peaks[: OpenposeDetector.obj_limit]
 
     def plot_ycoords(self):
-        peaks, strongest_peaks_index = self.find_peaks()
-
         plt.figure(1)
         plt.title("normalized y coordinate motion")
 
         plt.xlabel("frame")
         plt.ylabel("y coord")
 
         frames = numpy.arange(self.n_frames)
+        best_coords_and_peaks = self.find_peaks()
 
-        for i, y_coords in enumerate(self.all_y_coords):
+        for i, coordspeaks in enumerate(best_coords_and_peaks):
+            y_coords, peaks = coordspeaks
             y_coords = numpy.asarray(y_coords)
-            plt.plot(frames, y_coords, label="obj {0}".format(i))
-
-            if i == strongest_peaks_index:
-                # mark the strongest peaks in a thicker manner
-                plt.plot(
-                    peaks[i],
-                    y_coords[peaks[i]],
-                    marker=next(marker),
-                    linestyle="None",
-                    markersize=8,
-                    color="black",
-                )
-            else:
-                plt.plot(
-                    peaks[i],
-                    y_coords[peaks[i]],
-                    marker=next(marker),
-                    linestyle="None",
-                    markersize=5,
-                )
+            plt.plot(
+                frames,
+                y_coords,
+                "-D",
+                label="obj {0}".format(i),
+                markevery=peaks,
+                mec="black",
+                mfc="black",
+            )
+
         plt.legend()
         plt.show()