src/tools/lvr2_chunking/Options.cpp

Go to the documentation of this file.

 
#include "Options.hpp"
 
#include <iostream>
 
namespace chunking
{
 
using boost::program_options::command_line_parser;
using boost::program_options::value;
using std::cout;
using std::endl;
 
Options::Options(int argc, char** argv) : m_descr("Supported options")
{
    // Create option descriptions
    m_descr.add_options()("help",
                          "Produce help message")("inputFile", value<std::vector<string>>()->multitoken(), "Input file names.")(
        "outputDir", value<string>(), "Output directory name.")(
        "chunkSize", value<float>()->default_value(10.0f), "Side length of chunks.")(
        "maxChunkOverlap", value<float>()->default_value(0.1f),
        "maximum allowed overlap between chunks relative to the chunk size.")(
        "chunkedMesh", value<string>(), "Chunked mesh hdf5-file name.")(
        "load", value<bool>()->default_value(false), "Set this value to true, if you want to load an hdf5-file")(
        "x_min", value<float>()->default_value(0.0f), "bounding box minimum value in x-dimension")(
        "y_min", value<float>()->default_value(0.0f), "bounding box minimum value in y-dimension")(
        "z_min", value<float>()->default_value(0.0f), "bounding box minimum value in z-dimension")(
        "x_max", value<float>()->default_value(10.0f), "bounding box maximum value in x-dimension")(
        "y_max", value<float>()->default_value(10.0f), "bounding box maximum value in y-dimension")(
        "z_max", value<float>()->default_value(10.0f), "bounding box maximum value in z-dimension")(
        "cacheSize", value<int>()->default_value(200), "while loading the maximum number of chunks in RAM")(
        "meshName", value<std::string>()->default_value(""), "group name of the mesh if the HDF5 contains multiple meshes");
 
    // Parse command line and generate variables map
    store(command_line_parser(argc, argv).options(m_descr).positional(m_posDescr).run(),
          m_variables);
    notify(m_variables);
}
 
bool Options::printUsage() const
{
    if (m_variables.count("help"))
    {
        cout << m_descr << endl;
        return true;
    }
 
    if (!m_variables.count("inputFile") && !getLoad())
    {
        cout << "Error: You must specify an input file." << endl;
        cout << endl;
        cout << m_descr << endl;
        return true;
    }
 
    if(getLoad() && !m_variables.count("chunkedMesh"))
    {
        cout << "Error: You must specify an hdf5-file (\"chunkedMesh\") when loading." << endl;
        cout << endl;
        cout << m_descr << endl;
        return true;
    }
 
    return false;
}
 
std::vector<string> Options::getInputFile() const
{
 
    return m_variables["inputFile"].as<std::vector<string>>();
}
 
string Options::getOutputDir() const
{
    return m_variables["outputDir"].as<string>();
}
 
float Options::getChunkSize() const
{
    return m_variables["chunkSize"].as<float>();
}
 
float Options::getMaxChunkOverlap() const
{
    return m_variables["maxChunkOverlap"].as<float>();
}
string Options::getChunkedMesh() const
{
    return m_variables["chunkedMesh"].as<string>();
}
bool Options::getLoad() const
{
    return m_variables["load"].as<bool>();
}
 
float Options::getXMin() const
{
    return m_variables["x_min"].as<float>();
}
float Options::getYMin() const
{
    return m_variables["y_min"].as<float>();
}
float Options::getZMin() const
{
    return m_variables["z_min"].as<float>();
}
float Options::getXMax() const
{
    return m_variables["x_max"].as<float>();
}
float Options::getYMax() const
{
    return m_variables["y_max"].as<float>();
}
float Options::getZMax() const
{
    return m_variables["z_max"].as<float>();
}
int Options::getCacheSize() const
{
    int size = m_variables["cacheSize"].as<int>();
    if(size > 0)
    {
        return size;
    }
    return 200;
}
std::string Options::getMeshGroup() const
{
    return m_variables["meshName"].as<std::string>();
}
 
Options::~Options()
{
    // TODO Auto-generated destructor stub
}
 
} // namespace chunking