/*
Copyright (c) 2011-2021 Timur Gafarov

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

/**
 * Generic image interface and its implementations for integer pixel formats
 *
 * Copyright: Timur Gafarov 2011-2021.
 * License: $(LINK2 boost.org/LICENSE_1_0.txt, Boost License 1.0).
 * Authors: Timur Gafarov
 */
module dlib.image.image;

import std.stdio;
import std.math;
import std.conv;
import std.range;
import dlib.core.memory;
import dlib.math.vector;
import dlib.math.interpolation;
import dlib.image.color;

/// sRGBa integer pixel formats, 8 and 16 bits per channel
enum IntegerPixelFormat: uint
{
    L8 = 0,
    LA8 = 1,
    RGB8 = 2,
    RGBA8 = 3,
    L16 = 4,
    LA16 = 5,
    RGB16 = 6,
    RGBA16 = 7
}

/**
 * Abstract image interface
 */
interface SuperImage: Freeable
{
    /**
     * Image width in pixels
     */
    @property uint width();

    /**
     * Image height in pixels
     */
    @property uint height();
    
    /**
     * Bits per channel
     */
    @property uint bitDepth();
    
    /**
     * Number of channels
     */
    @property uint channels();
    
    /**
     * Bytes per pixel
     */
    @property uint pixelSize();

    /**
     * This is compatible with IntegerPixelFormat and other internal format enums in dlib.
     * Values from 0 to 255 are reserved for dlib.
     * Values 256 and above are application-specific and can be used for custom SuperImage implementations
     */
    @property uint pixelFormat();

    /**
     * Returns raw buffer of image data in scan order.
     * Pixel layout is specified by pixelFormat
     */
    @property ubyte[] data();

    /**
     * Pixel access operator.
     * Should always return floating-point sRGBa or linear RGBa,
     * depending on format family (IntegerPixelFormat or FloatPixelFormat)
     */
    Color4f opIndex(int x, int y);
    
    /**
     * Pixel assignment operator.
     * Accepts floating-point sRGBa or linear RGBa,
     * depending on format family (IntegerPixelFormat or FloatPixelFormat)
     */
    Color4f opIndexAssign(Color4f c, int x, int y);

    /**
     * Makes a copy of the image
     */
    @property SuperImage dup();

    /**
     * Makes a blank image of the same format
     */
    SuperImage createSameFormat(uint w, uint h);

    /**
     * Range of x pixel indices
     */
    final @property auto row()
    {
        return iota(0, width);
    }

    /**
     * Range of y pixel indices
     */
    final @property auto col()
    {
        return iota(0, height);
    }

    /**
     * Enumerates all pixels of the image in scan order
     */
    final int opApply(scope int delegate(ref Color4f p, uint x, uint y) dg)
    {
        int result = 0;

        foreach(uint y; col)
        {
            foreach(uint x; row)
            {
                Color4f col = opIndex(x, y);
                result = dg(col, x, y);
                opIndexAssign(col, x, y);

                if (result)
                    break;
            }

            if (result)
                break;
        }

        return result;
    }
}

/**
 * SuperImage implementation template for integer pixel formats
 */
class Image(IntegerPixelFormat fmt): SuperImage
{
    public:

    override @property uint width()
    {
        return _width;
    }

    override @property uint height()
    {
        return _height;
    }

    override @property uint bitDepth()
    {
        return _bitDepth;
    }

    override @property uint channels()
    {
        return _channels;
    }

    override @property uint pixelSize()
    {
        return _pixelSize;
    }

    override @property uint pixelFormat()
    {
        return fmt;
    }

    override @property ubyte[] data()
    {
        return _data;
    }

    override @property SuperImage dup()
    {
        auto res = new Image!(fmt)(_width, _height);
        res.data[] = data[];
        return res;
    }

    override SuperImage createSameFormat(uint w, uint h)
    {
        return new Image!(fmt)(w, h);
    }

