src/tools/lvr2_cuda_normals/Options.hpp

Go to the documentation of this file.

#ifndef OPTIONS_H_
#define OPTIONS_H_

#include <iostream>
#include <string>
#include <vector>
#include <boost/program_options.hpp>

using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::ostream;


namespace cuda_normals
{

using namespace boost::program_options;

class Options
{
public:

    Options(int argc, char** argv);
    virtual ~Options();

    string  outputFile() const
    {
        return (m_variables["outputFile"].as<string>());
    }



    string  inputFile() const
    {
        return (m_variables["inputFile"].as< vector<string> >())[0];
    }

    bool    useRansac() const
    {
        return (m_variables.count("ransac"));
    }

    bool    usePCA() const
    {
        return (m_variables.count("pca"));
    }

    float     flipx() const
    {
        return m_variables["flipx"].as<float>();
    }

    float     flipy() const
    {
        return m_variables["flipy"].as<float>();
    }

    float     flipz() const
    {
        return m_variables["flipz"].as<float>();
    }

    int     kn() const
    {
        return m_variables["kn"].as<int>();
    }

    int     ki() const
    {
        return m_variables["ki"].as<int>();
    }

    int        kd() const
    {
        return m_variables["kd"].as<int>();
    }

    float     getVoxelsize() const
    {
        return m_variables["voxelsize"].as<float>();
    }

    bool     useVoxelSize() const
    {
        return m_variables.count("voxelsize");
    }

    bool     reconstruct() const
    {
        return m_variables.count("reconstruct");
    }

    bool    exportPointNormals() const
    {
        return m_variables.count("exportPointNormals");
    }

private:

    variables_map m_variables;

    options_description m_descr;

    positional_options_description m_pdescr;

    float         m_flipx;
    float          m_flipy;
    float           m_flipz;
    int              m_kn;
    int           m_ki;
    int              m_kd;
    float          m_voxelsize;
    string        m_outputFile;
};

inline ostream& operator<<(ostream& os, const Options& o)
{
    os << "##### Cuda normal estimation settings #####" << endl;
    if(o.useRansac()){
        os << "Normal Calculation with RANSAC" << endl;
    }else if(o.usePCA()){
        os << "Normal Calculation with PCA" << endl;
    }else{
        os << "Normal Calculation with PCA" << endl;
    }
    os << "Neighbors for normal estimation: "<< o.kn() << endl;
    os << "Neighbors for normal interpolation: " << o.ki() << endl;
    os << "Neighbors for distance function: " << o.kd() << endl;
    os << "Flippoint x: " << o.flipx() << endl;
    os << "Flippoint y: " << o.flipy() << endl;
    os << "Flippoint z: " << o.flipz() << endl;

    return os;
}

} // namespace normals

#endif