updates

Author: Hepic

Makefile

@@ -1,7 +1,7 @@
 CC = g++
 FLAGS = -g -Wall
 OUT = run
-OBJS = main.o file_functions.o curve.o help_functions.o cluster.o distances.o  binary_mean_tree.o
+OBJS = main.o file_functions.o curve.o help_functions.o cluster.o distances.o binary_mean_tree.o hash_functions.o hashtable.o list.o
 
 run: $(OBJS)
 	$(CC) $(FLAGS) $^ -o $(OUT)

cluster.cpp

@@ -24,21 +24,19 @@ vector<int> k_random_selection(int len, int k) {
     return pick_random_points;
 }
 
-void k_means_pp(vector<int> &centroids_ind, vector<const Curve*> &centroids, int len, int k, const char *dist_func) {
+void k_means_pp(vector<const Curve*> &centroids, int len, int k, const char *dist_func) {
     vector<double> min_distance(len, -1);
     vector<bool> is_centroid(len, false);
     int pos;
     double max_sum = 0;
 
-    centroids_ind.reserve(k);
     centroids.reserve(k);
 
     for (int t = 0; ; ++t) {
         if (!t) {
             pos = rand() % len;
 
             is_centroid[pos] = true; 
-            centroids_ind.push_back(pos);
             centroids.push_back(&input_curves[pos]);
         }
 
@@ -51,7 +49,7 @@ void k_means_pp(vector<int> &centroids_ind, vector<const Curve*> &centroids, int
                 continue;
             }
 
-            double dist = compute_distance(i, pos, dist_func);
+            double dist = compute_distance(input_curves[i], input_curves[pos], dist_func);
 
             if (min_distance[i] == -1 || dist < min_distance[i]) {
                 if (min_distance[i] != -1) {
@@ -80,15 +78,14 @@ void k_means_pp(vector<int> &centroids_ind, vector<const Curve*> &centroids, int
         }
 
         is_centroid[pos] = true;
-        centroids_ind.push_back(pos);
         centroids.push_back(&input_curves[pos]);
 
         max_sum -= min_distance[pos] * min_distance[pos];
     }
 }
 
-double loyd_assignment(const vector<int> &centroids, vector<int> &assign, vector<double> &close_dist, vector<double> &close_dist_sec, vector<vector<int> > &clusters, char *metric) {
-    double min_dist, min_dist_sec, dist, value = 0;
+double loyd_assignment(const vector<const Curve*> &centroids, vector<vector<int> > &clusters) {
+    double min_dist, dist, value = 0;
     int p_centr;
 
     for (int i = 0; i < (int)clusters.size(); ++i) {
@@ -99,67 +96,104 @@ double loyd_assignment(const vector<int> &centroids, vector<int> &assign, vector
         min_dist = -1;
 
         for (int j = 0; j < (int)centroids.size(); ++j) {
-            dist = compute_distance(i, centroids[j], metric);
+            dist = compute_distance(input_curves[i], *centroids[j], "DFT");
 
             if (min_dist == -1 || dist < min_dist) {
-                min_dist_sec = min_dist;
                 min_dist = dist;
                 p_centr = j;
-            } else if (min_dist_sec == -1 || dist < min_dist_sec) {
-                min_dist_sec = dist;
             }
         }
-
+        
         clusters[p_centr].push_back(i);
-        assign[i] = centroids[p_centr];
-
-        close_dist[i] = min_dist;
-        close_dist_sec[i] = min_dist_sec;
-
         value += min_dist;
     }
 
     return value;
 }
 
-double loyd_assignment(const vector<const Curve*> &centroids, vector<vector<int> > &clusters) {
-    double min_dist, dist, value = 0;
-    int p_centr;
+vector<int> range_search(const vector<HashTable> &hashtables, const vector<Curve> &centroids, int dim, int L, int k, double delta) {
+    vector<int> assignment((int)input_curves.size(), -1);
+    vector<set<Curve> > R_closest_curves((int)centroids.size());
+    vector<bool> grid_curves_found((int)centroids.size(), false), visited((int)input_curves.size(), false);
+    double minim = -1;
 
-    for (int i = 0; i < (int)clusters.size(); ++i) {
-        clusters[i].clear();
+    for (int i = 0; i < (int)centroids.size(); ++i) {
+        centroids[i].print_curve();
+
+        for (int j = i + 1; j < (int)centroids.size(); ++j) {
+            double dist = compute_distance(centroids[i], centroids[j], "DFT");
+            
+            if (minim == -1 || dist < minim) {
+                minim = dist;
+            }
+        }
     }
 
-    for (int i = 0; i < (int)input_curves.size(); ++i) {
-        min_dist = -1;
+    double R = minim / 2.0;
+    cout << "R = " << R << endl;
+    
+    while (1) {
+        general_search(hashtables, L, delta, k, R, "classic", "DFT", R_closest_curves, centroids, grid_curves_found, visited);
+        bool found = false;
+
+        for (int i = 0; i < (int)R_closest_curves.size(); ++i) {
+            for (set<Curve>::const_iterator itr = R_closest_curves[i].begin(); itr != R_closest_curves[i].end(); ++itr) {
+                int id = itr->get_int_id();
+                
+                itr->print_curve();
+
+                if (assignment[id] == -1) {
+                    assignment[id] = i;
+                    found = true;
+                } else {
+                    int dist_1 = compute_distance(*itr, centroids[i], "DFT");
+                    int dist_2 = compute_distance(*itr, centroids[assignment[id]], "DFT"); 
+                    
+                    if (dist_1 < dist_2) {
+                        assignment[id] = i;
+                        found = true;
+                    }
+                }
+            }
+        }
 
-        for (int j = 0; j < (int)centroids.size(); ++j) {
-            dist = discrete_frechet_distance(input_curves[i], *centroids[j]);
+        if (!found) {
+            break;
+        }
 
-            if (min_dist == -1 || dist < min_dist) {
-                min_dist = dist;
-                p_centr = j;
+        R *= 2;
+    }
+    
+    // assignment for long points
+    for (int i = 0; i < (int)assignment.size(); ++i) {
+        if (assignment[i] == -1) {
+            double minim = -1;
+            
+            for (int j = 0; j < (int)centroids.size(); ++j) {
+                double dist = compute_distance(input_curves[i], centroids[j], "DFT");
+                
+                if (minim == -1 || dist < minim) {
+                    minim = dist;
+                    assignment[i] = j;
+                }
             }
         }
-
-        clusters[p_centr].push_back(i);
-        value += min_dist;
     }
-
-    return value;
+    
+    return assignment;
 }
 
-double swap_update_centroid(int old_centr, int new_centr, const vector<int> &assign, const vector<double> &close_dist, const vector<double> &close_dist_sec, char *metric) {
+double swap_update_centroid(const vector<const Curve*> &centroids, int old_centr, int new_centr, const vector<int> &assign, const vector<double> &close_dist, const vector<double> &close_dist_sec) {
     double value = 0;
 
     for (int i = 0; i < (int)assign.size(); ++i) {
-        if ((i != old_centr && (assign[i] == i)) || i == new_centr) {
+        if ((i != old_centr && (centroids[assign[i]]->get_int_id() == i)) || i == new_centr) {
             continue;
         }
 
-        double dist = compute_distance(i, new_centr, metric);
+        double dist = compute_distance(input_curves[i], input_curves[new_centr], "DFT");
 
-        if (assign[i] != old_centr) {
+        if (centroids[assign[i]]->get_int_id() != old_centr) {
             value += min(dist, close_dist[i]);
         } else {
             value += min(dist, close_dist_sec[i]);
@@ -169,25 +203,45 @@ double swap_update_centroid(int old_centr, int new_centr, const vector<int> &ass
     return value;
 }
 
-bool PAM_update(vector<int> &centroids, const vector<int> &assign, const vector<double> &close_dist, const vector<double> &close_dist_sec, double value, const vector<int> &cluster, int p_clust, char *metric) {
+bool PAM_update(vector<const Curve*> &centroids, double value, const vector<vector<int> > &clusters) { 
+    vector<double> close_dist((int)input_curves.size(), -1), close_dist_sec((int)input_curves.size(), -1);
+    vector<int> assign((int)input_curves.size());
+
     double min_value = value; 
-    int new_cent = -1;
+    int p_new_cent, p_clust;
 
-    for (int i = 0; i < (int)cluster.size(); ++i) {
-        if (cluster[i] == centroids[p_clust]) {
-            continue;
+    for (int i = 0; i < (int)input_curves.size(); ++i) {
+        for (int j = 0; j < (int)centroids.size(); ++j) {
+            double dist = compute_distance(input_curves[i], *centroids[j], "DFT");
+
+            if (close_dist[i] == -1 || dist < close_dist[i]) {
+                close_dist_sec[i] = close_dist[i];
+                close_dist[i] = dist;
+                assign[i] = j;
+            } else if (close_dist_sec[i] == -1 || close_dist_sec[i] < dist) {
+                close_dist_sec[i] = dist;
+            }
         }
-        
-        double new_value = swap_update_centroid(centroids[p_clust], cluster[i], assign, close_dist, close_dist_sec, metric);
+    }
+    
+    for (int i = 0; i < (int)clusters.size(); ++i) {
+        for (int j = 0; j < (int)clusters[i].size(); ++j) {
+            if (clusters[i][j] == centroids[i]->get_int_id()) {
+                continue;
+            }
+            
+            double new_value = swap_update_centroid(centroids, centroids[i]->get_int_id(), clusters[i][j], assign, close_dist, close_dist_sec); 
 
-        if (new_value < min_value) {
-            min_value = new_value;
-            new_cent = cluster[i];
+            if (new_value < min_value) {
+                min_value = new_value;
+                p_new_cent = clusters[i][j];
+                p_clust = i;
+            }
         }
     }
-
+    
     if (value > min_value) {
-        centroids[p_clust] = new_cent;
+        centroids[p_clust] = &input_curves[p_new_cent];
         return true;
     }
 
@@ -202,34 +256,31 @@ bool mean_frechet_update(vector<const Curve*> &centroids, const vector<vector<in
         const Curve *mean_curve = tree.get_mean();
 
         if (!centroids[i]->equal_curves(*mean_curve)) {
-            centroids[i] = mean_curve; 
+            centroids[i] = mean_curve;
             check = true;    
         }
     }
 
     return check;
 }
 
-void clustering(char *metric) {
+void clustering(const vector<HashTable> &hashtables, int L, int k, double delta) {
     vector<const Curve*> centroids;
-    vector<int> assignment(input_curves.size()), centroids_ind;
+    vector<int> assignment(input_curves.size());
     vector<double> close_dist(input_curves.size()), close_dist_sec(input_curves.size());
     bool check;
     double value;
     int num_of_clusters = 2;
-    
-    k_means_pp(centroids_ind, centroids, input_curves.size(), num_of_clusters, metric);
+
+    k_means_pp(centroids, input_curves.size(), num_of_clusters, "DFT");
     cout << "initialization ended" << endl;
 
     vector<vector<int> > clusters(num_of_clusters);
 
     do {
-        for (int i = 0; i < num_of_clusters; ++i) {
-            //value = loyd_assignment(centroids_ind, assignment, close_dist, close_dist_sec, clusters);
-            value = loyd_assignment(centroids, clusters);
-            //check = PAM_update(centroids_ind, assignment, close_dist, close_dist_sec, value, clusters[i], i, metric); 
-            check = mean_frechet_update(centroids, clusters);
-        }
+        value = loyd_assignment(centroids, clusters);
+        //check = PAM_update(centroids, value, clusters); 
+        check = mean_frechet_update(centroids, clusters);
     } while(check);
 
     double min_s = -1, max_s = -1;

cluster.h

@@ -2,16 +2,17 @@
 #define CLUSTER_H
 
 #include "curve.h"
+#include "hashtable.h"
 #include <vector>
 
 using namespace std;
 
 vector<int> k_random_selection(int, int);
-void k_means_pp(vector<int>&, vector<const Curve*>&, int, int, const char*);
-double loyd_assignment(const vector<int>&, vector<int>&, vector<double>&, vector<double>&, vector<vector<int> >&, char*);
+void k_means_pp(vector<const Curve*>&, int, int, const char*);
 double loyd_assignment(const vector<const Curve*>&, vector<vector<int> >&);
-bool PAM_update(vector<int>&, const vector<int>&, const vector<double>&, const vector<double>&, double, const vector<int>&, int, char*);
+vector<int> range_search(const vector<HashTable> &, const vector<Curve>&, int, int, int, double);
+bool PAM_update(vector<int>&, double, const vector<int>&);
 bool mean_frechet_update(vector<const Curve*>&, const vector<vector<int> >&);
-void clustering(char*);
+void clustering(const vector<HashTable> &hashtables, int, int, double);
 
 #endif

curve.cpp

@@ -4,27 +4,35 @@ vector<Curve> input_curves;
 
 Curve::Curve() {
     this->id = "";
+    this->int_id = -1;
 }
 
-Curve::Curve(string id, int dim) {
+Curve::Curve(string id, int int_id, int dim) {
     this->id = id;
+    this->int_id = int_id;
     this->dim = dim;
 }
 
-Curve::Curve(string id, int dim, const vector<vector<double> > &curve) {
+Curve::Curve(string id, int int_id, int dim,const vector<vector<double> > &curve) {
     this->id = id;
+    this->int_id = int_id;
     this->dim = dim;
     this->curve = curve;
 }
 
-void Curve::set_id(string id) {
+void Curve::set_id(string id, int int_id) {
     this->id = id;
+    this->int_id = int_id;
 }
 
 void Curve::insert_point(const vector<double> &point) {
     curve.push_back(point);
 }
 
+void Curve::clear_curve() {
+    curve.clear();
+}
+
 int Curve::get_dimension() const {
     return dim;
 }
@@ -37,6 +45,10 @@ string Curve::get_id() const {
     return id;
 }
 
+int Curve::get_int_id() const {
+    return int_id;
+}
+
 double Curve::get_coord_point(int coord, int pnt) const {
     return curve[pnt][coord];
 }
@@ -66,7 +78,8 @@ bool Curve::is_empty() const {
 }
 
 void Curve::print_curve() const {
-    cout << "Id: " << id << endl;
+    cout << "Id: " << id << "\n";
+    cout << "int_Id: " << int_id << "\n";
 
     for (int i = 0; i < (int)curve.size(); ++i) {
         cout << "Point " << i << ": ";
@@ -82,11 +95,8 @@ void Curve::print_curve() const {
 }
 
 void Curve::append_curve(const Curve &new_curve) {
-    vector<double> temp;
-    
     for (int i = 0; i < new_curve.get_length(); ++i) {
-        temp = new_curve.get_point(i);
-        curve.push_back(temp);
+        curve.push_back(new_curve.get_point(i));
     }
 }