Use CLI11 for command line interfaces

Drop own command line parsing implementation.

Author: RainerKuemmerle

g2o/EXTERNAL/CLI11/CMakeLists.txt

@@ -0,0 +1,10 @@
+include(FetchContent)
+FetchContent_Declare(
+    cli11_proj
+    QUIET
+    GIT_REPOSITORY https://github.com/CLIUtils/CLI11.git
+    # v2.5.0
+    GIT_TAG 4160d259d961cd393fd8d67590a8c7d210207348
+)
+
+FetchContent_MakeAvailable(cli11_proj)

g2o/EXTERNAL/CMakeLists.txt

@@ -1,3 +1,5 @@
+add_subdirectory(CLI11)
+
 if (G2O_HAVE_OPENGL)
   add_subdirectory(freeglut)
 endif()

g2o/apps/g2o_cli/CMakeLists.txt

@@ -22,7 +22,8 @@ endif(UNIX)
 add_executable(g2o_cli_application
   g2o.cpp)
 
-target_link_libraries(g2o_cli_application g2o_cli_library)
+target_link_libraries(g2o_cli_application PUBLIC g2o_cli_library)
+target_link_libraries(g2o_cli_application PRIVATE CLI11::CLI11)
 
 set_target_properties(g2o_cli_application PROPERTIES OUTPUT_NAME g2o)
 

g2o/apps/g2o_cli/g2o.cpp

@@ -33,6 +33,7 @@
 #include <string>
 #include <string_view>
 
+#include "CLI/CLI.hpp"
 #include "dl_wrapper.h"
 #include "g2o/core/batch_stats.h"
 #include "g2o/core/estimate_propagator.h"
@@ -45,7 +46,6 @@
 #include "g2o/core/robust_kernel_factory.h"
 #include "g2o/core/sparse_optimizer.h"
 #include "g2o/core/sparse_optimizer_terminate_action.h"
-#include "g2o/stuff/command_args.h"
 #include "g2o/stuff/filesys_tools.h"
 #include "g2o/stuff/logger.h"
 #include "g2o/stuff/macros.h"
