src/tools/lvr2_cuda_normals/Main.cpp

Go to the documentation of this file.

#include <boost/filesystem.hpp>

#include "lvr2/reconstruction/cuda/CudaSurface.hpp"

#include "lvr2/geometry/BaseVector.hpp"
#include "lvr2/geometry/HalfEdgeMesh.hpp"

#include "lvr2/reconstruction/PointsetSurface.hpp"
#include "lvr2/reconstruction/AdaptiveKSearchSurface.hpp"
#include "lvr2/reconstruction/FastReconstruction.hpp"
#include "lvr2/reconstruction/PointsetGrid.hpp"
#include "lvr2/reconstruction/BilinearFastBox.hpp"

#include "lvr2/io/ModelFactory.hpp"
#include "lvr2/io/Timestamp.hpp"
#include "lvr2/io/IOUtils.hpp"

#include "Options.hpp"


using namespace lvr2;

using Vec = BaseVector<float>;
using akSurface = AdaptiveKSearchSurface<Vec>;
using psSurface = PointsetSurface<Vec>;
using GpuSurface = CudaSurface;


void computeNormals(string filename, cuda_normals::Options& opt, PointBufferPtr& buffer)
{
    ModelPtr model = ModelFactory::readModel(filename);
    size_t num_points;

    floatArr points;
    if (model && model->m_pointCloud )
    {
        num_points = model->m_pointCloud->numPoints();
        points = model->m_pointCloud->getPointArray();
        cout << timestamp << "Read " << num_points << " points from " << filename << endl;
    }
    else
    {
        cout << timestamp << "Warning: No point cloud data found in " << filename << endl;
        return;
    }

    floatArr normals = floatArr(new float[ num_points * 3 ]);

    cout << timestamp << "Constructing kd-tree..." << endl;
    CudaSurface gpu_surface(points, num_points);
    cout << timestamp << "Finished kd-tree construction." << endl;

    gpu_surface.setKn(opt.kn());
    gpu_surface.setKi(opt.ki());

    if(opt.useRansac())
    {
        std::string method = "RANSAC";
        gpu_surface.setMethod(method);
    } else
    {
        std::string method = "PCA";
        gpu_surface.setMethod(method);
    }
    gpu_surface.setFlippoint(opt.flipx(), opt.flipy(), opt.flipz());

    cout << timestamp << "Start Normal Calculation..." << endl;
    gpu_surface.calculateNormals();

    gpu_surface.getNormals(normals);
    cout << timestamp << "Finished Normal Calculation. " << endl;

    size_t nc;
    model->m_pointCloud->setNormalArray(normals, num_points);
    buffer = model->m_pointCloud;

    gpu_surface.freeGPU();
}

void reconstructAndSave(PointBufferPtr& buffer, cuda_normals::Options& opt)
{
    // RECONSTRUCTION
    // PointsetSurface
    PointsetSurfacePtr<Vec> surface;
    surface = PointsetSurfacePtr<Vec>( new AdaptiveKSearchSurface<Vec>(buffer,
        "FLANN",
        opt.kn(),
        opt.ki(),
        opt.kd(),
        1
    ) );


    // // Create an empty mesh
    HalfEdgeMesh<Vec> mesh;

    float resolution = opt.getVoxelsize();

    auto grid = std::make_shared<PointsetGrid<Vec, BilinearFastBox<Vec>>>(
        resolution,
        surface,
        surface->getBoundingBox(),
        true,
        true
    );

    grid->calcDistanceValues();

    auto reconstruction = make_unique<FastReconstruction<Vec, BilinearFastBox<Vec>>>(grid);
    reconstruction->getMesh(mesh);


    SimpleFinalizer<Vec> fin;
    MeshBufferPtr res = fin.apply(mesh);

    ModelPtr m( new Model( res ) );

    cout << timestamp << "Saving mesh." << endl;
    ModelFactory::saveModel( m, "triangle_mesh.ply");
}

int main(int argc, char** argv){


    cuda_normals::Options opt(argc, argv);
    cout << opt << endl;


    boost::filesystem::path inFile(opt.inputFile());

    if(boost::filesystem::is_directory(inFile))
    {
        vector<float> all_points;
        vector<float> all_normals;

        boost::filesystem::directory_iterator lastFile;
        for(boost::filesystem::directory_iterator it(inFile); it != lastFile; it++ )
        {
            boost::filesystem::path p = boost::filesystem::canonical(it->path());
            string currentFile = p.filename().string();

            if(string(p.extension().string().c_str()) == ".3d")
            {
                // Check for naming convention "scanxxx.3d"
                int num = 0;
                if(sscanf(currentFile.c_str(), "scan%3d", &num))
                {
                    cout << timestamp << "Processing " << p.string() << endl;
                    PointBufferPtr buffer(new PointBuffer );

                    computeNormals(p.string(), opt, buffer);
                    transformPointCloudAndAppend(buffer, p, all_points, all_normals);

                }
            }
        }

        if(!opt.reconstruct() || opt.exportPointNormals() )
        {
            writePointsAndNormals(all_points, all_normals, opt.outputFile());
        }

        if(opt.reconstruct() )
        {
            PointBufferPtr buffer(new PointBuffer);

            floatArr points = floatArr(&all_points[0]);
            size_t num_points = all_points.size() / 3;

            floatArr normals = floatArr(&all_normals[0]);
            size_t num_normals = all_normals.size() / 3;

            buffer->setPointArray(points, num_points);
            buffer->setNormalArray(normals, num_points);

            reconstructAndSave(buffer, opt);
        }

    }
    else
    {
        PointBufferPtr buffer(new PointBuffer);
        computeNormals(opt.inputFile(), opt, buffer);

        if(!opt.reconstruct() || opt.exportPointNormals() )
        {
            ModelPtr out_model(new Model(buffer));
            ModelFactory::saveModel(out_model, opt.outputFile());
        }

        if(opt.reconstruct())
        {
            reconstructAndSave(buffer, opt);
        }

    }


}