Heuristic -> Initialization

Renamed confusing 'heuristic' word for 'initialization'

Author: AHuguetUPC

README.md

@@ -96,7 +96,7 @@ To adapt LIMO-Velo to our own hardware infrastructure, a [YAML](https://yaml.org
 Relevant parameters are:
 - ``real_time`` if you want to get real time experience.
 - ``mapping_offline`` is on an pre-alpha stage and it does not work 100% as it should of.
-- ``heuristic`` which you can choose how you want the initialization of the pointcloud sizes (sizes =: deltas, in seconds).
+- ``initialization`` which you can choose how you want the initialization of the pointcloud sizes (sizes =: deltas, in seconds).
 
 ## 4. Modifying the LiDAR driver to get true real-time performance
 *TODO* - This section is intended to explain how to modify the LiDAR driver to increase its frequency by publishing parts of the pointcloud instead of waiting for all of it.

config/kitti.yaml

@@ -47,6 +47,6 @@ degeneracy_threshold: 400.
 print_degeneracy_values: false
 
 # Delta refinement
-Heuristic:
+Initialization:
   times: []
   deltas: [0.1]

config/ouster.yaml

@@ -58,11 +58,11 @@ print_degeneracy_values: false     # Print the degeneracy eigenvalues to guess w
 # Choose a set of times and field of view sizes (deltas) for the initialization.
 # The delta (t2 - t1) that will be used through the algorithm therefore is the last one in the 'deltas' vector
 # Tick the 'Localizator' box in RViz to see the initialization in action
-Heuristic:
-    # No heuristic
+Initialization:
+    # No initialization
     times: []
     deltas: [0.1]
 
-    # # With heuristic
+    # # With initialization
     # times: [2.0]
     # deltas: [0.1, 0.025]

config/params.yaml

@@ -56,11 +56,11 @@ print_degeneracy_values: false     # Print the degeneracy eigenvalues to guess w
 # Choose a set of times and field of view sizes (deltas) for the initialization.
 # The delta (t2 - t1) that will be used through the algorithm therefore is the last one in the 'deltas' vector
 # Tick the 'Localizator' box in RViz to see the initialization in action
-Heuristic:
-#     # No heuristic
+Initialization:
+#     # No initialization
 #     times: []
 #     deltas: [0.1]
 
-    # With heuristic
+    # With initialization
     times: [0.5, 1.0]
     deltas: [0.1, 0.05, 0.02]

config/xaloc.yaml

@@ -51,11 +51,11 @@ degeneracy_threshold: 5.
 print_degeneracy_values: false
 
 # Delta refinement
-Heuristic:
-#     # No heuristic
+Initialization:
+#     # No initialization
 #     times: []
 #     deltas: [0.1]
 
-    # With heuristic
+    # With initialization
     times: [0.5, 1.0, 1.25]
     deltas: [0.1, 0.05, 0.02]

include/Headers/Accumulator.hpp

@@ -47,7 +47,7 @@ class Accumulator {
 
         // Time management
 
-            double update_delta(const HeuristicParams&, double t);
+            double update_delta(const InitializationParams&, double t);
             double latest_time();
 
     private:
@@ -111,7 +111,7 @@ class Accumulator {
 
         bool enough_imus();
         void set_initial_time();
-        double interpret_heuristic(const HeuristicParams&, double t);
+        double interpret_initialization(const InitializationParams&, double t);
 
         bool missing_data(const Points&);
         void throw_warning(const Points&);

include/Headers/Common.hpp

@@ -48,7 +48,7 @@ namespace LIDAR_TYPE {
     const std::string Custom = "custom";
 }
 
-struct HeuristicParams {
+struct InitializationParams {
     std::vector<double> times;
     std::vector<double> deltas;
 };
@@ -103,7 +103,7 @@ struct Params {
     std::string points_topic;
     std::string imus_topic;
 
-    HeuristicParams Heuristic;
+    InitializationParams Initialization;
 };
 
 namespace velodyne_ros {

src/Modules/Accumulator.cpp

@@ -113,9 +113,9 @@ extern struct Params Config;
             return this->get_imus(t - 3., t).size() < 2;
         }
 
-        double Accumulator::update_delta(const HeuristicParams& heuristic, double t) {
-            assert(("There has to be exactly one more delta value than time delimiters", heuristic.times.size() + 1 == heuristic.deltas.size()));
-            return this->interpret_heuristic(heuristic, t);
+        double Accumulator::update_delta(const InitializationParams& initialization, double t) {
+            assert(("There has to be exactly one more delta value than time delimiters", initialization.times.size() + 1 == initialization.deltas.size()));
+            return this->interpret_initialization(initialization, t);
         }
 
         double Accumulator::latest_time() {
@@ -154,27 +154,27 @@ extern struct Params Config;
             this->initial_time = latest_imu_time - Config.real_time_delay;
         }
 
-        double Accumulator::interpret_heuristic(const HeuristicParams& heuristic, double t) {
+        double Accumulator::interpret_initialization(const InitializationParams& initialization, double t) {
             // If is after last time
-            if (heuristic.times.empty()) return heuristic.deltas.back();
-            if (t - this->initial_time >= heuristic.times.back()) return heuristic.deltas.back();
+            if (initialization.times.empty()) return initialization.deltas.back();
+            if (t - this->initial_time >= initialization.times.back()) return initialization.deltas.back();
 
             // If we have to find it in the list
-            for (int k = 0; k < heuristic.times.size(); ++k)
-                if (t - this->initial_time < heuristic.times[k])
-                    return heuristic.deltas[k];
+            for (int k = 0; k < initialization.times.size(); ++k)
+                if (t - this->initial_time < initialization.times[k])
+                    return initialization.deltas[k];
 
-            return heuristic.deltas.back();
+            return initialization.deltas.back();
         }
 
         bool Accumulator::missing_data(const Points& time_sorted_points) {
             if (time_sorted_points.size() < Config.MAX_POINTS2MATCH) return false;
 
             // Check missing 'time' information
             if (time_sorted_points.front().time == 0 and time_sorted_points.back().time == 0) {
-                // Remove Heuristic
-                Config.Heuristic.times = {};
-                Config.Heuristic.deltas = {Config.full_rotation_time};
+                // Remove Initialization
+                Config.Initialization.times = {};
+                Config.Initialization.deltas = {Config.full_rotation_time};
 
                 return true;
             }

src/main.cpp

@@ -45,7 +45,7 @@ int main(int argc, char** argv) {
     t2 = DBL_MAX;
 
     // (Delta = t2 - t1) Size of the field of view we use to localize
-    double delta = Config.Heuristic.deltas.front();
+    double delta = Config.Initialization.deltas.front();
 
     ros::Rate rate(5000);
 
@@ -63,7 +63,7 @@ int main(int argc, char** argv) {
                 else t2 = std::min(t2 + delta, accum.latest_time());
 
                 // Update delta value
-                delta = accum.update_delta(Config.Heuristic, t2);
+                delta = accum.update_delta(Config.Initialization, t2);
 
                 // Define t1 but don't use to localize repeated points
                 t1 = std::max(t2 - delta, loc.last_time_updated);
@@ -168,8 +168,8 @@ void fill_config(ros::NodeHandle& nh) {
     nh.param<std::string>("imus_topic", Config.imus_topic, "/vectornav/IMU");
     nh.param<bool>("offset_beginning", Config.offset_beginning, false);
     nh.param<bool>("stamp_beginning", Config.stamp_beginning, false);
-    nh.param<std::vector<double>>("/Heuristic/times", Config.Heuristic.times, {});
-    nh.param<std::vector<double>>("/Heuristic/deltas", Config.Heuristic.deltas, {Config.full_rotation_time});
+    nh.param<std::vector<double>>("/Initialization/times", Config.Initialization.times, {});
+    nh.param<std::vector<double>>("/Initialization/deltas", Config.Initialization.deltas, {Config.full_rotation_time});
     nh.param<std::vector<float>>("initial_gravity", Config.initial_gravity, {0.0, 0.0, -9.807});
     nh.param<std::vector<float>>("I_Translation_L", Config.I_Translation_L, std::vector<float> (3, 0.));
     nh.param<std::vector<float>>("I_Rotation_L", Config.I_Rotation_L, std::vector<float> (9, 0.));