From 123ca7e1c5547650f9501965b87c35d92127cf88 Mon Sep 17 00:00:00 2001
From: Takahiro Poly Horikawa <horikawa.takahiro@gmail.com>
Date: Thu, 27 Nov 2014 16:29:05 +0900
Subject: [PATCH 1/3] Parallize building kmeans index in flann

---
 .../include/opencv2/flann/kmeans_index.h      | 85 +++++++++++++++----
 1 file changed, 67 insertions(+), 18 deletions(-)

diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h
index bfc9b91453..1655ac6a11 100644
--- a/modules/flann/include/opencv2/flann/kmeans_index.h
+++ b/modules/flann/include/opencv2/flann/kmeans_index.h
@@ -69,7 +69,6 @@ struct KMeansIndexParams : public IndexParams
     }
 };
 
-
 /**
  * Hierarchical kmeans index
  *
@@ -271,6 +270,68 @@ public:
         return FLANN_INDEX_KMEANS;
     }
 
+    class KMeansDistanceComputer : public cv::ParallelLoopBody
+    {
+    public:
+        KMeansDistanceComputer(Distance _distance, const Matrix<ElementType>& _dataset,
+            const int _branching, const int* _indices, const Matrix<double>& _dcenters, const int _veclen,
+            int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool* _updated)
+            : distance(_distance)
+            , dataset(_dataset)
+            , branching(_branching)
+            , indices(_indices)
+            , dcenters(_dcenters)
+            , veclen(_veclen)
+            , count(_count)
+            , belongs_to(_belongs_to)
+            , radiuses(_radiuses)
+            , updated(_updated)
+        {
+        }
+
+        void operator()(const cv::Range& range) const
+        {
+            const int begin = range.start;
+            const int end = range.end;
+
+            for( int i = begin; i<end; ++i)
+            {
+                DistanceType sq_dist = distance(dataset[indices[i]], dcenters[0], veclen);
+                int new_centroid = 0;
+                for (int j=1; j<branching; ++j) {
+                    DistanceType new_sq_dist = distance(dataset[indices[i]], dcenters[j], veclen);
+                    if (sq_dist>new_sq_dist) {
+                        new_centroid = j;
+                        sq_dist = new_sq_dist;
+                    }
+                }
+                if (sq_dist > radiuses[new_centroid]) {
+                    radiuses[new_centroid] = sq_dist;
+                }
+                if (new_centroid != belongs_to[i]) {
+                    count[belongs_to[i]]--;
+                    count[new_centroid]++;
+                    belongs_to[i] = new_centroid;
+                    updated[i] = true;
+                } else {
+                    updated[i] = false;
+                }
+            }
+        }
+
+    private:
+        Distance distance;
+        const Matrix<ElementType>& dataset;
+        const int branching;
+        const int* indices;
+        const Matrix<double>& dcenters;
+        int veclen;
+        int* count;
+        int* belongs_to;
+        std::vector<DistanceType>& radiuses;
+        bool* updated;
+    };
+
     /**
      * Index constructor
      *
@@ -708,6 +769,7 @@ private:
 
         bool converged = false;
         int iteration = 0;
+        bool* updated = new bool[indices_length];
         while (!converged && iteration<iterations_) {
             converged = true;
             iteration++;
@@ -732,25 +794,11 @@ private:
             }
 
             // reassign points to clusters
+            parallel_for_(cv::Range(0, indices_length), KMeansDistanceComputer(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, updated));
             for (int i=0; i<indices_length; ++i) {
-                DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
-                int new_centroid = 0;
-                for (int j=1; j<branching; ++j) {
-                    DistanceType new_sq_dist = distance_(dataset_[indices[i]], dcenters[j], veclen_);
-                    if (sq_dist>new_sq_dist) {
-                        new_centroid = j;
-                        sq_dist = new_sq_dist;
-                    }
-                }
-                if (sq_dist>radiuses[new_centroid]) {
-                    radiuses[new_centroid] = sq_dist;
-                }
-                if (new_centroid != belongs_to[i]) {
-                    count[belongs_to[i]]--;
-                    count[new_centroid]++;
-                    belongs_to[i] = new_centroid;
-
+                if (updated[i]) {
                     converged = false;
+                    break;
                 }
             }
 
@@ -828,6 +876,7 @@ private:
         delete[] centers;
         delete[] count;
         delete[] belongs_to;
+        delete[] updated;
     }
 
 

From 180e54d09d13e90df722f5e0b821323d726f1380 Mon Sep 17 00:00:00 2001
From: Takahiro Poly Horikawa <horikawa.takahiro@gmail.com>
Date: Fri, 28 Nov 2014 18:39:49 +0900
Subject: [PATCH 2/3] - Use cv::Mutex to safely update converged flag - Use
 cv::AutoBuffer rather than new allocation - Fix "assignment operator could
 not be generated" warning

---
 .../include/opencv2/flann/kmeans_index.h      | 48 ++++++++-----------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h
index 1655ac6a11..e0ee9618bc 100644
--- a/modules/flann/include/opencv2/flann/kmeans_index.h
+++ b/modules/flann/include/opencv2/flann/kmeans_index.h
@@ -69,6 +69,7 @@ struct KMeansIndexParams : public IndexParams
     }
 };
 
+
 /**
  * Hierarchical kmeans index
  *
@@ -275,7 +276,7 @@ public:
     public:
         KMeansDistanceComputer(Distance _distance, const Matrix<ElementType>& _dataset,
             const int _branching, const int* _indices, const Matrix<double>& _dcenters, const int _veclen,
-            int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool* _updated)
+            int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool& _converged, cv::Mutex& _mtx)
             : distance(_distance)
             , dataset(_dataset)
             , branching(_branching)
@@ -285,7 +286,8 @@ public:
             , count(_count)
             , belongs_to(_belongs_to)
             , radiuses(_radiuses)
-            , updated(_updated)
+            , converged(_converged)
+            , mtx(_mtx)
         {
         }
 
@@ -312,9 +314,9 @@ public:
                     count[belongs_to[i]]--;
                     count[new_centroid]++;
                     belongs_to[i] = new_centroid;
-                    updated[i] = true;
-                } else {
-                    updated[i] = false;
+                    mtx.lock();
+                    converged = false;
+                    mtx.unlock();
                 }
             }
         }
@@ -322,14 +324,15 @@ public:
     private:
         Distance distance;
         const Matrix<ElementType>& dataset;
-        const int branching;
+        int branching;
         const int* indices;
         const Matrix<double>& dcenters;
         int veclen;
         int* count;
         int* belongs_to;
         std::vector<DistanceType>& radiuses;
-        bool* updated;
+        bool& converged;
+        cv::Mutex& mtx;
     };
 
     /**
@@ -719,7 +722,8 @@ private:
             return;
         }
 
-        int* centers_idx = new int[branching];
+        cv::AutoBuffer<int> centers_idx_buf(branching);
+        int* centers_idx = (int*)centers_idx_buf;
         int centers_length;
         (this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length);
 
@@ -727,29 +731,30 @@ private:
             node->indices = indices;
             std::sort(node->indices,node->indices+indices_length);
             node->childs = NULL;
-            delete [] centers_idx;
             return;
         }
 
 
-        Matrix<double> dcenters(new double[branching*veclen_],branching,veclen_);
+        cv::AutoBuffer<double> dcenters_buf(branching*veclen_);
+        Matrix<double> dcenters((double*)dcenters_buf,branching,veclen_);
         for (int i=0; i<centers_length; ++i) {
             ElementType* vec = dataset_[centers_idx[i]];
             for (size_t k=0; k<veclen_; ++k) {
                 dcenters[i][k] = double(vec[k]);
             }
         }
-        delete[] centers_idx;
 
         std::vector<DistanceType> radiuses(branching);
-        int* count = new int[branching];
+        cv::AutoBuffer<int> count_buf(branching);
+        int* count = (int*)count_buf;
         for (int i=0; i<branching; ++i) {
             radiuses[i] = 0;
             count[i] = 0;
         }
 
         //	assign points to clusters
-        int* belongs_to = new int[indices_length];
+        cv::AutoBuffer<int> belongs_to_buf(indices_length);
+        int* belongs_to = (int*)belongs_to_buf;
         for (int i=0; i<indices_length; ++i) {
 
             DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
@@ -769,7 +774,6 @@ private:
 
         bool converged = false;
         int iteration = 0;
-        bool* updated = new bool[indices_length];
         while (!converged && iteration<iterations_) {
             converged = true;
             iteration++;
@@ -794,13 +798,9 @@ private:
             }
 
             // reassign points to clusters
-            parallel_for_(cv::Range(0, indices_length), KMeansDistanceComputer(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, updated));
-            for (int i=0; i<indices_length; ++i) {
-                if (updated[i]) {
-                    converged = false;
-                    break;
-                }
-            }
+            cv::Mutex mtx;
+            KMeansDistanceComputer invoker(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, converged, mtx);
+            parallel_for_(cv::Range(0, (int)indices_length), invoker);
 
             for (int i=0; i<branching; ++i) {
                 // if one cluster converges to an empty cluster,
@@ -871,12 +871,6 @@ private:
             computeClustering(node->childs[c],indices+start, end-start, branching, level+1);
             start=end;
         }
-
-        delete[] dcenters.data;
-        delete[] centers;
-        delete[] count;
-        delete[] belongs_to;
-        delete[] updated;
     }
 
 

From 553bb7956e4d85fd8978d49913f3fb5b8a4cc566 Mon Sep 17 00:00:00 2001
From: Takahiro Poly Horikawa <horikawa.takahiro@gmail.com>
Date: Fri, 28 Nov 2014 19:33:52 +0900
Subject: [PATCH 3/3] Fix "assignment operator could not be generated" warnings

---
 modules/flann/include/opencv2/flann/kmeans_index.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h
index e0ee9618bc..b49b8ddded 100644
--- a/modules/flann/include/opencv2/flann/kmeans_index.h
+++ b/modules/flann/include/opencv2/flann/kmeans_index.h
@@ -275,7 +275,7 @@ public:
     {
     public:
         KMeansDistanceComputer(Distance _distance, const Matrix<ElementType>& _dataset,
-            const int _branching, const int* _indices, const Matrix<double>& _dcenters, const int _veclen,
+            const int _branching, const int* _indices, const Matrix<double>& _dcenters, const size_t _veclen,
             int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool& _converged, cv::Mutex& _mtx)
             : distance(_distance)
             , dataset(_dataset)
@@ -324,15 +324,16 @@ public:
     private:
         Distance distance;
         const Matrix<ElementType>& dataset;
-        int branching;
+        const int branching;
         const int* indices;
         const Matrix<double>& dcenters;
-        int veclen;
+        const size_t veclen;
         int* count;
         int* belongs_to;
         std::vector<DistanceType>& radiuses;
         bool& converged;
         cv::Mutex& mtx;
+        KMeansDistanceComputer& operator=( const KMeansDistanceComputer & ) { return *this; }
     };
 
     /**