Added flag for minimal group size.

spt/interface.cpp

@@ -4,9 +4,9 @@
 // =================================================================================================
 // =================================================================================================
 
-Triangulator::Triangulator(float min_score)
+Triangulator::Triangulator(float min_score, size_t min_group_size)
 {
-    this->triangulator = new TriangulatorInternal(min_score);
+    this->triangulator = new TriangulatorInternal(min_score, min_group_size);
 }
 
 // =================================================================================================

spt/interface.hpp

@@ -20,9 +20,11 @@ public:
      *
      *
      * @param min_score Minimum score to consider a triangulated joint as valid.
+     * @param min_group_size Minimum number of camera pairs that need to see a person.
      */
     Triangulator(
-        float min_score = 0.95);
+        float min_score = 0.95,
+        size_t min_group_size = 1);
 
     /**
      * Calculate a triangulation.

spt/triangulator.cpp

@@ -102,9 +102,10 @@ void CameraInternal::update_projection_matrix()
 // =================================================================================================
 // =================================================================================================
 
-TriangulatorInternal::TriangulatorInternal(float min_score)
+TriangulatorInternal::TriangulatorInternal(float min_score, size_t min_group_size)
 {
     this->min_score = min_score;
+    this->min_group_size = min_group_size;
 }
 
 // =================================================================================================
@@ -443,20 +444,13 @@ std::vector<std::vector<std::array<float, 4>>> TriangulatorInternal::triangulate
     stime = std::chrono::high_resolution_clock::now();
 
     // Drop low scoring poses
-    std::vector<size_t> drop_indices;
-    for (size_t i = 0; i < all_scored_poses.size(); ++i)
+    size_t num_poses = all_scored_poses.size();
+    for (size_t i = num_poses; i > 0; --i)
     {
-        if (all_scored_poses[i].second < min_score)
+        if (all_scored_poses[i - 1].second < min_score)
         {
-            drop_indices.push_back(i);
-        }
-    }
-    if (!drop_indices.empty())
-    {
-        for (size_t i = drop_indices.size(); i > 0; --i)
-        {
-            all_scored_poses.erase(all_scored_poses.begin() + drop_indices[i - 1]);
-            all_pairs.erase(all_pairs.begin() + drop_indices[i - 1]);
+            all_scored_poses.erase(all_scored_poses.begin() + i - 1);
+            all_pairs.erase(all_pairs.begin() + i - 1);
         }
     }
 
@@ -464,6 +458,16 @@ std::vector<std::vector<std::array<float, 4>>> TriangulatorInternal::triangulate
     std::vector<std::tuple<cv::Point3d, cv::Mat, std::vector<int>>> groups;
     groups = calc_grouping(all_pairs, all_scored_poses, min_score);
 
+    // Drop groups with too few matches
+    size_t num_groups = groups.size();
+    for (size_t i = num_groups; i > 0; --i)
+    {
+        if (std::get<2>(groups[i - 1]).size() < this->min_group_size)
+        {
+            groups.erase(groups.begin() + i - 1);
+        }
+    }
+
     elapsed = std::chrono::high_resolution_clock::now() - stime;
     grouping_time += elapsed.count();
     stime = std::chrono::high_resolution_clock::now();

spt/triangulator.hpp

@@ -31,7 +31,7 @@ public:
 class TriangulatorInternal
 {
 public:
-    TriangulatorInternal(float min_score);
+    TriangulatorInternal(float min_score, size_t min_group_size);
 
     std::vector<std::vector<std::array<float, 4>>> triangulate_poses(
         const std::vector<std::vector<std::vector<std::array<float, 3>>>> &poses_2d,
@@ -44,6 +44,8 @@ public:
 
 private:
     float min_score;
+    float min_group_size;
+
     const std::vector<std::string> core_joints = {
         "shoulder_left",
         "shoulder_right",