Clean doc and directory checks

Author: Saurav Agarwal

.github/workflows/ghaction-doxygen-ghpages.yml

@@ -1,6 +1,9 @@
 on:
   release:
     types: [published]
+  push:
+    paths:
+      - 'doc/**'
 permissions:
   contents: write
 

cppsrc/core/include/CoverageControl/coverage_system.h

@@ -66,7 +66,6 @@ namespace CoverageControl {
  * library.
  */
 class CoverageSystem {
- protected:
   Parameters const params_;         //!< Parameters for the coverage system
   WorldIDF world_idf_;              //!< World IDF
   size_t num_robots_ = 0;           //!< Number of robots
@@ -404,13 +403,17 @@ class CoverageSystem {
     std::vector<int> robot_status(num_robots_, 0);
     PlotSystemMap(dir_name, step, robot_status);
   }
+	void PlotSystemMap(std::string const &) const;
   void PlotSystemMap(std::string const &, int const &,
                      std::vector<int> const &) const;
   void PlotMapVoronoi(std::string const &, int const &);
   void PlotMapVoronoi(std::string const &, int const &, Voronoi const &,
                       PointVector const &) const;
   void PlotWorldMap(std::string const &, std::string const &) const;
   void PlotWorldMapRobots(std::string const &, std::string const &) const;
+  void PlotInitMap(std::string const &filename) const {
+		PlotInitMap("./", filename);
+	}
   void PlotInitMap(std::string const &, std::string const &) const;
   void PlotRobotLocalMap(std::string const &, int const &, int const &);
   void PlotRobotSystemMap(std::string const &, int const &, int const &);

cppsrc/core/include/CoverageControl/plotter.h

@@ -107,7 +107,7 @@ class Plotter {
    * Voronoi const &); */
   /* void PlotMap(MapType const &, PointVector const &, PointVector const &); */
 
-  void GnuplotCommands(Gnuplot &gp);
+  bool GnuplotCommands(Gnuplot &gp);
   void StreamMap(Gnuplot &gp, MapType const &map);
   void PlotMap(Gnuplot &gp, bool begin = true);
   void PlotLine(Gnuplot &gp, int marker_sz, std::string color,

cppsrc/core/python_bindings/core_binds.h

@@ -34,8 +34,8 @@ namespace CoverageControl {
 CoverageSystem::CoverageSystem(Parameters const &params)
     : CoverageSystem(params, params.pNumFeatures, params.pNumRobots) {}
 
-CoverageSystem::CoverageSystem(Parameters const &params,
-                               int const num_features, int const num_robots)
+CoverageSystem::CoverageSystem(Parameters const &params, int const num_features,
+                               int const num_robots)
     : params_{params}, world_idf_{WorldIDF(params_)} {
   // Generate Bivariate Normal Distribution from random numbers
   std::srand(
@@ -466,6 +466,17 @@ void CoverageSystem::RecordPlotData(std::vector<int> const &robot_status,
   plotter_data_.push_back(data);
 }
 
+void CoverageSystem::PlotSystemMap(std::string const &filename) const {
+  std::vector<int> robot_status(num_robots_, 0);
+  Plotter plotter("./", params_.pWorldMapSize * params_.pResolution,
+                  params_.pResolution);
+  plotter.SetScale(2);
+  plotter.SetPlotName(filename);
+  plotter.PlotMap(system_map_, robot_global_positions_,
+                  robot_positions_history_, robot_status,
+                  params_.pCommunicationRange);
+}
+
 void CoverageSystem::PlotSystemMap(std::string const &dir_name, int const &step,
                                    std::vector<int> const &robot_status) const {
   Plotter plotter(dir_name, params_.pWorldMapSize * params_.pResolution,

cppsrc/core/src/coverage_system.cpp

@@ -31,14 +31,15 @@
 
 namespace CoverageControl {
 
-void Plotter::GnuplotCommands(Gnuplot &gp) {
-  std::filesystem::path path{dir};
-  if (not std::filesystem::exists(path)) {
-    std::cerr << "Directory does not exist" << std::endl;
-    throw std::runtime_error{"Directory does not exist"};
+[[nodiscard]] bool Plotter::GnuplotCommands(Gnuplot &gp) {
+
+	std::filesystem::path map_filename{std::filesystem::weakly_canonical(dir + "/" + plot_name)};
+	std::filesystem::path dir_path{map_filename.parent_path()};
+	if (!std::filesystem::exists(dir_path)) {
+    std::cerr << "Directory does not exist: " << dir_path << std::endl;
+		return 1;
   }
-  std::string map_filename{std::filesystem::absolute(path / plot_name)};
-  gp << "set o '" << map_filename << "'\n";
+  gp << "set o '" << map_filename.string() << "'\n";
   gp << "set terminal pngcairo enhanced font 'Times," << font_sz << "' size "
      << image_sz << "," << image_sz << "\n";
   gp << "set palette defined (-5 'black', -1 '" << color_unknown
@@ -48,6 +49,7 @@ void Plotter::GnuplotCommands(Gnuplot &gp) {
   gp << "set xrange [0:" << range_max << "]\n";
   gp << "set yrange [0:" << range_max << "]\n";
   if (unset_colorbox) gp << "unset colorbox\n";
+	return 0;
 }
 
 void Plotter::StreamMap(Gnuplot &gp, MapType const &map) {
@@ -91,15 +93,21 @@ void Plotter::PlotPoints(Gnuplot &gp, int point_type, int marker_size,
 
 void Plotter::PlotMap(MapType const &map) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
   gp << "\n";
   StreamMap(gp, map);
 }
 
 void Plotter::PlotMap(MapType const &map, PointVector const &positions) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
   PlotPoints(gp, 7, marker_sz, color_robot);
   gp << "\n";
@@ -116,7 +124,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       std::vector<std::list<Point2>> const &trajectories,
                       std::vector<int> const &robot_status) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
 
   for (size_t i = 0; i < positions.size(); ++i) {
@@ -154,7 +165,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       std::vector<int> const &robot_status,
                       double const &communication_range) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
 
   for (size_t i = 0; i < positions.size(); ++i) {
@@ -202,7 +216,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       std::vector<std::list<Point2>> const &voronoi,
                       std::vector<std::list<Point2>> const &trajectories) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
 
   PlotLine(gp, marker_sz, color_robot, false);
@@ -238,7 +255,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       Voronoi const &voronoi,
                       std::vector<std::list<Point2>> const &trajectories) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
 
   PlotLine(gp, marker_sz, color_robot, false);
@@ -276,7 +296,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
 void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       PointVector const &goals, Voronoi const &voronoi) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
   PlotMap(gp);
 
   PlotLine(gp, half_marker_sz, color_voronoi, false);  // voronoi
@@ -322,7 +345,10 @@ void Plotter::PlotMap(MapType const &map, PointVector const &positions,
                       std::vector<std::list<Point2>> const &trajectories,
                       PointVector const &frontiers) {
   Gnuplot gp;
-  GnuplotCommands(gp);
+	if (GnuplotCommands(gp)) {
+		std::cerr << "Error in GnuplotCommands" << std::endl;
+		return;
+	}
 
   PlotMap(gp);
   PlotLine(gp, marker_sz, color_robot);

cppsrc/core/src/plotter.cpp

@@ -29,12 +29,12 @@
       <publicstaticmethods title=""/>
       <publicattributes title=""/>
       <publicstaticattributes title=""/>
-      <protectedtypes title=""/>
-      <protectedslots title=""/>
-      <protectedmethods title=""/>
-      <protectedstaticmethods title=""/>
-      <protectedattributes title=""/>
-      <protectedstaticattributes title=""/>
+      <!-- <protectedtypes title=""/> -->
+      <!-- <protectedslots title=""/> -->
+      <!-- <protectedmethods title=""/> -->
+      <!-- <protectedstaticmethods title=""/> -->
+      <!-- <protectedattributes title=""/> -->
+      <!-- <protectedstaticattributes title=""/> -->
       <packagetypes title=""/>
       <packagemethods title=""/>
       <packagestaticmethods title=""/>

doc/config/DoxygenLayout.xml

@@ -22,12 +22,17 @@ You can choose one of the following algorithms instead of `ClairvoyantCVT`:
 Create a `CoverageControl::Parameters` object and load the configuration file:
 ```python
 params = CoverageControl.Parameters() # for default parameters
-params.load("params/coverage_control_params.toml") # load the configuration file
+params.load("params/coverage_control_params.toml") # Alternatively, load a configuration file
 ```
 
 Create a simulation environment:
 ```python
-env = CoverageControl.Environment(params)
+env = CoverageControl.CoverageSystem(params)
+```
+
+Plot the initial environment:
+```python
+env.PlotInitMap("init_map");
 ```
 
 Print the initial coverage cost:
@@ -64,6 +69,12 @@ current_cost = env.GetObjectiveValue()
 print("Improvement %: " + str('{:.2f}'.format(100 * (init_cost - current_cost)/init_cost)))
 ```
 
+Plot the final state of the environment:
+```cpp
+env.PlotSystemMap("final_map");
+```
+
+
 See \ref python/tests/coverage_simple.py and \ref python/tests/coverage_class.py for complete examples.
 
 ---
@@ -77,7 +88,7 @@ Include the `CoverageControl` library, algorithms, and other necessary headers:
 #include <CoverageControl/world_idf.h>
 #include <CoverageControl/coverage_system.h>
 
-#include <CoverageControl/algorithms/near_optimal_cvt.h>
+#include <CoverageControl/algorithms/clairvoyant_cvt.h>
 
 #include <iostream>
 #include <memory>
@@ -103,47 +114,80 @@ Parameters params;
 Create coverage system environment:
 ```cpp
 CoverageSystem env(params);
-auto init_objective = env->GetObjectiveValue();
+auto init_objective = env.GetObjectiveValue();
 std::cout << "Initial objective: " << init_objective << std::endl;
 ```
 
-To plot the initial environment use the function `PlotInitMap(dir_name, init_map)` :
+Plot the initial environment:
 ```cpp
-env.PlotInitMap("./", "init_map");
+env.PlotInitMap("init_map"); // Creates "init_map.png"
 ```
 
 Create a controller using the `CoverageAlgorithm` and the environment:
 ```cpp
-CoverageAlgorithm algorithm(params, *env);
+CoverageAlgorithm algorithm(params, env);
 ```
 
 Execute the algorithm:
 ```cpp
-for (int ii = 0; ii < params.pEpisodeSteps; ++ii) {
+for (int i = 0; i < params.pEpisodeSteps; ++i) {
     algorithm.ComputeActions();
     auto actions = algorithm.GetActions();
-    if (env->StepActions(actions)) {
+    if (env.StepActions(actions)) {
         std::cout << "Invalid action" << std::endl;
         break;
     }
-    if (algorithm.IsConverged() {
+    if (algorithm.IsConverged()) {
         break;
     }
 }
 ```
 
 Print improvement in cost:
 ```cpp
-auto current_objective = env->GetObjectiveValue();
+auto final_objective = env.GetObjectiveValue();
 std::cout << "Improvement %: "
           << (init_objective - final_objective) / init_objective * 100
           << std::endl;
 ```
 
+Plot the final state of the environment:
+```cpp
+env.PlotSystemMap("final_map"); // Creates "final_map.png"
+```
+
 See \ref cppsrc/main/coverage_algorithm.cpp for a complete example.
 
+### Compile and Run
+
+Create a `CMakeLists.txt` file with the following content:
+```python
+cmake_minimum_required(VERSION 3.16)
+project(coveragecontrol)
 
+set(CMAKE_BUILD_TYPE Release)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
 
+find_package(CoverageControl REQUIRED)
+
+add_executable(coveragecontrol coveragecontrol.cpp) # Replace with your source file
+target_link_libraries(coveragecontrol PRIVATE CoverageControl::CoverageControl)
+install(TARGETS coveragecontrol DESTINATION ${CMAKE_INSTALL_BINDIR})
+```
+
+Build the program:
+```bash
+mkdir build
+cd build
+cmake ..
+make
+```
+
+Run the program:
+```bash
+./coveragecontrol
+```