LargeScaleReconstruction.hpp

Go to the documentation of this file.

#ifndef LAS_VEGAS_LARGESCALERECONSTRUCTION_HPP
#define LAS_VEGAS_LARGESCALERECONSTRUCTION_HPP

#include "lvr2/types/ScanTypes.hpp"
#include "lvr2/reconstruction/PointsetGrid.hpp"
#include "lvr2/reconstruction/FastBox.hpp"
#include "lvr2/algorithm/ChunkManager.hpp"
#include "lvr2/geometry/HalfEdgeMesh.hpp"


namespace lvr2
{
    struct LSROptions
    {
        //flag to trigger .ply output of big Mesh
        bool bigMesh = true;

        // flag to trigger .ply output of chunks
        bool debugChunks = false;

        // flag to trigger GPU usage
        bool useGPU = false;

        // voxelsizes for reconstruction.
        std::vector<float> voxelSizes{0.1};

        // voxelsize for the BigGrid.
        float bgVoxelSize = 1;

        // scale factor.
        float scale = 1;

        // Max. Number of Points in a leaf (used to devide pointcloud).
        uint nodeSize = 1000000;

        // int flag to trigger partition-method (0 = kd-Tree; 1 = VGrid)
        int partMethod = 1;

        //Number of normals used in the normal interpolation process.
        int ki = 20;

        //Number of normals used for distance function evaluation.
        int kd = 20;

        // Size of k-neighborhood used for normal estimation.
        int kn = 20;

        //Set this flag for RANSAC based normal estimation.
        bool useRansac = false;

        // FlipPoint for GPU normal computation
        std::vector<float> flipPoint{10000000, 10000000, 10000000};

        // Do not extend grid. Can be used to avoid artifacts in dense data sets but. Disabling
        // will possibly create additional holes in sparse data sets.
        bool extrude = false;

        /*
         * Definition from here on are for the combine-process of partial meshes
         */

        // number for the removal of dangling artifacts.
        int removeDanglingArtifacts = 0;

        //Remove noise artifacts from contours. Same values are between 2 and 4.
        int cleanContours = 0;

        //Maximum size for hole filling.
        int fillHoles = 0;

        // Shift all triangle vertices of a cluster onto their shared plane.
        bool optimizePlanes = false;

        // (Plane Normal Threshold) Normal threshold for plane optimization.
        float planeNormalThreshold = 0.85;

        // Number of iterations for plane optimization.
        int planeIterations = 3;

        // Minimum value for plane optimization.
        int minPlaneSize = 7;

        // Threshold for small region removal. If 0 nothing will be deleted.
        int smallRegionThreshold = 0;

        // Retesselate regions that are in a regression plane. Implies --optimizePlanes.
        bool retesselate = false;

        // Threshold for fusing line segments while tesselating.
        float lineFusionThreshold = 0.01;

        vector<float> getFlipPoint() const
        {
            std::vector<float> dest = flipPoint;
            if(dest.size() != 3)
            {
                std::vector<float> dest = std::vector<float>();
                dest.push_back(10000000);
                dest.push_back(10000000);
                dest.push_back(10000000);
            }
            return dest;
        }
    };

    template <typename BaseVecT>
    class LargeScaleReconstruction
    {


    public:
        LargeScaleReconstruction();


        LargeScaleReconstruction(vector<float> voxelSizes, float bgVoxelSize, float scale,
                uint nodeSize, int partMethod,int ki, int kd, int kn, bool useRansac, std::vector<float> flipPoint,
                bool extrude, int removeDanglingArtifacts, int cleanContours, int fillHoles, bool optimizePlanes,
                float getNormalThreshold, int planeIterations, int minPlaneSize, int smallRegionThreshold,
                bool retesselate, float lineFusionThreshold, bool bigMesh, bool debugChunks, bool useGPU);

         LargeScaleReconstruction(LSROptions options);

        int mpiChunkAndReconstruct(ScanProjectEditMarkPtr project, BoundingBox<BaseVecT>& newChunksBB, std::shared_ptr<ChunkHashGrid> chunkManager);

        int mpiAndReconstruct(ScanProjectEditMarkPtr project);

        HalfEdgeMesh<BaseVecT> getPartialReconstruct(BoundingBox<BaseVecT> newChunksBB, std::shared_ptr<ChunkHashGrid> chunkHashGrid,  float voxelSize);




    private:

        void addTSDFChunkManager(int x, int y, int z,
                shared_ptr<lvr2::PointsetGrid<BaseVector<float>, lvr2::FastBox<BaseVector<float>>>> ps_grid,
                shared_ptr<ChunkHashGrid> cm,
                std::string layerName);

        //flag to trigger .ply output of big Mesh
        bool m_bigMesh = true;

        // flag to trigger .ply output of chunks
        bool m_debugChunks = false;

        // flag to trigger GPU usage
        bool m_useGPU = false;

        // path to hdf5 path containing previously reconstructed scans (or no scans) only
        string m_filePath;

        // voxelsize for reconstruction. Default: 10
        vector <float> m_voxelSizes;

        // voxelsize for the BigGrid. Default: 10
        float m_bgVoxelSize;

        // scale factor. Default: 1
        float m_scale;

        //ChunkSize, should be constant through all processes . Default: 20
        float m_chunkSize;

        // Max. Number of Points in a leaf (used to devide pointcloud). Default: 1000000
        uint m_nodeSize;

        // int flag to trigger partition-method (0 = kd-Tree; 1 = VGrid)
        int m_partMethod;

        //Number of normals used in the normal interpolation process. Default: 10
        int m_ki;

        //Number of normals used for distance function evaluation. Default: 5
        int m_kd;

        // Size of k-neighborhood used for normal estimation. Default: 10
        int m_kn;

        // flipPoint for GPU normal computation
        std::vector<float> m_flipPoint;

        //Set this flag for RANSAC based normal estimation. Default: false
        bool m_useRansac;

        // Do not extend grid. Can be used  to avoid artifacts in dense data sets but. Disabling
        // will possibly create additional holes in sparse data sets. Default: false
        bool m_extrude;

        /*
         * Definition from here on are for the combine-process of partial meshes
         */

        // flag to trigger the removal of dangling artifacts. Default: 0
        int m_removeDanglingArtifacts;

        //Remove noise artifacts from contours. Same values are between 2 and 4. Default: 0
        int m_cleanContours;

        //Maximum size for hole filling. Default: 0
        int m_fillHoles;

        // Shift all triangle vertices of a cluster onto their shared plane. Default: false
        bool m_optimizePlanes;

        // (Plane Normal Threshold) Normal threshold for plane optimization. Default: 0.85
        float m_planeNormalThreshold;

        // Number of iterations for plane optimization. Default: 3
        int m_planeIterations;

        // Minimum value for plane optimization. Default: 7
        int m_minPlaneSize;

        // Threshold for small region removal. If 0 nothing will be deleted. Default: 0
        int m_smallRegionThreshold;

        // Retesselate regions that are in a regression plane. Implies --optimizePlanes. Default: false
        bool m_retesselate;

        // Threshold for fusing line segments while tesselating. Default: 0.01
        float m_lineFusionThreshold;


    };
} // namespace lvr2

#include "lvr2/reconstruction/LargeScaleReconstruction.tcc"

#endif // LAS_VEGAS_LARGESCALERECONSTRUCTION_HPP