src/tools/lvr2_reconstruct/Options.hpp

Go to the documentation of this file.

 
 /*
 * Options.h
 *
 *  Created on: Nov 21, 2010
 *      Author: Thomas Wiemann
 */
 
#ifndef OPTIONS_H_
#define OPTIONS_H_
 
#include <iostream>
#include <string>
#include <vector>
#include <boost/program_options.hpp>
#include <float.h>
 
#include "lvr2/config/BaseOption.hpp"
 
using std::ostream;
using std::cout;
using std::endl;
using std::string;
using std::vector;
 
namespace reconstruct
{
 
class Options : public lvr2::BaseOption{
public:
 
    Options(int argc, char** argv);
    virtual ~Options();
 
    float   getVoxelsize()const;
 
    int     getNumThreads() const;
 
    bool    printUsage() const;
 
    bool    filenameSet() const;
 
    bool    saveFaceNormals() const;
 
    bool    colorRegions() const;
 
    bool    saveNormals() const;
 
    bool    saveGrid() const;
 
    bool    saveOriginalData() const;
 
 
    bool    optimizePlanes() const;
 
    bool    savePointNormals() const;
 
    bool    recalcNormals() const;
 
    bool    useRansac() const;
 
    bool    doTextureAnalysis() const;
 
    bool    generateTextures() const;
 
    int     getKi() const;
 
    int     getKn() const;
 
    int     getKd() const;
 
    bool      retesselate() const;
 
    bool    clusterPlanes() const;
 
    bool    writeClassificationResult() const;
 
    string  getInputFileName() const;
 
    string  getOutputFileName() const;
 
    vector<string>  getOutputFileNames() const;
 
    string  getClassifier() const;
 
    string  getScanPoseFile() const;
 
    int     getIntersections() const;
 
 
    int getPlaneIterations() const;
 
    string getPCM() const;
 
    string getDecomposition() const;
 
 
    float getNormalThreshold() const;
 
    int   getSmallRegionThreshold() const;
 
    int   getMinPlaneSize() const;
 
    int   getCleanContourIterations() const;
 
    int   getDanglingArtifacts() const;
 
    int   getFillHoles() const;
 
    float getTexelSize() const;
 
    float getSharpFeatureThreshold() const;
 
    float getSharpCornerThreshold() const;
 
    float getLineFusionThreshold() const;
 
    bool extrude() const;
 
    float getEdgeCollapseReductionRatio() const;
 
 
    unsigned int getNumStatsColors() const;
 
    unsigned int getNumCCVColors() const;
 
    unsigned int getCoherenceThreshold() const;
 
    float getColorThreshold() const;
 
    float getStatsThreshold() const;
 
    float getFeatureThreshold() const;
 
    bool getUseCrossCorr() const;
 
    float getPatternThreshold() const;
 
    float* getStatsCoeffs()const;
 
    string getTexturePack() const;
 
    int getMinimumTransformationVotes() const;
 
    int getTexMinClusterSize() const;
 
    int getTexMaxClusterSize() const;
 
    bool vertexColorsFromPointcloud() const;
 
    bool useGPU() const;
 
    vector<float> getFlippoint() const;
 
    bool texturesFromImages() const;
 
    string getProjectDir() const;
 
private:
 
    float                           m_voxelsize;
 
    int                             m_numThreads;
 
 
    string                          m_faceNormalFile;
 
    int                             m_numberOfDefaults;
 
    int                             m_kd;
 
    int                             m_kn;
 
    int                             m_ki;
 
    int                             m_intersections;
 
    bool                          m_retesselate;
 
    bool                           m_generateTextures;
 
    bool                           m_writeClassificationResult;
 
    string                          m_pcm;
 
    int                             m_planeIterations;
 
    float                           m_planeNormalThreshold;
 
    int                             m_smallRegionThreshold;
 
    int                             m_rda;
 
    int                             m_fillHoles;
 
    int                             m_minPlaneSize;
 
    int                             m_cleanContourIterations;
 
    float                           m_texelSize;
 
    float                           m_lineFusionThreshold;
 
    float                           m_sft;
 
    float                           m_sct;
 
    string                          m_classifier;
 
    float                           m_edgeCollapseReductionRatio;
 
 
    string m_texturePack;
 
    string m_statsCoeffs;
 
    unsigned int m_numStatsColors;
 
    unsigned int m_numCCVColors;
 
    unsigned int m_coherenceThreshold;
 
    float m_colorThreshold;
 
    float m_statsThreshold;
 
    float m_featuresThreshold;
 
    bool m_useCrossCorr;
 
    float m_patternThreshold;
 
    int m_minimumTransformationVotes;
 
    int m_texMinClusterSize;
 
    int m_texMaxClusterSize;
 
    bool m_vertexColorsFromPointcloud;
 
