File CLI_MTP_config.cpp

File List > algos > mesh_to_pointcloud > CLI_MTP_config.cpp

Go to the documentation of this file

#include <CLI/CLI.hpp>

#include "mesh_to_pointcloud/CentroidSampler.h"
#include "mesh_to_pointcloud/Naive.h"
#include "mesh_to_pointcloud/UniformAreaSampler.h"
#include "mesh_to_pointcloud/UniformPerFaceSampler.h"
#include "mesh_to_pointcloud/PointsPerFaceSampler.h"
#include "mesh_to_pointcloud/DensitySampler.h"

using namespace Argos;

// --- Doc :
// Ajouter algo : auto* cmd = group.add_subcommand("nom_algo", "description_algo");
// Ajouter option (paramètre à fournir à l'algo) : cmd->add_option("-nom_option", valeur_par_defaut, "description_option");
// Si option est obligatoire : cmd->required();

void static addAlgosMeshToPointcloud(CLI::Option_group& group, Mesh*& mesh, PointCloud& result) {
    auto *naif = group.add_subcommand("naive", "Lance l'algorithme naif qui convertit un objet en nuage de points");
    naif->callback([&result, &mesh]() {
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        Naive naive;
        result = naive.sample(*mesh);
    });



    auto* centroid = group.add_subcommand("centroid", "Place un point au centre de chaque face");
    centroid->callback([&result, &mesh]() {
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        CentroidSampler centroid;
        result = centroid.sample(*mesh);
    });



    auto* uniformArea = group.add_subcommand("uniform_area", "Répartit un nombre total de points proportionnellement aux surfaces");
    uniformArea->add_option("-p,--points", "Nombre total de points")->required()
    ->each([&result, &mesh](const std::string val) {
        int nbPointsArea = std::stoi(val);
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        UniformAreaSampler UASampler(nbPointsArea);
        result = UASampler.sample(*mesh);
    });


    auto* uniformPerFace_1 = group.add_subcommand("uniform_face_1", "Génère un nombre (répartie) identique de points sur chaque face du maillage");
    uniformPerFace_1->add_option("-p,--points", "Nombre total de points à répartir par face sur l'objet")->required()
    ->each([&result, &mesh](const std::string val) {
        int nbPoints = std::stoi(val);
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        UniformPerFaceSampler UPFSampler(nbPoints);
        result = UPFSampler.sample(*mesh);
    });


    auto* uniformPerFace_2 = group.add_subcommand("uniform_face_2", "Génère un nombre identique de points sur chaque face du maillage");
    uniformPerFace_2->add_option("-p,--points", "Nombre de points par face")->required()
    ->each([&result, &mesh](const std::string val) {
        int nbPointsPerFace = std::stoi(val);
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        PointsPerFaceSampler PPFSampler(nbPointsPerFace);
        result = PPFSampler.sample(*mesh);
    });

    auto* DensitySampler = group.add_subcommand("densitySampler", "Génère un nombre de points en fonction par unité de surface (densité)");
    DensitySampler->add_option("-d,--density", "Densité (Nombre de points/unité de surface")->required()
    ->each([&result, &mesh](const std::string val) {
        int density = std::stoi(val);
        if (mesh == nullptr) {
            throw std::runtime_error("Algo : Mesh introuvable...");
        }

        DensitySampler DSampler(density);
        result = DSampler.sample(*mesh);
    });
}