Groundtruth computing

Author: AntonisZks

.gitignore

@@ -4,4 +4,5 @@ build
 data/gist.tar.gz
 data/sift
 test.txt
-test.vig
+test.vig
+data/Dummy/dummy-groundtruth.bin

include/Algorithms/GreedySearch.h

@@ -115,9 +115,6 @@ struct EuclideanDistanceOrder {
  * 
  * @return Pair of sets: the first set contains the k nearest nodes, and the second set contains all visited nodes
  */
-
-/*
-*/
 template <typename graph_t>
 std::pair<std::set<graph_t>, std::set<graph_t>>
 GreedySearch(const Graph<graph_t>& G, const GraphNode<graph_t>& s, const graph_t& xq, unsigned int k, unsigned int L) {

main2.cpp

@@ -4,53 +4,149 @@
 #include "include/DataStructures/DataVector/BQDataVectors.h"
 #include "include/read_data.h"
 #include "include/distance.h"
+#include <fstream>
 
+/**
+ * @brief Compute the groundtruth for a set of base and query vectors.
+ * 
+ * This function computes the groundtruth for a set of base and query vectors by calculating the Euclidean distance
+ * between each query vector and all base vectors. The function supports only two query types: 0 and 1. For query type 0,
+ * the function computes the distances between the query vector and all base vectors. For query type 1, the function computes
+ * the distances between the query vector and the base vectors with the same C value.
+ * 
+ * @param base_vectors A vector of BaseDataVector objects representing the base vectors
+ * @param query_vectors A vector of QueryDataVector objects representing the query vectors
+ * @param maxDistances The maximum number of distances to compute for each query vector
+ * 
+ * @return A 2D vector containing the computed distances for each query vector
+ */
+std::vector<std::vector<float>> computeGroundtruth(
+  const std::vector<BaseDataVector<float>> base_vectors, const std::vector<QueryDataVector<float>> query_vectors, const unsigned int maxDistances) {
 
-int main(int argc, char* argv[]) {
+  // Allocate memory for the distance vector
+  std::vector<std::vector<float>> distances(query_vectors.size());
 
-  std::vector<BaseDataVector<float>> base_vectors = ReadFilteredBaseVectorFile("data/Dummy/dummy-data.bin");
-  std::vector<QueryDataVector<float>> query_vectors = ReadFilteredQueryVectorFile("data/Dummy/dummy-queries.bin");
+  // Compute the distances between the query vectors and the base vectors (with the same filter)
+  // If no filter provided then compute to the whole graph
+  for (auto query : query_vectors) {
 
-  // Allocate memory for the distances between the query and base vectors
-  double** distances = new double*[query_vectors.size()];
-  unsigned int** baseVectorIndeces = new unsigned int*[query_vectors.size()];
-  for (unsigned int i = 0; i < query_vectors.size(); i++) {
-    distances[i] = new double[base_vectors.size()];
-    baseVectorIndeces[i] = new unsigned int[base_vectors.size()];
-  }
+    // Compute the distances between the query vector and all base vectors
+    if (query.getQueryType() == 0) {
+      for (auto base : base_vectors) {
+        distances[query.getIndex()].push_back(euclideanDistance(base, query));
+      }
+    }
 
-  for (unsigned int i = 0; i < query_vectors.size(); i++) {
-    for (unsigned int j = 0; j < base_vectors.size(); j++) {
-      float distance = euclideanDistance(query_vectors[i], base_vectors[j]);
-      distances[i][j] = distance;
-      baseVectorIndeces[i][j] = j;
+    // If the filter type is C_EQUALS_v then compute the distances between the query vector 
+    // and the base vectors with the same C value
+    else if (query.getQueryType() == 1) {
+      for (auto base : base_vectors) {
+        if (base.getC() == query.getV()) {
+          distances[query.getIndex()].push_back(euclideanDistance(base, query));
+        }
+      }
     }
+    // IMPORTANT: Queries with filter type 2 and 3 are not supported in this version of the application
   }
 
-  // Sort the distances and keep the indeces of the base vectors
+  // Sort the distances for each query vector
   for (unsigned int i = 0; i < query_vectors.size(); i++) {
-    std::sort(baseVectorIndeces[i], baseVectorIndeces[i] + base_vectors.size(), 
-      [&distances, i](unsigned int a, unsigned int b) {
-        return distances[i][a] < distances[i][b];
-      }
-    );
+    std::sort(distances[i].begin(), distances[i].end());
   }
 
-  // Print the indeces of the base vectors with the smallest distances to the query vectors
-  for (unsigned int i = 0; i < query_vectors.size(); i++) {
-    std::cout << "Query " << i << ":\n";
-    for (unsigned int j = 0; j < 5; j++) {
-      std::cout << "Base vector index: " << baseVectorIndeces[i][j] << ", distance: " << distances[i][baseVectorIndeces[i][j]] << std::endl;
-    }
+  // Return the first `maxDistances` distances for each query vector
+  for (auto& query_distances : distances) {
+    query_distances.resize(maxDistances);
   }
 
-  // Deallocate memory for the distances
-  for (unsigned int i = 0; i < query_vectors.size(); i++) {
-    delete[] distances[i];
-    delete[] baseVectorIndeces[i];
+  return distances;
+
+}
+
+/**
+ * @brief Save the computed groundtruth distances to a binary file.
+ * 
+ * This function saves the computed groundtruth distances to a binary file. The file format consists of the following:
+ * - The number of query vectors (4 bytes)
+ * - For each query vector:
+ *   - The number of distances (4 bytes)
+ *   - The computed distances (4 bytes each)
+ * 
+ * @param distances A 2D vector containing the computed distances for each query vector
+ * @param filename The name of the output file to save the distances
+ */
+void saveGroundtruthToFile(const std::vector<std::vector<float>>& distances, const std::string& filename) {
+  std::ofstream file(filename, std::ios::binary);
+
+  if (!file.is_open()) {
+    std::cerr << "Error opening file: " << filename << std::endl;
+    return;
+  }
+
+  // Write the number of query vectors to the file
+  uint32_t num_queries = distances.size();
+  file.write(reinterpret_cast<const char*>(&num_queries), sizeof(num_queries));
+
+  // Write the distances for each query vector
+  for (const auto& query_distances : distances) {
+    uint32_t num_distances = query_distances.size();
+    file.write(reinterpret_cast<const char*>(&num_distances), sizeof(num_distances));
+    file.write(reinterpret_cast<const char*>(query_distances.data()), num_distances * sizeof(float));
+  }
+
+  file.close();
+}
+
+/**
+ * @brief Read the groundtruth distances from a binary file.
+ * 
+ * This function reads the groundtruth distances from a binary file. The file format consists of the following:
+ * - The number of query vectors (4 bytes)
+ * - For each query vector:
+ *   - The number of distances (4 bytes)
+ *   - The computed distances (4 bytes each)
+ * 
+ * @param filename The name of the input file to read the distances from
+ * 
+ * @return A 2D vector containing the read distances for each query vector
+ */
+std::vector<std::vector<float>> readGroundtruthFromFile(const std::string& filename) {
+  std::ifstream file(filename, std::ios::binary);
+
+  if (!file.is_open()) {
+    std::cerr << "Error opening file: " << filename << std::endl;
+    return {};
+  }
+
+  // Read the number of query vectors from the file
+  uint32_t num_queries;
+  file.read(reinterpret_cast<char*>(&num_queries), sizeof(num_queries));
+
+  std::vector<std::vector<float>> distances(num_queries);
+
+  // Read the distances for each query vector
+  for (auto& query_distances : distances) {
+    uint32_t num_distances;
+    file.read(reinterpret_cast<char*>(&num_distances), sizeof(num_distances));
+    query_distances.resize(num_distances);
+    file.read(reinterpret_cast<char*>(query_distances.data()), num_distances * sizeof(float));
   }
-  delete[] distances;
-  delete[] baseVectorIndeces;
+
+  file.close();
+  return distances;
+}
+
+int main(int argc, char* argv[]) {
+
+  std::vector<BaseDataVector<float>> base_vectors = ReadFilteredBaseVectorFile("data/Dummy/dummy-data.bin");
+  std::vector<QueryDataVector<float>> query_vectors = ReadFilteredQueryVectorFile("data/Dummy/dummy-queries.bin");
+
+  // Compute the distance vector, and save the computed distances to a file
+  std::vector<std::vector<float>> distances = computeGroundtruth(base_vectors, query_vectors, 1000);
+  saveGroundtruthToFile(distances, "data/Dummy/dummy-groundtruth.bin");
+
+  // Example usage of readGroundtruthFromFile
+  std::vector<std::vector<float>> read_distances = readGroundtruthFromFile("data/Dummy/dummy-groundtruth.bin");
 
   return 0;