Update parameters

Author: Saurav Agarwal

cppsrc/core/include/CoverageControl/parameters.h

@@ -54,10 +54,6 @@ class Parameters {
    * @{
    */
   int pNumRobots = 32;    //!< Number of robots
-  int pNumFeatures = 32;  //!< Number of features
-  int pNumPolygons = 0;   //!< Number of polygonal features
-  int pMaxVertices = 10;  //!< Maximum number of vertices in a polygon
-  double pPolygonRadius = 64;
 
   /*! \name IO Parameters
    * @{
@@ -103,6 +99,7 @@ class Parameters {
   // Helps in reducing the number of erfc evaluations
   // Needs testing to be sure that the probability masses are not significantly
   // off
+  int pNumGaussianFeatures = 32;  //!< Number of features
   double pTruncationBND = 2;
 
   double pNorm = 1;
@@ -114,6 +111,10 @@ class Parameters {
   double pMinPeak = 6;
   double pMaxPeak = 10;
 
+  int pNumPolygons = 0;   //!< Number of polygonal features
+  int pMaxVertices = 10;  //!< Maximum number of vertices in a polygon
+  double pPolygonRadius = 64;
+
   double pUnknownImportance = 0.5;
   bool pRobotMapUseUnknownImportance = false;
   /*! @} */

cppsrc/core/src/coverage_system.cpp

@@ -37,7 +37,7 @@
 namespace CoverageControl {
 
 CoverageSystem::CoverageSystem(Parameters const &params)
-    : CoverageSystem(params, params.pNumFeatures, params.pNumPolygons,
+    : CoverageSystem(params, params.pNumGaussianFeatures, params.pNumPolygons,
                      params.pNumRobots) {}
 
 CoverageSystem::CoverageSystem(Parameters const &params,

cppsrc/core/src/parameters.cpp

@@ -61,30 +61,6 @@ void Parameters::ParseParameters() {
     std::cout << "NumRobots (default): " << pNumRobots << std::endl;
   }
 
-  if (toml_config["NumFeatures"].value<int>()) {
-    pNumFeatures = toml_config["NumFeatures"].value<int>().value();
-  } else {
-    std::cout << "NumFeatures (default): " << pNumFeatures << std::endl;
-  }
-
-  if (toml_config["NumPolygons"].value<int>()) {
-    pNumPolygons = toml_config["NumPolygons"].value<int>().value();
-  } else {
-    std::cout << "NumPolygons (default): " << pNumPolygons << std::endl;
-  }
-
-  if (toml_config["MaxVertices"].value<int>()) {
-    pMaxVertices = toml_config["MaxVertices"].value<int>().value();
-  } else {
-    std::cout << "MaxVertices (default): " << pMaxVertices << std::endl;
-  }
-
-  if (toml_config["PolygonRadius"].value<double>()) {
-    pPolygonRadius = toml_config["PolygonRadius"].value<double>().value();
-  } else {
-    std::cout << "PolygonRadius (default): " << pPolygonRadius << std::endl;
-  }
-
   auto toml_IO = toml_config["IO"];
   if (toml_IO["PlotScale"].value<double>()) {
     pPlotScale = toml_IO["PlotScale"].value<double>().value();
@@ -146,6 +122,11 @@ void Parameters::ParseParameters() {
   auto toml_EnvironmentIDF = toml_config["Environment"]["IDF"];
 
   if (toml_EnvironmentIDF) {
+    if (toml_EnvironmentIDF["NumGaussianFeatures"].value<int>()) {
+      pNumGaussianFeatures = toml_EnvironmentIDF["NumGaussianFeatures"].value<int>().value();
+    } else {
+      std::cout << "NumGaussianFeatures (default): " << pNumGaussianFeatures << std::endl;
+    }
     auto toml_TruncationBND =
         toml_EnvironmentIDF["TruncationBND"].value<double>();
     auto toml_Norm = toml_EnvironmentIDF["Norm"].value<double>();
@@ -176,6 +157,25 @@ void Parameters::ParseParameters() {
     if (toml_MaxPeak) {
       pMaxPeak = toml_MaxPeak.value();
     }
+
+    if (toml_EnvironmentIDF["NumPolygons"].value<int>()) {
+      pNumPolygons = toml_EnvironmentIDF["NumPolygons"].value<int>().value();
+    } else {
+      std::cout << "NumPolygons (default): " << pNumPolygons << std::endl;
+    }
+
+    if (toml_EnvironmentIDF["MaxVertices"].value<int>()) {
+      pMaxVertices = toml_EnvironmentIDF["MaxVertices"].value<int>().value();
+    } else {
+      std::cout << "MaxVertices (default): " << pMaxVertices << std::endl;
+    }
+
+    if (toml_EnvironmentIDF["PolygonRadius"].value<double>()) {
+      pPolygonRadius = toml_EnvironmentIDF["PolygonRadius"].value<double>().value();
+    } else {
+      std::cout << "PolygonRadius (default): " << pPolygonRadius << std::endl;
+    }
+
     if (toml_UnknownImportance) {
       pUnknownImportance = toml_UnknownImportance.value();
     }
@@ -262,7 +262,6 @@ void Parameters::ParseParameters() {
 
 void Parameters::PrintParameters() const {
   std::cout << "NumRobots: " << pNumRobots << std::endl;
-  std::cout << "NumFeatures: " << pNumFeatures << std::endl;
   std::cout << "NumPolygons: " << pNumPolygons << std::endl;
   std::cout << "MaxVertices: " << pMaxVertices << std::endl;
   std::cout << "PolygonRadius: " << pPolygonRadius << std::endl;
@@ -279,13 +278,18 @@ void Parameters::PrintParameters() const {
   std::cout << "UpdateExplorationMap: " << pUpdateExplorationMap << std::endl;
   std::cout << "UpdateSystemMap: " << pUpdateSystemMap << std::endl;
 
+  std::cout << "NumGaussianFeatures: " << pNumGaussianFeatures << std::endl;
   std::cout << "TruncationBND: " << pTruncationBND << std::endl;
   std::cout << "Norm: " << pNorm << std::endl;
   std::cout << "MinSigma: " << pMinSigma << std::endl;
   std::cout << "MaxSigma: " << pMaxSigma << std::endl;
   std::cout << "MinPeak: " << pMinPeak << std::endl;
   std::cout << "MaxPeak: " << pMaxPeak << std::endl;
 
+  std::cout << "pNumPolygons: " << pNumPolygons << std::endl;
+  std::cout << "pMaxVertices: " << pMaxVertices << std::endl;
+  std::cout << "pPolygonRadius: " << pPolygonRadius << std::endl;
+
   std::cout << "UnknownImportance: " << pUnknownImportance << std::endl;
   std::cout << "RobotMapUseUnknownImportance: " << pRobotMapUseUnknownImportance
             << std::endl;

cppsrc/main/world_idf.cpp

@@ -27,7 +27,7 @@ int main(int argc, char** argv) {
   CoverageControl::CudaUtils::SetUseCuda(false);
   Parameters params;
   params.pNumRobots = 1;
-  params.pNumFeatures = 2;
+  params.pNumGaussianFeatures = 2;
   params.pNumPolygons = 20;
   params.pWorldMapSize = 1024;
   params.pMaxVertices = 7;

cppsrc/python_bindings/core_binds.h

@@ -229,7 +229,7 @@ void pyCoverageControl_core(py::module &m) {
       .def("SetConfig", &Parameters::SetConfig)
       .def("PrintParameters", &Parameters::PrintParameters)
       .def_readwrite("pNumRobots", &Parameters::pNumRobots)
-      .def_readwrite("pNumFeatures", &Parameters::pNumFeatures)
+      .def_readwrite("pNumGaussianFeatures", &Parameters::pNumGaussianFeatures)
       .def_readwrite("pNumPolygons", &Parameters::pNumPolygons)
       .def_readwrite("pMaxVertices", &Parameters::pMaxVertices)
       .def_readwrite("pPolygonRadius", &Parameters::pPolygonRadius)

cppsrc/tests/map_generation.cpp

@@ -59,7 +59,7 @@ int main(int argc, char** argv) {
   if (argc == 2) {
     std::string parameter_file = argv[1];
     params = Parameters(parameter_file);
-    env = std::make_unique<CoverageSystem>(params, params.pNumFeatures,
+    env = std::make_unique<CoverageSystem>(params, params.pNumGaussianFeatures,
                                            params.pNumRobots);
   }
 
@@ -69,7 +69,7 @@ int main(int argc, char** argv) {
     WorldIDF world_idf(params, idf_file);
     env = std::make_unique<CoverageSystem>(params, world_idf, pos_file);
     params.pNumRobots = env->GetNumRobots();
-    params.pNumFeatures = env->GetNumFeatures();
+    params.pNumGaussianFeatures = env->GetNumFeatures();
   }
 
   env->PlotInitMap("./", "init_map");

cppsrc/torch/include/CoverageControlTorch/generate_dataset.h

@@ -146,7 +146,7 @@ namespace CoverageControlTorch {
 			void Run() {
 				num_non_converged_env_ = 0;
 				while(dataset_count_ < dataset_size_) {
-					env_ = std::make_shared <CoverageSystem>(env_params_, env_params_.pNumFeatures, env_params_.pNumRobots);
+					env_ = std::make_shared <CoverageSystem>(env_params_, env_params_.pNumGaussianFeatures, env_params_.pNumRobots);
 					alg_ = std::make_shared <CoverageAlgorithm>(env_params_, num_robots_, *env_);
 
 					++env_count_;

python/coverage_env/coverage_class.py

@@ -25,7 +25,7 @@ def __init__(self, params_filename=None):
         else:
             self.params_ = cc.Parameters()
 
-        self.params_.pNumFeatures = 5
+        self.params_.pNumGaussianFeatures = 5
         self.params_.pMaxSigma = 100
         self.params_.pMinSigma = 100
 

python/coverage_env/world_idf.py

@@ -13,7 +13,7 @@
 else:
     params = coverage_control.Parameters()
     params.pNumRobots = 1
-    params.pNumFeatures = 5
+    params.pNumGaussianFeatures = 5
     params.pNumPolygons = 20
     params.pWorldMapSize = 1024
     params.pMaxVertices = 5

python/evaluators/eval.py

@@ -49,7 +49,7 @@ def __init__(self, in_config):
         self.cc_params = cc.Parameters(self.env_config_file)
 
         self.num_robots = self.cc_params.pNumRobots
-        self.num_features = self.cc_params.pNumFeatures
+        self.num_features = self.cc_params.pNumGaussianFeatures
         self.num_envs = self.config["NumEnvironments"]
         self.num_steps = self.config["NumSteps"]
         os.makedirs(self.env_dir + "/init_maps", exist_ok=True)