@@ -112,91 +112,34 @@ struct IncrementalEdgesCompare {
 
 int main(int argc, char** argv) {
   OptimizableGraph::initMultiThreading();
-  int maxIterations;
-  bool verbose;
+  int maxIterations = 5;
+  bool verbose = false;
   std::string inputFilename;
   std::string outputfilename;
   std::string solverProperties;
-  std::string strSolver;
+  std::string strSolver = "gn_var";
   std::string loadLookup;
-  bool initialGuess;
-  bool initialGuessOdometry;
-  bool marginalize;
-  bool listTypes;
-  bool listSolvers;
-  bool listRobustKernels;
-  bool incremental;
-  int gaugeId;
+  bool initialGuess = false;
+  bool initialGuessOdometry = false;
+  bool marginalize = false;
+  bool listTypes = false;
+  bool listSolvers = false;
+  bool listRobustKernels = false;
+  bool incremental = false;
+  int gaugeId = -1;
   std::string robustKernel;
-  bool computeMarginals;
-  bool printSolverProperties;
-  double huberWidth;
-  double gain;
-  int maxIterationsWithGain;
+  bool computeMarginals = false;
+  bool printSolverProperties = false;
+  double huberWidth = -1.;
+  double gain = 1e-6;
+  int maxIterationsWithGain = std::numeric_limits<int>::max();
   // double lambdaInit;
   int updateGraphEachN = 10;
   std::string statsFile;
   std::string summaryFile;
-  bool nonSequential;
+  bool nonSequential = false;
   // command line parsing
   std::vector<int> gaugeList;
-  g2o::CommandArgs arg;
-  arg.param("i", maxIterations, 5,
-            "perform n iterations, if negative consider the gain");
-  arg.param("gain", gain, 1e-6, "the gain used to stop optimization");
-  arg.param("ig", maxIterationsWithGain, std::numeric_limits<int>::max(),
-            "Maximum number of iterations with gain enabled");
-  arg.param("v", verbose, false, "verbose output of the optimization process");
-  arg.param("guess", initialGuess, false,
-            "initial guess based on spanning tree");
-  arg.param("guessOdometry", initialGuessOdometry, false,
-            "initial guess based on odometry");
-  arg.param("inc", incremental, false, "run incremetally");
-  arg.param("update", updateGraphEachN, 10, "updates after x odometry nodes");
-  arg.param("marginalize", marginalize, false, "on or off");
-  arg.param("printSolverProperties", printSolverProperties, false,
-            "print the properties of the solver");
-  arg.param("solverProperties", solverProperties, "",
-            "set the internal properties of a solver,\n\te.g., "
-            "initialLambda=0.0001,maxTrialsAfterFailure=2");
-  arg.param("robustKernel", robustKernel, "", "use this robust error function");
-  arg.param("robustKernelWidth", huberWidth, -1.,
-            "width for the robust Kernel (only if robustKernel)");
-  arg.param("computeMarginals", computeMarginals, false,
-            "computes the marginal covariances of something. FOR TESTING ONLY");
-  arg.param("gaugeId", gaugeId, -1, "force the gauge");
-  arg.param("o", outputfilename, "", "output final version of the graph");
-  arg.param("solver", strSolver, "gn_var",
-            "specify which solver to use underneat\n\t {gn_var, lm_fix3_2, "
-            "gn_fix6_3, lm_fix7_3}");
-#ifndef G2O_DISABLE_DYNAMIC_LOADING_OF_LIBRARIES
-  std::string dummy;
-  arg.param("solverlib", dummy, "",
-            "specify a solver library which will be loaded");
-  arg.param("typeslib", dummy, "",
-            "specify a types library which will be loaded");
-#endif
-  arg.param("stats", statsFile, "", "specify a file for the statistics");
-  arg.param("listTypes", listTypes, false, "list the registered types");
-  arg.param("listRobustKernels", listRobustKernels, false,
-            "list the registered robust kernels");
-  arg.param("listSolvers", listSolvers, false, "list the available solvers");
-  arg.param("renameTypes", loadLookup, "",
-            "create a lookup for loading types into other types,\n\t "
-            "TAG_IN_FILE=INTERNAL_TAG_FOR_TYPE,TAG2=INTERNAL2\n\t e.g., "
-            "VERTEX_CAM=VERTEX_SE3:EXPMAP");
-  arg.param("gaugeList", gaugeList, std::vector<int>(),
-            "set the list of gauges separated by commas without spaces \n  "
-            "e.g: 1,2,3,4,5 ");
-  arg.param("summary", summaryFile, "",
-            "append a summary of this optimization run to the summary file "
-            "passed as argument");
-  arg.paramLeftOver("graph-input", inputFilename, "",
-                    "graph file which will be processed", true);
-  arg.param("nonSequential", nonSequential, false,
-            "apply the robust kernel only on loop closures and not odometries");
-
-  arg.parseArgs(argc, argv);
 
 #ifndef G2O_DISABLE_DYNAMIC_LOADING_OF_LIBRARIES
   // registering all the types from the libraries
@@ -209,6 +152,84 @@ int main(int argc, char** argv) {
   if (verbose) cout << "# linked version of g2o\n";
 #endif
 
+  const std::vector<std::string> available_solvers = []() {
+    std::vector<std::string> solvers;
+    solvers.reserve(
+        OptimizationAlgorithmFactory::instance()->creatorList().size());
+    for (const auto& creator :
+         OptimizationAlgorithmFactory::instance()->creatorList()) {
+      solvers.emplace_back(creator->property().name);
+    }
+    return solvers;
+  }();
+
+  CLI::App app{"g2o's CLI"};
+  argv = app.ensure_utf8(argv);
+
+  app.add_option("-i,--iterations", maxIterations,
+                 "perform n iterations, if negative consider the gain")
+      ->check(CLI::Range(-1, 100000))
+      ->capture_default_str();
+  app.add_option("--gain", gain, "the gain used to stop optimization");
+  app.add_option("--iterations_gain", maxIterationsWithGain,
+                 "Maximum number of iterations with gain enabled");
+  app.add_flag("-v", verbose, "verbose output of the optimization process");
+  app.add_flag("--guess", initialGuess, "initial guess based on spanning tree");
+  app.add_flag("--guess_odometry", initialGuessOdometry,
+               "initial guess based on odometry");
+  app.add_flag("--inc", incremental, "run incrementally");
+  app.add_option("--update", updateGraphEachN,
+                 "updates after x odometry nodes");
+  app.add_flag("--marginalize", marginalize, "marginalize landmarks");
+  app.add_flag("--print_solver_properties", printSolverProperties,
+               "print the properties of the solver");
+  app.add_option("--solver_properties", solverProperties,
+                 "set the internal properties of a solver, e.g., "
+                 "initialLambda=0.0001,maxTrialsAfterFailure=2");
+  app.add_option("--robust_kernel", robustKernel,
+                 "use this robust error function");
+  app.add_option("--robust_kernel_width", huberWidth,
+                 "width for the robust Kernel (only if robustKernel)");
+  app.add_flag(
+      "--compute_marginals", computeMarginals,
+      "computes the marginal covariances of something. FOR TESTING ONLY");
+  app.add_option("--gauge_id", gaugeId, "force the gauge");
+  app.add_option("-o,--output", outputfilename,
+                 "output final version of the graph");
+  app.add_option("--solver", strSolver,
+                 "specify which solver to use underneath")
+      ->check(CLI::IsMember(available_solvers));
+#ifndef G2O_DISABLE_DYNAMIC_LOADING_OF_LIBRARIES
+  std::string dummy;
+  app.add_option("--solverlib", dummy,
+                 "specify a solver library which will be loaded");
+  app.add_option("--typeslib", dummy,
+                 "specify a types library which will be loaded");
+#endif
+  app.add_option("--stats", statsFile, "specify a file for the statistics");
+  app.add_flag("--list_types", listTypes, "list the registered types");
+  app.add_flag("--list_robust_kernels", listRobustKernels,
+               "list the registered robust kernels");
+  app.add_flag("--list_solvers", listSolvers, "list the available solvers");
+  app.add_option("--rename_types", loadLookup,
+                 "create a lookup for loading types into other types, "
+                 "TAG_IN_FILE=INTERNAL_TAG_FOR_TYPE,TAG2=INTERNAL2, e.g., "
+                 "VERTEX_CAM=VERTEX_SE3:EXPMAP");
+  app.add_option("--gauge_list", gaugeList,
+                 "set the list of gauges separated by commas without spaces, "
+                 "e.g: 1 2 3 4 5");
+  app.add_option(
+      "--summary", summaryFile,
+      "append a summary of this optimization run to the summary file "
+      "passed as argument");
+  app.add_flag(
+      "--non_sequential", nonSequential,
+      "apply the robust kernel only on loop closures and not odometries");
+  app.add_option("input", inputFilename, "graph file which will be processed")
+      ->check(CLI::ExistingFile);
+
+  CLI11_PARSE(app, argc, argv);
+
   OptimizationAlgorithmFactory* solverFactory =
       OptimizationAlgorithmFactory::instance();
   if (listSolvers) {
@@ -411,10 +432,6 @@ int main(int argc, char** argv) {
             "the binary g2o_incremental"
          << '\n';
     int incIterations = maxIterations;
-    if (!arg.parsedParam("i")) {
-      cerr << "# Setting default number of iterations\n";
-      incIterations = 1;
-    }
     int maxDim = 0;
 
     cerr << "# incremental settings\n";

g2o/apps/g2o_cli/g2o_common.cpp

@@ -120,7 +120,8 @@ void loadStandardTypes(DlWrapper& dlTypesWrapper, int argc, char** argv) {
   }
 
   std::vector<std::string> libs;
-  if (argc > 0 && argv != nullptr) findArguments("-typeslib", libs, argc, argv);
+  if (argc > 0 && argv != nullptr)
+    findArguments("--typeslib", libs, argc, argv);
   for (const auto& lib : libs) {
     G2O_INFO("Loading types {}", lib);
     dlTypesWrapper.openLibrary(lib);
@@ -156,7 +157,7 @@ void loadStandardSolver(DlWrapper& dlSolverWrapper, int argc, char** argv) {
 
   std::vector<std::string> libs;
   if (argc > 0 && argv != nullptr)
-    findArguments("-solverlib", libs, argc, argv);
+    findArguments("--solverlib", libs, argc, argv);
   for (const auto& lib : libs) {
     G2O_INFO("Loading solver {}", lib);
     dlSolverWrapper.openLibrary(lib);

g2o/apps/g2o_simulator/CMakeLists.txt

@@ -1,13 +1,15 @@
 add_executable(g2o_simulator2d_application
   g2o_simulator2d.cpp
 )
-target_link_libraries(g2o_simulator2d_application simulator_lib types_slam2d_addons types_slam2d core)
+target_link_libraries(g2o_simulator2d_application PRIVATE simulator_lib types_slam2d_addons types_slam2d core)
+target_link_libraries(g2o_simulator2d_application PRIVATE CLI11::CLI11)
 set_target_properties(g2o_simulator2d_application PROPERTIES OUTPUT_NAME g2o_simulator2d)
 
 add_executable(g2o_simulator3d_application
   g2o_simulator3d.cpp
 )
-target_link_libraries(g2o_simulator3d_application simulator_lib types_slam3d_addons types_slam3d types_slam2d_addons types_slam2d core)
+target_link_libraries(g2o_simulator3d_application PRIVATE simulator_lib types_slam3d_addons types_slam3d types_slam2d_addons types_slam2d core)
+target_link_libraries(g2o_simulator3d_application PRIVATE CLI11::CLI11)
 set_target_properties(g2o_simulator3d_application PROPERTIES OUTPUT_NAME g2o_simulator3d)
 
 install(TARGETS g2o_simulator2d_application g2o_simulator3d_application

g2o/apps/g2o_simulator/g2o_simulator2d.cpp

@@ -28,58 +28,77 @@
 #include <fstream>
 #include <iostream>
 
+#include "CLI/CLI.hpp"
 #include "g2o/core/optimizable_graph.h"
 #include "g2o/simulator/simulator.h"
 #include "g2o/simulator/simulator2d_base.h"
-#include "g2o/stuff/command_args.h"
 #include "g2o/stuff/logger.h"
 
 int main(int argc, char** argv) {
-  g2o::CommandArgs arg;
   g2o::Simulator2D::Config simulator_config;
+  // Setting up default
+  simulator_config.nlandmarks = 100;
+  simulator_config.nSegments = 1000;
+  simulator_config.segmentGridSize = 50;
+  simulator_config.minSegmentLength = 0.5;
+  simulator_config.maxSegmentLength = 3;
+  simulator_config.simSteps = 100;
+  simulator_config.worldSize = 25.0;
 
-  G2O_INFO("Running 2D simulator");
+  CLI::App app{"g2o Simulator 2D"};
+  argv = app.ensure_utf8(argv);
 
   std::string outputFilename;
-  arg.param("nlandmarks", simulator_config.nlandmarks, 100,
-            "number of landmarks in the map");
-  arg.param("nSegments", simulator_config.nSegments, 1000,
-            "number of segments");
-  arg.param("segmentGridSize", simulator_config.segmentGridSize, 50,
-            "number of cells of the grid where to align the segments");
-  arg.param("minSegmentLength", simulator_config.minSegmentLength, 0.5,
-            "minimal Length of a segment in the world");
-  arg.param("maxSegmentLength", simulator_config.maxSegmentLength, 3,
-            "maximal Length of a segment in the world");
+  app.add_option("--num_landmarks", simulator_config.nlandmarks,
+                 "number of landmarks in the map")
+      ->check(CLI::NonNegativeNumber);
+  app.add_option("--num_segments", simulator_config.nSegments,
+                 "number of segments")
+      ->check(CLI::NonNegativeNumber);
+  app.add_option("--segment_grid_size", simulator_config.segmentGridSize,
+                 "number of cells of the grid where to align the segments")
+      ->check(CLI::PositiveNumber);
+  app.add_option("--min_segment_length", simulator_config.minSegmentLength,
+                 "minimal Length of a segment in the world")
+      ->check(CLI::NonNegativeNumber);
+  app.add_option("--max_segment_length", simulator_config.maxSegmentLength,
+                 "maximal Length of a segment in the world")
+      ->check(CLI::NonNegativeNumber);
 
-  arg.param("simSteps", simulator_config.simSteps, 100,
-            "number of simulation steps");
-  arg.param("worldSize", simulator_config.worldSize, 25.0, "size of the world");
-  arg.param("hasOdom", simulator_config.hasOdom, false,
-            "the robot has an odometry");
-  arg.param("hasPointSensor", simulator_config.hasPointSensor, false,
-            "the robot has a point sensor");
-  arg.param("hasPointBearingSensor", simulator_config.hasPointBearingSensor,
-            false, "the robot has a point bearing sensor");
-  arg.param("hasPoseSensor", simulator_config.hasPoseSensor, false,
-            "the robot has a pose sensor");
-  arg.param("hasCompass", simulator_config.hasCompass, false,
-            "the robot has a compass");
-  arg.param("hasGPS", simulator_config.hasGPS, false, "the robot has a GPS");
-  arg.param("hasSegmentSensor", simulator_config.hasSegmentSensor, false,
-            "the robot has a segment sensor");
-  arg.paramLeftOver("graph-output", outputFilename, "",
-                    "graph file which will be written", true);
+  app.add_option("--sim_steps", simulator_config.simSteps,
+                 "number of simulation steps")
+      ->check(CLI::PositiveNumber);
+  app.add_option("--world_size", simulator_config.worldSize,
+                 "size of the world")
+      ->check(CLI::PositiveNumber);
+  app.add_flag("--has_odom", simulator_config.hasOdom,
+               "the robot has an odometry");
+  app.add_flag("--has_point_sensor", simulator_config.hasPointSensor,
+               "the robot has a point sensor");
+  app.add_flag("--has_point_bearing_sensor",
+               simulator_config.hasPointBearingSensor,
+               "the robot has a point bearing sensor");
+  app.add_flag("--has_pose_sensor", simulator_config.hasPoseSensor,
+               "the robot has a pose sensor");
+  app.add_flag("--has_compass", simulator_config.hasCompass,
+               "the robot has a compass");
+  app.add_flag("--has_gps", simulator_config.hasGPS, "the robot has a GPS");
+  app.add_flag("--has_segment_sensor", simulator_config.hasSegmentSensor,
+               "the robot has a segment sensor");
+  app.add_option("graph-output", outputFilename,
+                 "graph file which will be written ('-' for stdout)")
+      ->required();
 
-  arg.parseArgs(argc, argv);
+  CLI11_PARSE(app, argc, argv);
 
+  G2O_INFO("Running 2D simulator");
   g2o::Simulator2D simulator(std::move(simulator_config));
   G2O_INFO("Setting up");
   simulator.setup();
   G2O_INFO("Simulate");
   simulator.simulate();
 
-  if (outputFilename.empty()) {
+  if (outputFilename == "-") {
     G2O_INFO("Saving to stdout");
     simulator.world().graph().save(std::cout);
   } else {