    this(uint w, uint h)
    {
        _width = w;
        _height = h;

        _bitDepth = [
            IntegerPixelFormat.L8:     8, IntegerPixelFormat.LA8:     8,
            IntegerPixelFormat.RGB8:   8, IntegerPixelFormat.RGBA8:   8,
            IntegerPixelFormat.L16:   16, IntegerPixelFormat.LA16:   16,
            IntegerPixelFormat.RGB16: 16, IntegerPixelFormat.RGBA16: 16
        ][fmt];

        _channels = [
            IntegerPixelFormat.L8:    1, IntegerPixelFormat.LA8:    2,
            IntegerPixelFormat.RGB8:  3, IntegerPixelFormat.RGBA8:  4,
            IntegerPixelFormat.L16:   1, IntegerPixelFormat.LA16:   2,
            IntegerPixelFormat.RGB16: 3, IntegerPixelFormat.RGBA16: 4
        ][fmt];

        _pixelSize = (_bitDepth / 8) * _channels;
        
        enum maxDimension = int.max;
        
        if (w > maxDimension)
        {
            writeln("Image data is not allocated. Exceeded maximum image width ", maxDimension);
            return;
        }
        
        if (h > maxDimension)
        {
            writeln("Image data is not allocated. Exceeded maximum image height ", maxDimension);
            return;
        }
            
        allocateData();
    }

    protected void allocateData()
    {
        size_t size = cast(size_t)_width * cast(size_t)_height * cast(size_t)_pixelSize;
        _data = new ubyte[size];
    }

    public Color4 getPixel(int x, int y)
    {
        ubyte[] pixData = data();

        if (x >= width) x = width-1;
        else if (x < 0) x = 0;

        if (y >= height) y = height-1;
        else if (y < 0) y = 0;

        size_t index = (cast(size_t)y * cast(size_t)_width + cast(size_t)x) * cast(size_t)_pixelSize;

        auto maxv = (2 ^^ bitDepth) - 1;

        static if (fmt == IntegerPixelFormat.L8)
        {
            auto v = pixData[index];
            return Color4(v, v, v);
        }
        else if (fmt == IntegerPixelFormat.LA8)
        {
            auto v = pixData[index];
            return Color4(v, v, v, pixData[index+1]);
        }
        else if (fmt == IntegerPixelFormat.RGB8)
        {
            return Color4(pixData[index], pixData[index+1], pixData[index+2], cast(ubyte)maxv);
        }
        else if (fmt == IntegerPixelFormat.RGBA8)
        {
            return Color4(pixData[index], pixData[index+1], pixData[index+2], pixData[index+3]);
        }
        else if (fmt == IntegerPixelFormat.L16)
        {
            ushort v = pixData[index] << 8 | pixData[index+1];
            return Color4(v, v, v);
        }
        else if (fmt == IntegerPixelFormat.LA16)
        {
            ushort v = pixData[index]   << 8 | pixData[index+1];
            ushort a = pixData[index+2] << 8 | pixData[index+3];
            return Color4(v, v, v, a);
        }
        else if (fmt == IntegerPixelFormat.RGB16)
        {
            ushort r = pixData[index]   << 8 | pixData[index+1];
            ushort g = pixData[index+2] << 8 | pixData[index+3];
            ushort b = pixData[index+4] << 8 | pixData[index+5];
            ushort a = cast(ushort)maxv;
            return Color4(r, g, b, a);
        }
        else if (fmt == IntegerPixelFormat.RGBA16)
        {
            ushort r = pixData[index]   << 8 | pixData[index+1];
            ushort g = pixData[index+2] << 8 | pixData[index+3];
            ushort b = pixData[index+4] << 8 | pixData[index+5];
            ushort a = pixData[index+6] << 8 | pixData[index+7];
            return Color4(r, g, b, a);
        }
        else
        {
            assert (0, "Image.opIndex is not implemented for IntegerPixelFormat." ~ to!string(fmt));
        }
    }

