src/tools/lvr2_asciiconverter/Main.cpp

Go to the documentation of this file.

#include "Options.hpp"

#include "lvr2/io/Timestamp.hpp"
#include "lvr2/io/AsciiIO.hpp"
#include "lvr2/io/DataStruct.hpp"
#include "lvr2/io/ModelFactory.hpp"
#include "lvr2/io/Progress.hpp"

#include <iostream>
#include <fstream>

using namespace lvr2;


int main(int argc, char** argv)
{
    // Parse command line arguments
    ascii_convert::Options options(argc, argv);

    // Exit if options had to generate a usage message
    // (this means required parameters are missing)
    if (options.printUsage()) return 0;

    std::cout << options << std::endl;

    // Get input and putput files
    string inputFile = options.inputFile();
    string outputFile = options.outputFile();

    // Count entries
    int numEntries = AsciiIO::getEntriesInLine(inputFile);
    int numLines = AsciiIO::countLines(inputFile);
    int numPoints = numLines - 1;

    if(numPoints <= 0)
    {
        std::cout << timestamp << "File contains no points. Exiting." << std::endl;
    }

    // Check color and intensity options
    bool readColor = true;
    if( (options.r() < 0) || (options.g() < 0) || (options.b() < 0) )
    {
        readColor = false;
    }

    bool readIntensity = options.i() >= 0;
    bool convert = options.convertRemission();

    // Print stats
    std::cout << timestamp << "Read colors\t\t: " << readColor << std::endl;
    std::cout << timestamp << "Read intensities\t\t: " << readIntensity << std::endl;
    std::cout << timestamp << "Convert intensities\t: " << convert << std::endl;

    // Alloc buffers
    floatArr points(new float[3 * numPoints]);
    ucharArr colors;
    floatArr intensities;

    if(readColor || (readIntensity && convert))
    {
        colors = ucharArr(new unsigned char[3 * numPoints]);
    }

    if(readIntensity)
    {
        intensities = floatArr(new float[numPoints]);
    }

    // Open input file and skip first line

    string comment = timestamp.getElapsedTime() + "Reading file " + inputFile;
    ProgressBar progress(numPoints, comment);

    std::ifstream in(inputFile.c_str());
    char buffer[2048];
    if(in.good())
    {
        // Data to store the input data
        float* data = new float[numEntries];
        in.getline(buffer, 2048);
        int c = 0;
        while(in.good() && c <= numPoints)
        {
            // Read a new line
            for(int i = 0; i < numEntries; i++)
            {
                in >> data[i];
            }

            // Fill data arrays
            int posPtr = 3 * c;

            points[posPtr    ] = data[options.x()];
            points[posPtr + 1] = data[options.y()];
            points[posPtr + 2] = data[options.z()];

            points[posPtr    ] *= options.sx();
            points[posPtr + 1] *= options.sy();
            points[posPtr + 2] *= options.sz();

            if(convert)
            {
                colors[posPtr    ] = (unsigned char)data[options.i()];
                colors[posPtr + 1] = (unsigned char)data[options.i()];
                colors[posPtr + 2] = (unsigned char)data[options.i()];
            }
            else if (readColor)
            {
                colors[posPtr    ] = (unsigned char)data[options.r()];
                colors[posPtr + 1] = (unsigned char)data[options.g()];
                colors[posPtr + 2] = (unsigned char)data[options.b()];
            }

            if(readIntensity)
            {
                intensities[c] = data[options.i()];
            }
            c++;
            ++progress;
        }
                delete[] data;

        // Create model and save data
        PointBufferPtr pointBuffer(new PointBuffer );
        pointBuffer->setPointArray(points, numPoints);
        pointBuffer->setColorArray(colors, numPoints);
        pointBuffer->addFloatChannel(intensities, "intensities", numPoints, 1);

        ModelPtr model( new Model(pointBuffer));
        ModelFactory::saveModel(model, outputFile);
    }
    else
    {
        std::cout << "Unable to open file for output: " << inputFile << std::endl;
    }

    std::cout << std::endl;

        return 0;
}