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