ext/kintinuous/kfusion/include/kfusion/Options.hpp

Go to the documentation of this file.

/* Copyright (C) 2011 Uni Osnabrück
 * This file is part of the LAS VEGAS Reconstruction Toolkit,
 *
 * LAS VEGAS is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * LAS VEGAS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
 */


 /*
 * Options.hpp
 *
 *  Created on: Sep 17, 2015
 *      Author: Thomas Wiemann
 *      Author: Tristan Igelbrink
 */

#ifndef OPTIONS_H_
#define OPTIONS_H_

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

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


namespace kfusion{

using namespace boost::program_options;

class Options {
public:

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

        int     getNumThreads() const;

        bool    printUsage() const;

        bool    colorRegions() const;

        bool    optimizePlanes() const;

        bool    textures() const;

        bool    noVizualisation() const;

        bool    noReconstruction() const;

        bool    verbose() const;

        bool    clusterPlanes() const;

        string  getInputDevice() const;

        string getOutput() const;

        string  getClassifier() const;

        int getPlaneIterations() const;

        float getNormalThreshold() const;

        int   getSmallRegionThreshold() const;

        int   getMinPlaneSize() const;

        int   getCleanContourIterations() const;

        int   getDanglingArtifacts() const;

        int   getFillHoles() const;

        float    getShiftingDistance() const;

        float    getCameraOffset() const;

        int getDepth() const;

    float getLineFusionThreshold() const;


private:

        string                                                  m_device ;
    string                                                  m_mesh_name;
    bool                                                        m_no_reconstruct;
    bool                                                        m_optimize;
    bool                                                        m_no_viz;
    float                                                       m_cam_offset;
    float                                                       m_shifting_distance;
        int                                             m_numThreads;

        variables_map                           m_variables;

        options_description                 m_descr;

        positional_options_description  m_pdescr;

        int                             m_numberOfDefaults;

        int                             m_planeIterations;

        float                           m_planeNormalThreshold;

        int                             m_smallRegionThreshold;

        int                             m_rda;

        int                             m_fillHoles;

        int                             m_minPlaneSize;

        int                                                             m_depth;

        int                                                             m_cleanContourIterations;

        float                           m_lineFusionThreshold;

        string                                                  m_classifier;

};


inline ostream& operator<<(ostream& os, const Options &o)
{
        cout << "##### Program options: " << endl;

        cout << "##### Number of threads \t\t: "    << o.getNumThreads()      << endl;


        cout << "##### Using Device \t\t\t: " << o.getInputDevice()  << endl;
        cout << "##### Saving mesh to \t\t\t: " << o.getOutput() << endl;
        cout << "##### Using shifting distance \t\t: " << o.getShiftingDistance() << endl;
        cout << "##### Using camera offset \t\t: " << o.getCameraOffset() << endl;

        if(o.noVizualisation())
        {
                 cout << "##### Live visualization \t\t: NO"  << endl;
        }
        else
                cout << "##### Live visualization \t\t: YES"  << endl;

        if(o.noReconstruction())
        {
                 cout << "##### Online reconstruction \t\t: NO"  << endl;
        }
        else
                cout << "##### Online reconstruction \t\t: YES"  << endl;

        if(o.getFillHoles())
        {
            cout << "##### Fill holes \t\t\t: " << o.getFillHoles() << endl;
        }
        else
        {
            cout << "##### Fill holes \t\t\t: NO" << endl;
        }

        if(o.getDanglingArtifacts())
        {
            cout << "##### Remove DAs \t\t\t: " << o.getDanglingArtifacts() << endl;
        }
        else
        {
            cout << "##### Remove DAs \t\t\t: NO" << endl;
        }

        if(o.optimizePlanes())
        {
                cout << "##### Optimize Planes \t\t\t: YES" << endl;
                cout << "##### Plane iterations \t\t\t: " << o.getPlaneIterations() << endl;
                cout << "##### Normal threshold \t\t\t: " << o.getNormalThreshold() << endl;
                cout << "##### Region threshold \t\t\t: " << o.getSmallRegionThreshold() << endl;
        }
        if(o.textures())
                cout << "##### Live texturing \t\t\t: YES" << endl;
        else
                cout << "##### Live texturing \t\t\t: NO" << endl;
        if(o.getDepth())
        {
            cout << "##### Recursion depth \t\t\t: " << o.getDepth() << endl;
        }
        if(o.verbose())
        {
                cout << "##### Verbose output \t\t\t: YES" << endl;
        }
        return os;
}

} // namespace reconstruct


#endif /* OPTIONS_H_ */