Image.h

#pragma once

// STL includes
#include <vector>
#include <cstdint>
#include <cstring>
#include <algorithm>
#include <cassert>
#include <utils/ColorRgb.h>


template <typename Pixel_T>
class Image
{
public:

    typedef Pixel_T pixel_type;

    Image() :
        _width(1),
        _height(1),
        _pixels(new Pixel_T[2]),
        _endOfPixels(_pixels + 1)
    {
        memset(_pixels, 0, 2*sizeof(Pixel_T));
    }

    Image(const unsigned width, const unsigned height) :
        _width(width),
        _height(height),
        _pixels(new Pixel_T[width * height + 1]),
        _endOfPixels(_pixels + width * height)
    {
        memset(_pixels, 0, (_width*_height+1)*sizeof(Pixel_T));
    }

    Image(const unsigned width, const unsigned height, const Pixel_T background) :
        _width(width),
        _height(height),
        _pixels(new Pixel_T[width * height + 1]),
        _endOfPixels(_pixels + width * height)
    {
        std::fill(_pixels, _endOfPixels, background);
    }

    Image(const Image & other) :
        _width(other._width),
        _height(other._height),
        _pixels(new Pixel_T[other._width * other._height + 1]),
        _endOfPixels(_pixels + other._width * other._height)
    {
        memcpy(_pixels, other._pixels, (long) other._width * other._height * sizeof(Pixel_T));
    }

    // Define assignment operator in terms of the copy constructor
    // More to read: https://stackoverflow.com/questions/255612/dynamically-allocating-an-array-of-objects?answertab=active#tab-top
    Image& operator=(Image rhs)
    {
        rhs.swap(*this);
        return *this;
    }

    void swap(Image& s) noexcept
    {
        using std::swap;
        swap(this->_width, s._width);
        swap(this->_height, s._height);
        swap(this->_pixels, s._pixels);
        swap(this->_endOfPixels, s._endOfPixels);
    }

    // C++11
    Image(Image&& src) noexcept
        : _width(0)
        , _height(0)
        , _pixels(NULL)
        , _endOfPixels(NULL)
    {
        src.swap(*this);
    }
    Image& operator=(Image&& src) noexcept
    {
        src.swap(*this);
        return *this;
    }

    ~Image()
    {
        delete[] _pixels;
    }

    inline unsigned width() const
    {
        return _width;
    }

    inline unsigned height() const
    {
        return _height;
    }

    uint8_t red(const unsigned pixel) const
    {
        return (_pixels + pixel)->red;
    }

    uint8_t green(const unsigned pixel) const
    {
        return (_pixels + pixel)->green;
    }

    uint8_t blue(const unsigned pixel) const
    {
        return (_pixels + pixel)->blue;
    }

    const Pixel_T& operator()(const unsigned x, const unsigned y) const
    {
        return _pixels[toIndex(x,y)];
    }

    Pixel_T& operator()(const unsigned x, const unsigned y)
    {
        return _pixels[toIndex(x,y)];
    }

    void resize(const unsigned width, const unsigned height)
    {
        if ((width*height) > unsigned((_endOfPixels-_pixels)))
        {
            delete[] _pixels;
            _pixels = new Pixel_T[width*height + 1];
            _endOfPixels = _pixels + width*height;
        }

        _width = width;
        _height = height;
    }

    void copy(const Image<Pixel_T>& other)
    {
        assert(other._width == _width);
        assert(other._height == _height);

        memcpy(_pixels, other._pixels, _width*_height*sizeof(Pixel_T));
    }

    Pixel_T* memptr()
    {
        return _pixels;
    }

    const Pixel_T* memptr() const
    {
        return _pixels;
    }


    void toRgb(Image<ColorRgb>& image)
    {
        image.resize(_width, _height);
        const unsigned imageSize = _width * _height;

        for (unsigned idx=0; idx<imageSize; idx++)
        {
            const Pixel_T color = memptr()[idx];
            image.memptr()[idx] = ColorRgb{color.red, color.green, color.blue};
        }
    }

    //
    ssize_t size() const
    {
        return  (ssize_t) _width * _height * sizeof(Pixel_T);
    }

private:

    inline unsigned toIndex(const unsigned x, const unsigned y) const
    {
        return y*_width + x;
    }

private:
    unsigned _width;
    unsigned _height;

    Pixel_T* _pixels;

    Pixel_T* _endOfPixels;
};