src/tools/lvr2_chunking/Main.cpp

Go to the documentation of this file.

#include "Options.hpp"
#include "lvr2/algorithm/ChunkManager.hpp"
#include "lvr2/io/hdf5/HDF5FeatureBase.hpp"
#include "lvr2/io/ModelFactory.hpp"

#include <boost/filesystem.hpp>
#include <iostream>
#include <string>

int main(int argc, char** argv)
{
    // =======================================================================
    // Parse and print command line parameters
    // =======================================================================
    // Parse command line arguments
    chunking::Options options(argc, argv);

    // Exit if options had to generate a usage message
    // (this means required parameters are missing)
    if (options.printUsage())
    {
        return EXIT_SUCCESS;
    }
    if (options.getLoad())
    {
        if (boost::filesystem::exists(options.getChunkedMesh()))
        {
            // loading a hdf5 file and extracting the chunks for a given bounding box
            lvr2::ChunkManager chunkLoader(options.getChunkedMesh(), options.getCacheSize());

            // TODO: remove tmp test later
            // beginn: tmp test of extractArea method for dat/scan.pts with chunkSize 200
            if (!boost::filesystem::exists("area"))
            {
                boost::filesystem::create_directories("area");
            }
            lvr2::BoundingBox<lvr2::BaseVector<float>> area(
                lvr2::BaseVector<float>(options.getXMin(), options.getYMin(), options.getZMin()),
                lvr2::BaseVector<float>(options.getXMax(), options.getYMax(), options.getZMax()));
            // end: tmp test of extractArea method

//            lvr2::ModelFactory::saveModel(
//                lvr2::ModelPtr(new lvr2::Model(chunkLoader.extractArea(area))), "area.ply");
        }
    }
    else
    {
        // saving a mesh as multiple chunked meshes in an hdf5 file
        boost::filesystem::path outputPath = boost::filesystem::absolute(options.getOutputDir());
        if (!boost::filesystem::is_directory(outputPath))
        {
            boost::filesystem::create_directories(outputPath);
        }

        float size = options.getChunkSize();
        float maxChunkOverlap = options.getMaxChunkOverlap();


        // Check extension
        std::vector<std::string> files = options.getInputFile();
        boost::filesystem::path selectedFile(files[0]);
        std::string extension = selectedFile.extension().string();
        lvr2::MeshBufferPtr meshBuffer;
        if (extension == ".h5")
        {
            using HDF5MeshToolIO = lvr2::Hdf5IO<lvr2::hdf5features::ArrayIO,
                                                lvr2::hdf5features::ChannelIO,
                                                lvr2::hdf5features::VariantChannelIO,
                                                lvr2::hdf5features::MeshIO>;
            HDF5MeshToolIO hdf5;
            hdf5.open(files[0]);
            meshBuffer = hdf5.loadMesh(options.getMeshGroup());
        }
        else // use model reader
        {
            std::vector<lvr2::MeshBufferPtr> meshes;
            std::vector<std::string> layers;
            for(size_t i = 0; i < files.size(); ++i)
            {
                lvr2::ModelPtr model = lvr2::ModelFactory::readModel(files[i]);
                layers.push_back(std::string("mesh") + std::to_string(i));
                meshBuffer = model->m_mesh;
                if (meshBuffer)
                {
                    meshes.push_back(meshBuffer);
                }

            }
         lvr2::ChunkManager chunker(meshes, size, maxChunkOverlap, outputPath.string(), layers);
        }
    }
    return EXIT_SUCCESS;
}