TextureFactory.cpp

Go to the documentation of this file.

#include "lvr2/texture/TextureFactory.hpp"

#include "lvr2/io/PPMIO.hpp"
#include "lvr2/io/Timestamp.hpp"
#include "lvr2/texture/Texture.hpp"

#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>

#include <iostream>
using std::cout;
using std::endl;

namespace lvr2
{

Texture TextureFactory::readTexture(std::string filename)
{
    // returns 8-bit image with BGR order
    cv::Mat mat = cv::imread(filename);


    // if unable to read file
    if (mat.data == NULL)
    {
        cout << timestamp << "TextureFactory: Unable to read file '"
            << filename << "'. Returning empty Texture." << endl;

        // return empty Texture
        return Texture();
    }

    // convert it to RGB order
    cv::cvtColor(mat, mat, cv::COLOR_BGR2RGB);

    Texture ret(0, mat.cols, mat.rows, 3, 1, 1.0);
    std::copy(mat.datastart, mat.dataend, ret.m_data);

    return ret;
}

void TextureFactory::saveTexture(const Texture& tex, std::string filename)
{
    // if Texture has no data to be saved
    if (tex.m_data == NULL || tex.m_width == 0 || tex.m_height == 0 ||
        tex.m_numChannels == 0 || tex.m_numBytesPerChan == 0)
    {
        cout << timestamp << "TextureFactory: Texture will not be saved to file '"
            << filename << "' because the texture has no data." << endl;

        return;
    }

    // TODO convert the data instead of only allowing 1 byte channels
    if (tex.m_numBytesPerChan != 1)
    {
        cout << timestamp << "TextureFactory: Texture will not be saved to file '"
            << filename << "' because texture has more than 1 byte \
            per channel (currently only 1-byte channels are supported)." << endl;

        return;
    }

    if (tex.m_numChannels != 1 && tex.m_numChannels != 3 && tex.m_numChannels != 4)
    {
        cout << timestamp << "TextureFactory: Texture will not be saved to file '"
            << filename << "' because the texture has an unsupported amount of channels \
            (currently only 1, 3 and 4 channels per pixel are supported)." << endl;

        return;
    }

    // convert texture data to be saved with OpenCV
    int mat_type = CV_8UC1;
    int conversionCode = cv::COLOR_GRAY2BGR;

    if (tex.m_numChannels == 3)
    {
        mat_type = CV_8UC3;
        conversionCode = cv::COLOR_RGB2BGR;
    }
    else if (tex.m_numChannels == 4)
    {
        // currently we just ignore the alpha channel but it would be
        // possible to save the alpha channel with OpenCV for PNG images.
        mat_type = CV_8UC3;
        conversionCode = cv::COLOR_RGBA2BGR;
    }

    cv::Mat mat;
    mat.create(tex.m_height, tex.m_width, mat_type);

    size_t bytesToCopy = tex.m_width * tex.m_height * tex.m_numChannels * tex.m_numBytesPerChan;
    std::copy(tex.m_data, tex.m_data + bytesToCopy, mat.data);

    if (!(mat_type == CV_8UC1))
    {
        cv::cvtColor(mat, mat, conversionCode);
    }

    // todo include params like binary mode for ppm files for example...
    if (!cv::imwrite(filename, mat))
    {
        cout << timestamp << "TextureFactory: Unable to save texture to file '"
            << filename << "'." << endl;
    };
}

} // namespace lvr2