File main.cpp

File List > benchmark > main.cpp

Go to the documentation of this file

#include <fstream>
#include <iostream>

#include "metrics/CLI_Metrics_config.cpp"
#include "../src/algos/mesh_to_pointcloud/CLI_MTP_config.cpp"
#include "../src/algos/pointcloud_to_mesh/CLI_PTM_config.cpp"

#include <CLI/CLI.hpp>
#include <benchmark/benchmark.h>
#include <nlohmann/json_fwd.hpp>

#include "exporter/basic_formatter.h"
#include "exporter/xlsx_exporter.h"
#include "BenchmarksContainer.h"
#include "reporter/reporter.h"

std::vector<char*> getConfigJSON(const std::string& filepath);

using namespace Argos;

const std::string XLSX_FILENAME = "rapport.xlsx";

int main(int argc, char **argv) {

    // 0. Pre-traitement : si --config est present, on reecrit argc/argv avec le contenu du fichier de config
    std::vector<char*> configArgv;
    for (int i = 1; i < argc - 1; ++i) {
        if (std::string(argv[i]) == "--config") {
            configArgv = getConfigJSON(argv[i + 1]);
            argc = static_cast<int>(configArgv.size());
            argv = configArgv.data();
            break;
        }
    }

  CLI::App app{"Argos Benchmark"};
  app.fallthrough();

  // 1. Commande benchmark

  // 1.1 Dossier entrée qui contient fichiers .obj
  std::string inputFolder;

  auto *input = app.add_option("-i, --input", inputFolder,
                 "Chemin du dossier qui contient tous les fichiers .obj/.ply à "
                 "traiter pour le benchmark");

  // 1.2 Algorithmes de génération d'un nuage de points;
  auto *algoSamplerGroup = app.add_option_group(
      "Algorithmes Points",
      "Choisissez un algorithme de generation d'un nuage de points");

  // On ajoute tous les algos
  std::shared_ptr<ISurfaceSampler> algoSampler;

  addAlgosMeshToPointcloud(*algoSamplerGroup, algoSampler);

  algoSamplerGroup->require_subcommand(1);

  // 1.3 Algrotihmes de reconstruction d'un maillage
  auto *algoReconstructGroup = app.add_option_group(
      "Algorithmes Mesh",
      "Choisissez un algorithme de reconstruction d'un maillage");

  // On ajoute tous les algos
  std::vector<std::shared_ptr<ISurfaceReconstructor>> algosReconstruct;

  addAlgosPointcloudToMesh(*algoReconstructGroup, algosReconstruct);

  algoReconstructGroup->require_subcommand(1);

  // 1.4 Ajout des métriques
  auto *metricsGroup = app.add_option_group(
      "Metriques", "Choisissez une ou plusieurs metriques");

  // On ajoute toutes les métriques
  std::vector<std::shared_ptr<Metric>> metrics;

  addMetrics(*metricsGroup, metrics);

  // 2. Ajout option config (fichier config)
  std::string configFile;
  auto *config = app.add_option("--config", configFile,
                            "Choisir un fichier de configuration JSON au lieu de siasir la commande");

  // Ajout exclusions
  input->excludes(config);
  algoSamplerGroup->excludes(config);
  algoReconstructGroup->excludes(config);
  metricsGroup->excludes(config);


  // 3. Parsing
  CLI11_PARSE(app, argc, argv);

  // 4. Execution du benchmark
  if (app.parsed()) {
      // Vérification si le chemin saisi est bien un dossier
      if (!std::filesystem::exists(inputFolder) ||
          !std::filesystem::is_directory(inputFolder)) {
          throw std::runtime_error("Entrer : Dossier introuvable");
      }

      benchmark::Initialize(&argc, argv);


      //Création du dossier de sortie
      auto now = std::chrono::system_clock::now();
      auto t = std::chrono::system_clock::to_time_t(now);
      std::tm tm = *std::localtime(&t);

      std::ostringstream oss;
      oss << std::put_time(&tm, "%Y-%m-%d_%H-%M-%S");

      std::filesystem::path outputFolderPath = std::filesystem::path(inputFolder) / "output" / oss.str();

      std::filesystem::create_directories(outputFolderPath);

      //Ajout des Benchmarks
      BenchmarksContainer runner(std::filesystem::path(inputFolder), outputFolderPath);


      for (std::shared_ptr<ISurfaceReconstructor> algo : algosReconstruct) {
          runner.addBenchmark(algo->name(), algo, metrics);
      }

      BenchmarkReporter reporter;
      runner.run(&reporter, algoSampler);

      // Export vers Excel
      std::filesystem::path outputPath = outputFolderPath / XLSX_FILENAME;

      BasicFormatter formatter;
      XLSXExporter exporter(formatter);

      std::ofstream outFile(outputPath, std::ios::binary);
      if (!outFile) {
          std::cerr << "Erreur : impossible de creer le fichier " << outputPath
                    << std::endl;
          return 1;
      }

      exporter.Export(reporter.result(), outFile);
      outFile.close();

      std::cout << "Benchmark termine ! Rapport exporte vers : " << outputPath
                << std::endl;


      return 0;
  }
}