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_ */