    public Color4 setPixel(Color4 c, int x, int y)
    {
        ubyte[] pixData = data();

        if (x >= width || y >= height || x < 0 || y < 0)
            return c;

        size_t index = (cast(size_t)y * cast(size_t)_width + cast(size_t)x) * cast(size_t)_pixelSize;

        static if (fmt == IntegerPixelFormat.L8)
        {
            pixData[index] = cast(ubyte)c.r;
        }
        else if (fmt == IntegerPixelFormat.LA8)
        {
            pixData[index] = cast(ubyte)c.r;
            pixData[index+1] = cast(ubyte)c.a;
        }
        else if (fmt == IntegerPixelFormat.RGB8)
        {
            pixData[index] = cast(ubyte)c.r;
            pixData[index+1] = cast(ubyte)c.g;
            pixData[index+2] = cast(ubyte)c.b;
        }
        else if (fmt == IntegerPixelFormat.RGBA8)
        {
            pixData[index] = cast(ubyte)c.r;
            pixData[index+1] = cast(ubyte)c.g;
            pixData[index+2] = cast(ubyte)c.b;
            pixData[index+3] = cast(ubyte)c.a;
        }
        else if (fmt == IntegerPixelFormat.L16)
        {
            pixData[index] = cast(ubyte)(c.r >> 8);
            pixData[index+1] = cast(ubyte)(c.r & 0xFF);
        }
        else if (fmt == IntegerPixelFormat.LA16)
        {
            pixData[index] = cast(ubyte)(c.r >> 8);
            pixData[index+1] = cast(ubyte)(c.r & 0xFF);
            pixData[index+2] = cast(ubyte)(c.a >> 8);
            pixData[index+3] = cast(ubyte)(c.a & 0xFF);
        }
        else if (fmt == IntegerPixelFormat.RGB16)
        {
            pixData[index] = cast(ubyte)(c.r >> 8);
            pixData[index+1] = cast(ubyte)(c.r & 0xFF);
            pixData[index+2] = cast(ubyte)(c.g >> 8);
            pixData[index+3] = cast(ubyte)(c.g & 0xFF);
            pixData[index+4] = cast(ubyte)(c.b >> 8);
            pixData[index+5] = cast(ubyte)(c.b & 0xFF);
        }
        else if (fmt == IntegerPixelFormat.RGBA16)
        {
            pixData[index] = cast(ubyte)(c.r >> 8);
            pixData[index+1] = cast(ubyte)(c.r & 0xFF);
            pixData[index+2] = cast(ubyte)(c.g >> 8);
            pixData[index+3] = cast(ubyte)(c.g & 0xFF);
            pixData[index+4] = cast(ubyte)(c.b >> 8);
            pixData[index+5] = cast(ubyte)(c.b & 0xFF);
            pixData[index+6] = cast(ubyte)(c.a >> 8);
            pixData[index+7] = cast(ubyte)(c.a & 0xFF);
        }
        else
        {
            assert (0, "Image.opIndexAssign is not implemented for IntegerPixelFormat." ~ to!string(fmt));
        }

        return c;
    }

    override Color4f opIndex(int x, int y)
    {
        return Color4f(getPixel(x, y), _bitDepth);
    }

    override Color4f opIndexAssign(Color4f c, int x, int y)
    {
        setPixel(c.convert(_bitDepth), x, y);
        return c;
    }

    void free()
    {
        // Do nothing, let GC delete the object
    }

    protected:

    uint _width;
    uint _height;
    uint _bitDepth;
    uint _channels;
    uint _pixelSize;
    ubyte[] _data;
}

/// Specialization of Image for 8-bit luminance pixel format
alias ImageL8 = Image!(IntegerPixelFormat.L8);
/// Specialization of Image for 8-bit luminance-alpha pixel format
alias ImageLA8 = Image!(IntegerPixelFormat.LA8);
/// Specialization of Image for 8-bit RGB pixel format
alias ImageRGB8 = Image!(IntegerPixelFormat.RGB8);
/// Specialization of Image for 8-bit RGBA pixel format
alias ImageRGBA8 = Image!(IntegerPixelFormat.RGBA8);

/// Specialization of Image for 16-bit luminance pixel format
alias ImageL16 = Image!(IntegerPixelFormat.L16);
/// Specialization of Image for 16-bit luminance-alpha pixel format
alias ImageLA16 = Image!(IntegerPixelFormat.LA16);
/// Specialization of Image for 16-bit RGB pixel format
alias ImageRGB16 = Image!(IntegerPixelFormat.RGB16);
/// Specialization of Image for 16-bit RGBA pixel format
alias ImageRGBA16 = Image!(IntegerPixelFormat.RGBA16);

/**
 * All-in-one image factory interface
 */
interface SuperImageFactory
{
    SuperImage createImage(uint w, uint h, uint channels, uint bitDepth, uint numFrames = 1);
}

/**
 * All-in-one image factory class
 */
class ImageFactory: SuperImageFactory
{
    SuperImage createImage(uint w, uint h, uint channels, uint bitDepth, uint numFrames = 1)
    {
        return image(w, h, channels, bitDepth);
    }
}

private SuperImageFactory _defaultImageFactory;

/**
 * Get default image factory singleton
 */
SuperImageFactory defaultImageFactory()
{
    if (!_defaultImageFactory)
        _defaultImageFactory = new ImageFactory();
    return _defaultImageFactory;
}

