src/tools/lvr2_largescale_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 "lvr2/config/BaseOption.hpp"

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

using std::cout;
using std::endl;
using std::ostream;
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_ */