LargeScaleOptions.hpp

Go to the documentation of this file.

 
/*
 * LargeScaleOptions.hpp
 *
 *      Author: Isaak Mitschke
 */
 
#ifndef LARGESCALEOPTIONS_H_
#define LARGESCALEOPTIONS_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 LargeScaleOptions
{
 
class Options : public lvr2::BaseOption
{
  public:
    Options(int argc, char** argv);
    virtual ~Options();
 
    bool getBigMesh() const;
 
    bool getDebugChunks() const;
 
    bool useGPU() const;
 
    vector<float> getVoxelSizes() const;
 
    float getVoxelsize() const;
 
    float getBGVoxelsize() const;
 
    float getScaling() const;
 
     // TODO data types don't match!!
    int getChunkSize() const;
 
    unsigned int getNodeSize() const;
 
    int getPartMethod() const;
 
    int getKi() const;
 
    int getKd() const;
 
    int getKn() const;
 
    bool useRansac() const;
 
    vector<float> getFlippoint() const;
 
    bool extrude() const;
 
    /*
     * Definition from here on are for the combine-process of partial meshes
     */
 
    int getDanglingArtifacts() const;
 
    int getCleanContourIterations() const;
 
    int getFillHoles() const;
 
    bool optimizePlanes() const;
 
    float getNormalThreshold() const;
    int getPlaneIterations() const;
 
    int getSmallRegionThreshold() const;
 
    bool retesselate() const;
 
    float getLineFusionThreshold() const;
 
    /*
     * Definition from here on are not used (anymore?)
     */
 
    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 savePointNormals() const;
 
    bool recalcNormals() const;
 
    bool doTextureAnalysis() const;
 
    bool generateTextures() const;
 
    bool clusterPlanes() const;
 
    bool writeClassificationResult() const;
 
    std::vector<string> getInputFileName() const;
 
    string getClassifier() const;
 
    string getScanPoseFile() const;
 
    int getIntersections() const;
 
    string getPCM() const;
 
    string getDecomposition() const;
 
    int getMinPlaneSize() const;
 
    int getDepth() const;
 
    float getTexelSize() const;
 
    float getSharpFeatureThreshold() const;
 
    float getSharpCornerThreshold() const;
 
    int getNumEdgeCollapses() const;
 
    bool onlyNormals() const;
 
    string getEdgeCollapseMethod() 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;
    unsigned int getBufferSize() const;
 
    bool interpolateBoxes() const;
 
 
    string getOutputFolderPath() const;
 
    bool getUseNormals() const;
 
    size_t getVolumenSize() const;
 
    size_t getLineReaderBuffer() const;
 
  private:
    bool m_bigMesh;
 
    bool m_debugChunks;
 
    vector<float> m_voxelSizes;
 
    float m_voxelsize;
 
    float m_voxelsizeBG;
 
    float m_scaling;
 
    int m_chunkSize;
 
    int m_partMethod;
 
    int m_ki;
 
    int m_kd;
 
    int m_kn;
 
    vector<float> m_flippoint;
 
    bool m_extrude;
 
    int m_removeDanglingArtifacts;
 
    int m_cleanContourIterations;
 
    int m_fillHoles;
 
    float m_planeNormalThreshold;
 
    int m_planeIterations;
 
    int m_minPlaneSize;
 
    int m_smallRegionThreshold;
 
    bool m_retesselate;
 
    float m_lineFusionThreshold;
 
 
    /*
     * Definition from here on are not used (anymore?)
     */
 
    int m_numThreads;
 
    string m_faceNormalFile;
 
    int m_numberOfDefaults;
 
    int m_intersections;
 
    bool m_generateTextures;
 
    bool m_writeClassificationResult;
 
    string m_pcm;
 
    int m_depth;
 
    float m_texelSize;
 
    float m_sft;
 
    float m_sct;
 
    string m_classifier;
 
    string m_ecm;
 
    int m_numEdgeCollapses;
 
    string m_outputFolderPath;
 
    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;
 
    unsigned int m_bufferSize;
 
    unsigned int m_octreeNodeSize;
 
    bool m_interpolateBoxes;
 
    bool m_use_normals;
 
    size_t m_volumenSize;
 
    size_t m_lineReaderBuffer;
 
    bool m_onlyNormals;
 
};
 
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_i \t\t\t: " << o.getKi() << endl;
    cout << "##### k_d \t\t\t: " << o.getKd() << endl;
    cout << "##### k_n \t\t\t: " << o.getKn() << 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;
    }
    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.generateTextures())
    {
        cout << "##### Generate Textures \t: YES" << endl;
        cout << "##### Texel size \t\t: " << o.getTexelSize() << endl;
        if (o.doTextureAnalysis())
        {
            cout << "##### Texture Analysis \t: OFF" << endl;
        }
        else
        {
            cout << "##### Texture Analysis \t\t: OFF" << endl;
        }
    }
    if (o.getDepth())
    {
        cout << "##### Recursion depth \t\t: " << o.getDepth() << endl;
    }
    if (o.getNumEdgeCollapses())
    {
        cout << "##### Edge collapse method \t\t: " << o.getEdgeCollapseMethod() << endl;
        cout << "##### Number of edge collapses\t: " << o.getNumEdgeCollapses() << endl;
    }
 
    if (o.getNodeSize())
    {
        cout << "##### Leaf Size \t\t: " << o.getNodeSize() << endl;
    }
 
    cout << "##### Interpolating Boxes \t: " << o.interpolateBoxes() << endl;
 
    if (o.getBufferSize())
    {
        cout << "##### Buffer Size \t\t: " << o.getBufferSize() << endl;
    }
    cout << "##### Volumen Size \t\t: " << o.getVolumenSize() << endl;
    return os;
}
 
} // namespace LargeScaleOptions
 
#endif /* LARGESCALEOPTIONS_H_ */