Greedy assignment for person tracking. (#767)

* Skeleton for abstract base class Tracker

* Creating updateTracks() which cleans up track store based on track age. Also, updating property names to be mixed case instead of using underscores

* Basic formatting updates.

* Adding lowerCamelCase for all variables and a couple more formatting updates

* Creating tracker_utils.ts to validate tracker config.

* Making computeSimilarity() abstract to allow for batch implementations. Also fixing some comments and validation checks

* Updating flow so that tracks are filtered by age prior to assignment with new detections

* Updating the documentation for maxTracks to indicate that this should be set higher than maxPoses

* Moving track filtering before the computation of similarity matrices

* Implementing assignTracks(), which is a greedy assigner.

* Merge remote-tracking branch 'upstream/master' into tracker, and add new tracking changes.

* Fixing linting issues.

* Updating assignTracks so that unmatched detections are kept track of

Author: ronnyvotel

pose-detection/src/calculators/interfaces/config_interfaces.ts

@@ -81,4 +81,6 @@ export interface TrackerConfig {
                    // like to recover people that are not detected for long
                    // stretches of time (at the cost of potential false
                    // re-identifications).
+  minSimilarity: number;  // New poses will only be linked with tracks if the
+                          // similarity score exceeds this threshold.
 }

pose-detection/src/calculators/tracker.ts

@@ -29,11 +29,15 @@ export abstract class Tracker {
   private tracks: Track[];
   private readonly maxTracks: number;
   private readonly maxAge: number;
+  private readonly minSimilarity: number;
+  private nextID: number;
 
   constructor(config: TrackerConfig) {
     validateTrackerConfig(config);
     this.maxTracks = config.maxTracks;
     this.maxAge = config.maxAge;
+    this.minSimilarity = config.minSimilarity;
+    this.nextID = 1;
   }
 
   /**
@@ -72,17 +76,60 @@ export abstract class Tracker {
   }
 
   /**
-   * Performs an optimization to link detections with tracks. The `poses`
+   * Performs a greedy optimization to link detections with tracks. The `poses`
    * array is updated in place by providing an `id` property. If incoming 
    * detections are not linked with existing tracks, new tracks will be created.
-   * @param poses An array of detected `Pose's.
+   * @param poses An array of detected `Pose's. It's assumed that poses are
+   * sorted from most confident to least confident.
    * @param simMatrix A 2D array of shape [num_det, num_tracks] with pairwise
    * similarity scores between detections and tracks.
    * @param timestamp The current timestamp in milliseconds.
    */
   assignTracks(
       poses: Pose[], simMatrix: number[][], timestamp: number): void {
-    //TODO: Implement optimization and track store mechanics.
+    const unmatchedTrackIndices = Array.from(Array(simMatrix[0].length).keys());
+    const detectionIndices = Array.from(Array(poses.length).keys());
+    const unmatchedDetectionIndices: number[] = [];
+
+    for (const detectionIndex of detectionIndices) {
+      if (unmatchedTrackIndices.length === 0) {
+        break;
+      }
+
+      // Assign the detection to the track which produces the highest pairwise
+      // similarity score, assuming the score exceeds the minimum similarity
+      // threshold.
+      let maxTrackIndex = -1;
+      let maxSimilarity = -1;
+      for (const trackIndex of unmatchedTrackIndices) {
+        const similarity = simMatrix[detectionIndex][trackIndex];
+        if (similarity >= this.minSimilarity && similarity > maxSimilarity) {
+          maxTrackIndex = trackIndex;
+          maxSimilarity = similarity;
+        }
+      }
+      if (maxTrackIndex >= 0) {
+        // Link the detection with the highest scoring track.
+        this.tracks[maxTrackIndex].lastTimestamp = timestamp;
+        this.tracks[maxTrackIndex].keypoints = (
+          poses[detectionIndex].keypoints.slice());
+        const index = unmatchedTrackIndices.indexOf(maxTrackIndex);
+        unmatchedTrackIndices.splice(index, 1);
+      } else {
+        unmatchedDetectionIndices.push(detectionIndex);
+      }
+    }
+
+    // Spawn new tracks for all unmatched detections.
+    for (const detectionIndex of unmatchedDetectionIndices) {
+      const newID = this.nextTrackID();
+      const newTrack: Track = {
+        id: newID,
+        lastTimestamp: timestamp,
+        keypoints: poses[detectionIndex].keypoints.slice()
+      };
+      this.tracks.push(newTrack);
+    }
   }
 
   /**
@@ -102,6 +149,15 @@ export abstract class Tracker {
     this.tracks = this.tracks.slice(0, this.maxTracks);
   }
 
+  /**
+   * Returns the next free track ID. 
+   */
+  nextTrackID() {
+    const nextID = this.nextID;
+    this.nextID += 1;
+    return nextID;
+  }
+
   /**
    * Removes specific tracks, based on their ids.
    */