src/tools/lvr2_image_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 image_normals
{

using namespace boost::program_options;

class Options
{
public:

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


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


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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

private:

        variables_map m_variables;

        options_description m_descr;

        positional_options_description m_pdescr;

    int         m_minH;
    int         m_maxH;
    int         m_minV;
    int         m_maxV;
    int         m_width;
    int         m_height;
    int         m_windowWidth;
    int         m_windowHeight;
    float       m_minZ;
    float       m_maxZ;
    float       m_minZimg;
    float       m_maxZimg;
    string      m_imageOut;
    string      m_system;
};

inline ostream& operator<<(ostream& os, const Options& o)
{
    os << "##### Panorama normal estimation settings #####" << endl;
    os << "Horizontal field of view\t: "   << o.minH() << " x " << o.maxH() << endl;
    os << "Vertical field of view\t\t: "   << o.minV() << " x " << o.maxV() << endl;
    os << "Image Dimensions\t\t: " << o.imageWidth() << " x " << o.imageHeight() << endl;
    os << "Z range (scan) \t\t\t: " << o.minZ() << " to " << o.maxZ() << endl;
    os << "Z range (img)\t\t\t: " << o.minZimg() << " to " << o.maxZimg() << endl;
    os << "Optimize aspect\t\t\t: " << o.optimize() << endl;
    os << "Coordinate system\t\t: " << o.coordinateSystem() << endl;
    return os;
}

} // namespace normals

#endif