    // Flippoint for gpu normal calculation
    vector<float> m_flippoint;
 
};
 
 
inline ostream& operator<<(ostream& os, const Options &o)
{
    o.printTransformation(os);
 
 
    if(o.getIntersections() > 0)
    {
        cout << "##### Intersections \t\t: " << o.getIntersections() << endl;
    }
    else
    {
        cout << "##### Voxelsize \t\t: " << o.getVoxelsize() << endl;
    }
    cout << "##### Number of threads \t: "    << o.getNumThreads()      << endl;
    cout << "##### Point cloud manager \t: " << o.getPCM()             << endl;
    if(o.useRansac())
    {
        cout << "##### Use RANSAC\t\t: YES" << endl;
    }
    else
    {
        cout << "##### Use RANSAC\t\t: NO" << endl;
    }
 
    cout << "##### Voxel decomposition: \t: " << o.getDecomposition()   << endl;
    cout << "##### Classifier:\t\t: "         << o.getClassifier()      << endl;
    if(o.writeClassificationResult())
    {
        cout << "##### Dump classification\t: YES" << endl;
    }
    else
    {
        cout << "##### Dump classification\t: NO" << endl;
    }
    cout << "##### k_n \t\t\t: "              << o.getKn()              << endl;
    cout << "##### k_i \t\t\t: "              << o.getKi()              << endl;
    cout << "##### k_d \t\t\t: "              << o.getKd()              << endl;
    if(o.getDecomposition() == "SF")
    {
        cout << "##### Sharp feature threshold \t: " << o.getSharpFeatureThreshold() << endl;
        cout << "##### Sharp corner threshold \t: " << o.getSharpCornerThreshold() << endl;
    }
    if(o.retesselate())
    {
        cout << "##### Retesselate \t\t: YES"     << endl;
        cout << "##### Line fusion threshold \t: " << o.getLineFusionThreshold() << endl;
    }
    if(o.saveFaceNormals())
    {
        cout << "##### Write Face Normals \t: YES" << endl;
    }
 
    if(o.getFillHoles())
    {
        cout << "##### Fill holes \t\t: " << o.getFillHoles() << endl;
    }
    else
    {
        cout << "##### Fill holes \t\t: NO" << endl;
    }
 
    if(o.getDanglingArtifacts())
    {
        cout << "##### Remove DAs \t\t: " << o.getDanglingArtifacts() << endl;
    }
    else
    {
        cout << "##### Remove DAs \t\t: NO" << endl;
    }
 
    if(o.optimizePlanes())
    {
        cout << "##### Optimize Planes \t\t: YES" << endl;
        cout << "##### Plane iterations\t\t: " << o.getPlaneIterations() << endl;
        cout << "##### Normal threshold \t\t: " << o.getNormalThreshold() << endl;
        cout << "##### Region threshold\t\t: " << o.getSmallRegionThreshold() << endl;
        cout << "##### Region min size\t\t: " << o.getMinPlaneSize() << endl;
    }
    if(o.saveNormals())
    {
        cout << "##### Save normals \t\t: YES" << endl;
    }
    if(o.saveOriginalData())
    {
        cout << "##### Save input data \t\t: YES" << endl;
    }
 
    if(o.recalcNormals())
    {
        cout << "##### Recalc normals \t\t: YES" << endl;
    }
    if(o.savePointNormals())
    {
        cout << "##### Save points normals \t: YES" << endl;
    }
    if(o.vertexColorsFromPointcloud())
    {
        cout << "##### Vertex colors: \t\t: YES" << endl;
    }
    if(o.generateTextures())
    {
        cout << "##### Generate Textures \t: YES" << endl;
        cout << "##### Texel size \t\t: " << o.getTexelSize() << endl;
        cout << "##### Texture Min#Cluster \t: " << o.getTexMinClusterSize() << endl;
        cout << "##### Texture Max#Cluster \t: " << o.getTexMaxClusterSize() << endl;
 
        if(o.doTextureAnalysis())
        {
            cout << "##### Texture Analysis \t: ON" << endl;
        }
        else
        {
            cout << "##### Texture Analysis \t\t: OFF" << endl;
        }
    }
    if(o.getEdgeCollapseReductionRatio() > 0.0)
    {
        cout << "##### Edge collapse reduction ratio\t: " << o.getEdgeCollapseReductionRatio() << endl;
    }
 
    if(o.useGPU())
    {
        cout << "##### GPU normal estimation \t: ON" << endl;
        std::vector<float> flipPoint = o.getFlippoint();
        cout << "##### Flippoint \t\t: ("
            << flipPoint[0] << ", "
            << flipPoint[1] << ", "
            << flipPoint[2] << ")" << endl;
    }else{
        cout << "##### GPU normal estimation \t: OFF" << endl;
    }
 
 
    return os;
}
 
} // namespace reconstruct
 
 
#endif /* OPTIONS_H_ */