Merge pull request flann-lib#157 from pemmanuelviel/groupWiseCenterChooser

Add a new method for initializing KMeans centers that leads to better clusters and thus better retrieval when final centers have to be existing keypoints instead of clusters barycenters.

Author: mariusmuja

src/cpp/flann/algorithms/center_chooser.h

@@ -291,6 +291,94 @@ class KMeansppCenterChooser : public CenterChooser<Distance>
 };
 
 
+
+/**
+ * Chooses the initial centers in a way inspired by Gonzales (by Pierre-Emmanuel Viel):
+ * select the first point of the list as a candidate, then parse the points list. If another
+ * point is further than current candidate from the other centers, test if it is a good center
+ * of a local aggregation. If it is, replace current candidate by this point. And so on...
+ *
+ * Used with KMeansIndex that computes centers coordinates by averaging positions of clusters points,
+ * this doesn't make a real difference with previous methods. But used with HierarchicalClusteringIndex
+ * class that pick centers among existing points instead of computing the barycenters, there is a real
+ * improvement.
+ */
+template <typename Distance>
+class GroupWiseCenterChooser : public CenterChooser<Distance>
+{
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
+    using CenterChooser<Distance>::points_;
+    using CenterChooser<Distance>::distance_;
+    using CenterChooser<Distance>::cols_;
+
+    GroupWiseCenterChooser(const Distance& distance, const std::vector<ElementType*>& points) :
+        CenterChooser<Distance>(distance, points) {}
+
+    void operator()(int k, int* indices, int indices_length, int* centers, int& centers_length)
+    {
+        const float kSpeedUpFactor = 1.3f;
+
+        int n = indices_length;
+
+        DistanceType* closestDistSq = new DistanceType[n];
+
+        // Choose one random center and set the closestDistSq values
+        int index = rand_int(n);
+        assert(index >=0 && index < n);
+        centers[0] = indices[index];
+
+        for (int i = 0; i < n; i++) {
+            closestDistSq[i] = distance_(points_[indices[i]], points_[indices[index]], cols_);
+        }
+
+
+        // Choose each center
+        int centerCount;
+        for (centerCount = 1; centerCount < k; centerCount++) {
+
+            // Repeat several trials
+            double bestNewPot = -1;
+            int bestNewIndex = 0;
+            DistanceType furthest = 0;
+            for (index = 0; index < n; index++) {
+
+                // We will test only the potential of the points further than current candidate
+                if( closestDistSq[index] > kSpeedUpFactor * (float)furthest ) {
+
+                    // Compute the new potential
+                    double newPot = 0;
+                    for (int i = 0; i < n; i++) {
+                        newPot += std::min( distance_(points_[indices[i]], points_[indices[index]], cols_)
+                                            , closestDistSq[i] );
+                    }
+
+                    // Store the best result
+                    if ((bestNewPot < 0)||(newPot <= bestNewPot)) {
+                        bestNewPot = newPot;
+                        bestNewIndex = index;
+                        furthest = closestDistSq[index];
+                    }
+                }
+            }
+
+            // Add the appropriate center
+            centers[centerCount] = indices[bestNewIndex];
+            for (int i = 0; i < n; i++) {
+                closestDistSq[i] = std::min( distance_(points_[indices[i]], points_[indices[bestNewIndex]], cols_)
+                                             , closestDistSq[i] );
+            }
+        }
+
+        centers_length = centerCount;
+
+        delete[] closestDistSq;
+    }
+};
+
+
 }
 
 

src/cpp/flann/algorithms/hierarchical_clustering_index.h

@@ -165,6 +165,9 @@ class HierarchicalClusteringIndex : public NNIndex<Distance>
         case FLANN_CENTERS_KMEANSPP:
             chooseCenters_ = new KMeansppCenterChooser<Distance>(distance_, points_);
         	break;
+        case FLANN_CENTERS_GROUPWISE:
+            chooseCenters_ = new GroupWiseCenterChooser<Distance>(distance_, points_);
+            break;
         default:
             throw FLANNException("Unknown algorithm for choosing initial centers.");
         }

src/cpp/flann/defines.h

@@ -97,6 +97,7 @@ enum flann_centers_init_t
     FLANN_CENTERS_RANDOM = 0,
     FLANN_CENTERS_GONZALES = 1,
     FLANN_CENTERS_KMEANSPP = 2,
+    FLANN_CENTERS_GROUPWISE = 3,
 };
 
 enum flann_log_level_t