Image.h

/*
 * Copyright (c) 2018, Stefan Osswald
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * 
 * * Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */ 

#ifndef INCLUDE_ARTICULATION_IMAGE_H_
#define INCLUDE_ARTICULATION_IMAGE_H_

#include <assimp/scene.h>
#include <stdexcept>
#include <cstdlib>

#if HAS_OPENCV
#include <opencv2/core/core.hpp>
#else
// Define dummy classes for systems without OpenGL (e.g. Android)
#define CV_8UC3 16
#define CV_8UC4 24
#define GL_BGR GL_RGB
#define GL_BGRA GL_RGBA
namespace cv {
    struct Mat {
        int rows;
        int cols;
        int type;
        int nchannels;
        unsigned char *data;
        Mat() : rows(0), cols(0), type(0), data(NULL) {}
        Mat(const int rows, const int cols, const int type, const void * const data) : rows(rows), cols(cols), type(type), data(NULL), allocatedData(false) {
            switch (type) {
                case CV_8UC3: nchannels = 3; break;
                case CV_8UC4: nchannels = 4; break;
                default: throw std::invalid_argument("Unknown type");
            }
            this->data = (unsigned char *) data;
        }
        Mat(const int rows, const int cols, const int type) : rows(rows), cols(cols), type(type), data(NULL), allocatedData(true) {
            switch (type) {
                case CV_8UC3: nchannels = 3; break;
                case CV_8UC4: nchannels = 4; break;
                default: throw std::invalid_argument("Unknown type");
            }
            data = (unsigned char *) calloc(rows * cols * nchannels, sizeof(unsigned char));
        }
        Mat(const Mat& other) : data(NULL), allocatedData(true) {
            rows = other.rows;
            cols = other.cols;
            type = other.type;
            nchannels = other.nchannels;
            data = (unsigned char *) calloc(rows * cols * nchannels, sizeof(unsigned char));
            memcpy(data, other.data, rows * cols * nchannels);
        }
        ~Mat() {
            if (allocatedData) {
                //TODO free leads to SIGSEGV
                //free(data);
            }
            data = NULL;
        }
        inline const int& channels() const {
            return nchannels;
        }
    private:
        bool allocatedData;
    };
}
#endif
#include GL_INCLUDE

namespace gpu_coverage {

class Image {
public:
    Image(const aiTexture * const texture, const size_t& id);

    virtual ~Image();

    static const Image * get(const std::string& path);

    static void release(const Image * image);

    inline bool inUse() const {
        return usage > 0;
    }

    void bindToUnit(const GLenum unit) const;

    const cv::Mat& image() const {
        return mat;
    }

protected:
    Image(const std::string& path);

    Image(const int rows, const int cols, const int type, const unsigned char * const data = NULL);

    const size_t id;                 
    cv::Mat mat;                     
    mutable size_t usage;            
    const std::string path;          
};

} /* namespace gpu_coverage */

#endif /* INCLUDE_ARTICULATION_IMAGE_H_ */