Adds CPP implementatinon

src/main.cpp

@@ -1,40 +1,107 @@
-#include <fstream>
+#include "calc.hpp"
+#include "json_output.hpp"
+#include "proto_loader.hpp"
+#include "spatial_grid.hpp"
+
 #include <iostream>
-
-#include "protocol_buffers_definitions/recordings.pb.h"
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
 
 
-using namespace ::indoors::proto;
+static void print_usage()
+{
+  std::cout << "ESRI C++ code assignment, E. Nindl 2021\n\n";
+  std::cout << "Usage:\n";
+  std::cout << "   executable <input-file[s]> <json-ouput-file>\n";
+}
+
+
+std::tuple<double, double, double, double>
+total_spatial_extent(std::vector<Magnetics> const& magnetics_recs) {
+  double x_min = std::numeric_limits<double>::max();
+  double y_min = std::numeric_limits<double>::max();
+  double x_max = std::numeric_limits<double>::min();
+  double y_max = std::numeric_limits<double>::min();
+  for (auto const& magnetics : magnetics_recs) {
+    auto const [x_min_i, y_min_i, x_max_i, y_max_i] = ::calc::spatial_extent(magnetics);
+    x_min = std::min(x_min, x_min_i);
+    y_min = std::min(y_min, y_min_i);
+    x_max = std::max(x_max, x_max_i);
+    y_max = std::max(y_max, y_max_i);
+  }
+  return std::make_tuple(x_min, y_min, x_max, y_max);
+}
+
+
+static bool write_output(std::string const& output_file, SpatialGrid<double>& grid)
+{
+  JsonOutput json_output(output_file.c_str());
+  json_output.add("start_x", grid.start_x());
+  json_output.add("start_y", grid.start_y());
+  json_output.add("spacing", grid.spacing);
+  json_output.add("data", grid.data());
+  return json_output.write();
+}
+
 
 int main(int argc, char* argv[])
 {
-  // Verify that the version of the library that we linked against is
-  // compatible with the version of the headers we compiled against.
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  std::cout << "ESRI C++ code assignment\n";
-
-  Recording recording;
-  Position positions;
-
-  std::fstream input(argv[1], std::ios::in | std::ios::binary);
-  if (!recording.ParseFromIstream(&input)) {
-    std::cerr << "Failed to parse input file.\n";
-    return -1;
+  if (argc < 3) {
+    print_usage();
+    return 1;
   }
-  std::cout.precision(17);
-  for (int i=0; i < recording.magnetics_size(); i++) {
-    auto const& s = recording.magnetics(i);
-    std::cout << s.t() << ": [" << s.x() << ", " << s.y() << ", " << s.z() << "]\n";
-  }
-  for (int i=0; i < recording.positions_size(); i++) {
-    auto const& s = recording.positions(i);
-    std::cout << s.t() << ": [" << s.x() << ", " << s.y() << "]\n";
+  std::string const output_file{argv[argc - 1]};
+  std::vector<std::string> input_files;
+  for (uint32_t i = 1; i < (argc - 1); i++) {
+    input_files.push_back(argv[i]);
   }
 
-  // Optional:  Delete all global objects allocated by libprotobuf.
-  google::protobuf::ShutdownProtobufLibrary();
+  std::vector<Magnetics> magnetics_recs;
+  std::vector<Positions> groundtruth_recs;
+
+  try {
+    for (auto const& input_file : input_files) {
+      ProtoLoader loader(input_file.c_str());
+      magnetics_recs.push_back(loader.magnetics());
+      groundtruth_recs.push_back(loader.groundtruth());
+    }
+  } catch (std::exception& e) {
+    std::cerr << "Error loading input: " << e.what() << "\n";
+    return 1;
+  }
+
+  for (size_t rec_id = 0; rec_id < magnetics_recs.size(); rec_id++) {
+    Magnetics& magnetics = magnetics_recs[rec_id];
+    Positions& groundtruth = groundtruth_recs[rec_id];
+    ::calc::crop_temporal_inersection(magnetics, groundtruth);
+    if (magnetics.size() == 0) {
+      std::cerr << "Error in groundtruth data\n";
+      return 1;
+    }
+    ::calc::interpolate_positions(magnetics, groundtruth);
+  }
+
+  auto const [x_min, y_min, x_max, y_max] = total_spatial_extent(magnetics_recs);
+  SpatialGrid<std::vector<double>> grid(x_min, y_min, x_max, y_max);
+
+  for (size_t rec_id = 0; rec_id < magnetics_recs.size(); rec_id++) {
+    Magnetics& magnetics = magnetics_recs[rec_id];
+    Positions& groundtruth = groundtruth_recs[rec_id];
+    for (auto& mag : magnetics) {
+      auto& cell = grid.at(mag.position);
+      double const magnitude = ::calc::norm(mag.field.cbegin(), mag.field.cend());
+      cell.push_back(magnitude);
+    }
+  }
+
+  SpatialGrid<double> average_grid(x_min, y_min, x_max, y_max);
+  calc::average_grid(grid, average_grid);
+  if (!write_output(output_file, average_grid)) {
+    std::cout << "Error writing output file: " << output_file << "\n";
+    return 1;
+  }
 
   return 0;
 }
-