File main.cpp

File List > src > main.cpp

Go to the documentation of this file

#include <iostream>

#include "../include/mesh/Face.h"
#include "mesh/Mesh.h"
#include "../include/serializer/ObjSerializer.h"

#include "core/algos/mesh_to_pointcloud/CLI_MTP_config.cpp"

#include <CLI/CLI.hpp>
#include <nlohmann/json.hpp>

#include "point_cloud/PointCloud.h"


using namespace Argos;


int main(int argc, char **argv) {
    CLI::App app{"Argos"};




    // 1. Commande principale | Lance un algorithme
    ObjSerializer serializer = ObjSerializer();

    auto *run = app.add_subcommand("run", "Lance le programme pricipal de conversion");



    // 1.1 Objet entrée
    std::string inputFile;

    run->add_option("-i, --input", inputFile,
                "Utiliser un fichier (chemin du fichier) en entree au lieu de l'entree standard (stdin)");



    // 1.2 Ajout des algos de construction d'un nuage de points et de reconstruction d'un maillage
    PointCloud result_MTP;
    Mesh result_PTM;

    auto *algoGroup = run->add_option_group("Algorithmes", "Choisissez un algorithme");

    // On ajoute tous les algos
    PointCloud* pc = nullptr;
    Mesh* mesh = nullptr;

    addAlgosMeshToPointcloud(*algoGroup, mesh, result_MTP);
    //addAlgosPointcloudToMesh(...);

    algoGroup->require_subcommand(1);



    // 1.3 Ajout chemin fichier de sortie
    std::string outputFile;
    run->add_option("-o,--output", outputFile,
            "Utiliser un fichier (chemin du fichier) en sortie au lieu de la sortie standard (stdout)");


    // 1.4 Execution run
    run->callback([&pc, &mesh, &serializer, &inputFile]() {

        // Récupération infos objet
        std::vector<Vector3D<double>> vertices;
        std::vector<Face> faces;


        if (!inputFile.empty()) {
            std::ifstream file(inputFile);

            if (!file.is_open()) {
                std::cerr << "Erreur : impossible d'ouvrir le fichier " << inputFile << std::endl;
                throw std::runtime_error("Impossible d'ouvrir le fichier " + inputFile);
            }

            serializer.deserialize(vertices, faces, file);

            file.close();
        } else {
            serializer.deserialize(vertices, faces, std::cin);
        }


        // Conversion en objet Mesh ou PointCloud
        if (faces.empty()) {
            pc = new PointCloud(vertices);
        }
        else {
            mesh = new Mesh(vertices, faces);
        }
    });
    run->immediate_callback();













    // 2. Commande info_algos | Informations algorithmes disponibles et leurs paramètres
    auto *info = app.add_subcommand("info_algos",
    "Retourne les differents algorithmes disponibles ainsi que leurs potentiels parametres");

    info->callback([&algoGroup]() {
        nlohmann::json json;

        // Liste des algorithmes
        std::vector<CLI::App *> algorithms = algoGroup->get_subcommands([](const CLI::App*){ return true; });
        json["algos"] = nlohmann::json::array();

        for (CLI::App *algo: algorithms) {
            if (algo->get_name() == "info_algos") continue;

            nlohmann::json json_algo;
            json_algo["name"] = algo->get_name();
            json_algo["description"] = algo->get_description();
            json_algo["params"] = nlohmann::json::array();

            // Paramètres de l'algo
            std::vector<CLI::Option *> params = algo->get_options();
            nlohmann::json json_params;
            for (CLI::Option* p : params) {
                json_params["args"] = p->get_name(false, true);
                json_params["description"] = p->get_description();
                json_params["isRequired"] = p->get_required();

                json_algo["params"].emplace_back(json_params);
            }

            json["algos"].emplace_back(json_algo);
        }

        std::cout << json << std::endl;
    });






    // 1 seul choix possible
    app.require_subcommand(1);


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


    if (run->parsed()) {
        std::cout<<"SORTIE";
        if (result_MTP.empty() && result_PTM.getFaces().empty() && result_PTM.getVertices().empty()) {
            throw std::runtime_error("Sortie : Impossible de convertir en obj");
        }

        if (outputFile.empty()) {
            if (result_MTP.empty()) {
                serializer.serialize(result_PTM.getVertices(), result_PTM.getFaces(), std::cout);
            }
            else if (result_PTM.getFaces().empty() && result_PTM.getVertices().empty()) {
                std::vector<Face> f;
                serializer.serialize(result_MTP.getPoints(), f, std::cout);
            }
        }
        else {
            std::ofstream file(outputFile);
            if (!file.is_open()) {
                std::cerr << "Erreur : impossible d'ouvrir le fichier " << outputFile << std::endl;
                throw std::runtime_error("Impossible d'ouvrir le fichier " + outputFile);
            }

            if (result_MTP.empty()) {
                serializer.serialize(result_PTM.getVertices(), result_PTM.getFaces(), file);
            }
            else if (result_PTM.getFaces().empty() && result_PTM.getVertices().empty()) {
                std::vector<Face> f;
                serializer.serialize(result_MTP.getPoints(), f, file);
            }

            file.close();

            std::cout << "Conversion terminee avec succes !" << std::endl;
        }

    }

    return 0;
}