/// Create an image with specified parameters
SuperImage image(uint w, uint h, uint channels = 3, uint bitDepth = 8)
in
{
    assert(channels > 0 && channels <= 4);
    assert(bitDepth == 8 || bitDepth == 16);
}
do
{
    switch(channels)
    {
        case 1:
        {
            if (bitDepth == 8)
                return new ImageL8(w, h);
            else
                return new ImageL16(w, h);
        }
        case 2:
        {
            if (bitDepth == 8)
                return new ImageLA8(w, h);
            else
                return new ImageLA16(w, h);
        }
        case 3:
        {
            if (bitDepth == 8)
                return new ImageRGB8(w, h);
            else
                return new ImageRGB16(w, h);
        }
        case 4:
        {
            if (bitDepth == 8)
                return new ImageRGBA8(w, h);
            else
                return new ImageRGBA16(w, h);
        }
        default:
            assert(0);
    }
}

/// Convert image to specified pixel format
T convert(T)(SuperImage img)
{
    auto res = new T(img.width, img.height);
    foreach(x; 0..img.width)
    foreach(y; 0..img.height)
        res[x, y] = img[x, y];
    return res;
}

/// Get interpolated pixel value from an image
Color4f bilinearPixel(SuperImage img, float x, float y)
{
    real intX;
    real fracX = modf(x, intX);
    real intY;
    real fracY = modf(y, intY);

    Color4f c1 = img[cast(int)intX, cast(int)intY];
    Color4f c2 = img[cast(int)(intX + 1.0f), cast(int)intY];
    Color4f c3 = img[cast(int)(intX + 1.0f), cast(int)(intY + 1.0f)];
    Color4f c4 = img[cast(int)intX, cast(int)(intY + 1.0f)];

    Color4f ic1 = lerp(c1, c2, fracX);
    Color4f ic2 = lerp(c4, c3, fracX);
    Color4f ic3 = lerp(ic1, ic2, fracY);

    return ic3;
}

/**
 * Rectangular region of an image that can be iterated with foreach
 */
struct ImageRegion
{
    SuperImage img;
    uint xstart;
    uint ystart;
    uint width;
    uint height;

    final int opApply(scope int delegate(ref Color4f p, uint x, uint y) dg)
    {
        int result = 0;
        uint x1, y1;

        foreach(uint y; 0..height)
        {
            y1 = ystart + y;
            foreach(uint x; 0..width)
            {
                x1 = xstart + x;
                Color4f col = img[x1, y1];
                result = dg(col, x, y);
                img[x1, y1] = col;

                if (result)
                    break;
            }

            if (result)
                break;
        }

        return result;
    }
}

/// ImageRegion factory function
ImageRegion region(SuperImage img, uint x, uint y, uint width, uint height)
{
    return ImageRegion(img, x, y, width, height);
}

/**
 An InputRange of windows (regions around pixels) of an image that can be iterated with foreach
 */
struct ImageWindowRange
{
    SuperImage img;
    uint width;
    uint height;

    private uint halfWidth;
    private uint halfHeight;
    private uint wx = 0;
    private uint wy = 0;

    this(SuperImage img, uint w, uint h)
    {
        this.img = img;
        this.width = w;
        this.height = h;

        this.halfWidth = this.width / 2;
        this.halfHeight = this.height / 2;
    }

    final int opApply(scope int delegate(ImageRegion w, uint x, uint y) dg)
    {
        int result = 0;

        foreach(uint y; img.col)
        {
            uint ystart = y - halfWidth;
            foreach(uint x; img.row)
            {
                uint xstart = x - halfHeight;

                auto window = region(img, xstart, ystart, width, height);
                result = dg(window, x, y);

                if (result)
                    break;
            }

            if (result)
                break;
        }

        return result;
    }

    bool empty = false;

    void popFront()
    {
        wx++;
        if (wx == img.width)
        {
            wx = 0;
            wy++;

            if (wy == img.height)
            {
                wy = 0;
                empty = true;
            }
        }
    }

    @property ImageRegion front()
    {
        return region(img, wx - halfWidth, wy - halfHeight, width, height);
    }
}

/**
 ImageWindowRange factory function
 
 Examples:
 ---
 // Convolution with emboss kernel
 
 float[3][3] kernel = [
     [-1, -1,  0],
     [-1,  0,  1],
     [ 0,  1,  1],
 ];

 foreach(window, x, y; inputImage.windows(3, 3))
 {
     Color4f sum = Color4f(0, 0, 0);
     foreach(ref Color4f pixel, x, y; window)
         sum += pixel * kernel[y][x];
     outputImage[x, y] = sum / 4.0f + 0.5f;
 }
 ---
 */
ImageWindowRange windows(SuperImage img, uint width, uint height)
{
    return ImageWindowRange(img, width, height);
}