/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * 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 University of Southampton 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 OWNER 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.
 */
package org.openimaj.image;

import java.util.Comparator;

import org.openimaj.image.colour.ColourSpace;
import org.openimaj.image.pixel.Pixel;
import org.openimaj.image.renderer.MBFImageRenderer;
import org.openimaj.image.renderer.RenderHints;

/**
 * A multiband floating-point image.
 *
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 */
public class MBFImage extends MultiBandImage<Float, MBFImage, FImage> {
        private static final long serialVersionUID = 1L;

        /**
         * Construct an empty MBFImage with a the default RGB colourspace
         */
        public MBFImage() {
                super(ColourSpace.RGB);
        }

        /**
         * Construct an MBFImage from single band images. The given images are used
         * directly as the bands and are not cloned.
         *
         * @param colourSpace
         *            the colourspace
         * @param images
         *            the bands
         */
        public MBFImage(final ColourSpace colourSpace, final FImage... images) {
                super(colourSpace, images);
        }

        /**
         * Construct an MBFImage from single band images with the default RGB
         * colourspace if there are three images, RGBA if there are 4 images, or
         * CUSTOM otherwise. The given images are used directly as the bands and are
         * not cloned; if you want to create an RGB {@link MBFImage} from a single
         * {@link FImage}, you would need to clone the {@link FImage} at least
         * twice.
         *
         * @param images
         *            the bands
         */
        public MBFImage(final FImage... images) {
                super(images.length == 3 ? ColourSpace.RGB : images.length == 4 ? ColourSpace.RGBA : ColourSpace.CUSTOM, images);
        }

        /**
         * Construct an empty RGB image (3 bands)
         *
         * @param width
         *            Width of image
         * @param height
         *            Height of image
         */
        public MBFImage(final int width, final int height) {
                this(width, height, ColourSpace.RGB);
        }

        /**
         * Construct an empty image
         *
         * @param width
         *            Width of image
         * @param height
         *            Height of image
         * @param colourSpace
         *            the colourspace
         */
        public MBFImage(final int width, final int height, final ColourSpace colourSpace) {
                this.colourSpace = colourSpace;

                for (int i = 0; i < colourSpace.getNumBands(); i++) {
                        this.bands.add(new FImage(width, height));
                }
        }

        /**
         * Construct an empty image. If the number of bands is 3, RGB is assumed, if
         * the number is 4, then RGBA is assumed, otherwise the colourspace is set
         * to CUSTOM.
         *
         * @param width
         *            Width of image
         * @param height
         *            Height of image
         * @param nbands
         *            number of bands
         */
        public MBFImage(final int width, final int height, final int nbands) {
                if (nbands == 3)
                        this.colourSpace = ColourSpace.RGB;
                else if (nbands == 4)
                        this.colourSpace = ColourSpace.RGBA;

                for (int i = 0; i < nbands; i++) {
                        this.bands.add(new FImage(width, height));
                }
        }

        /**
         * Create an image from a BufferedImage object. Resultant image have RGB
         * bands in the 0-1 range.
         *
         * @param data
         *            array of packed ARGB pixels
         * @param width
         *            the image width
         * @param height
         *            the image height
         */
        public MBFImage(final int[] data, final int width, final int height) {
                this(data, width, height, false);
        }

        /**
         * Create an image from a int[] object. Resultant image will be in the 0-1
         * range. If alpha is true, bands will be RGBA, otherwise RGB
         *
         * @param data
         *            array of packed ARGB pixels
         * @param width
         *            the image width
         * @param height
         *            the image height
         * @param alpha
         *            should we load the alpha channel
         */
        public MBFImage(final int[] data, final int width, final int height, final boolean alpha) {
                this(width, height, alpha ? 4 : 3);
                this.internalAssign(data, width, height);
        }

        /**
         * Create an MBFImage from an array of double values with the given width
         * and height. The length of the array must equal the width multiplied by
         * the height by the number of bands. The values will be downcast to floats.
         * The data can either be interlaced (rgbrgb...) or band at a time (rrrr...
         * gggg... bbbb...).
         *
         * @param ds
         *            An array of floating point values.
         * @param width
         *            The width of the resulting image.
         * @param height
         *            The height of the resulting image.
         * @param nbands
         *            the number of bands
         * @param interlaced
         *            if true the data in the array is interlaced
         */
        public MBFImage(double[] ds, int width, int height, int nbands, boolean interlaced) {
                if (interlaced) {
                        for (int i = 0; i < nbands; i++) {
                                bands.add(new FImage(width, height));
                        }
                        for (int y = 0, c = 0; y < height; y++) {
                                for (int x = 0; x < width; x++) {
                                        for (int i = 0; i < nbands; i++, c++) {
                                                bands.get(i).pixels[y][x] = (float) ds[c];
                                        }
                                }
                        }
                } else {
                        for (int i = 0; i < nbands; i++) {
                                bands.add(new FImage(ds, width, height, i * width * height));
                        }
                }
        }

        /*
         * (non-Javadoc)
         *
         * @see uk.ac.soton.ecs.jsh2.image.MultiBandImage#flattenMax()
         */
        @Override
        public FImage flattenMax() {
                final int width = this.getWidth();
                final int height = this.getHeight();

                final FImage out = new FImage(width, height);

                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                float max = (this.bands.get(0)).pixels[y][x];

                                for (int i = 1; i < this.numBands(); i++)
                                        if (max < (this.bands.get(i)).pixels[y][x])
                                                max = (this.bands.get(i)).pixels[y][x];

                                out.pixels[y][x] = max;
                        }
                }

                return out;
        }

        @Override
        public FImage flatten() {
                // overly optimised flatten

                final int width = this.getWidth();
                final int height = this.getHeight();

                final FImage out = new FImage(width, height);
                final float[][] outp = out.pixels;
                final int nb = this.numBands();

                for (int i = 1; i < nb; i++) {
                        final float[][] bnd = this.bands.get(i).pixels;

                        for (int y = 0; y < height; y++) {
                                for (int x = 0; x < width; x++) {
                                        outp[y][x] += bnd[y][x];

                                }
                        }
                }

                final float norm = 1f / nb;
                final float[][] bnd = this.bands.get(0).pixels;
                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                outp[y][x] = (outp[y][x] + bnd[y][x]) * norm;
                        }
                }

                return out;
        }

        /*
         * (non-Javadoc)
         *
         * @see uk.ac.soton.ecs.jsh2.image.Image#getPixel(int, int)
         */
        @Override
        public Float[] getPixel(final int x, final int y) {
                final Float[] pixels = new Float[this.bands.size()];

                for (int i = 0; i < this.bands.size(); i++) {
                        pixels[i] = this.bands.get(i).getPixel(x, y);
                }

                return pixels;
        }

        @Override
        public Comparator<? super Float[]> getPixelComparator() {
                return new Comparator<Float[]>() {

                        @Override
                        public int compare(final Float[] o1, final Float[] o2) {
                                int sumDiff = 0;
                                boolean anyDiff = false;
                                for (int i = 0; i < o1.length; i++) {
                                        sumDiff += o1[i] - o2[i];
                                        anyDiff = sumDiff != 0 || anyDiff;
                                }
                                if (anyDiff) {
                                        if (sumDiff > 0)
                                                return 1;
                                        else
                                                return -1;
                                } else
                                        return 0;
                        }

                };
        }

        /*
         * (non-Javadoc)
         *
         * @see uk.ac.soton.ecs.jsh2.image.Image#getPixelInterp(double, double)
         */
        @Override
        public Float[] getPixelInterp(final double x, final double y) {
                final Float[] result = new Float[this.bands.size()];

                for (int i = 0; i < this.bands.size(); i++) {
                        result[i] = this.bands.get(i).getPixelInterp(x, y);
                }

                return result;
        }

        /*
         * (non-Javadoc)
         *
         * @see uk.ac.soton.ecs.jsh2.image.Image#getPixelInterp(double,
         * double,Float[])
         */
        @Override
        public Float[] getPixelInterp(final double x, final double y, final Float[] b) {
                final Float[] result = new Float[this.bands.size()];

                for (int i = 0; i < this.bands.size(); i++) {
                        result[i] = this.bands.get(i).getPixelInterp(x, y, b[i]);
                }

                return result;
        }

        /**
         * Assign planar RGB bytes (R1G1B1R2G2B2...) to this image.
         *
         * @param bytes
         *            the byte array
         * @param width
         *            the width of the byte image
         * @param height
         *            the height of the byte image
         * @return this
         */
        public MBFImage internalAssign(final byte[] bytes, final int width, final int height) {
                if (this.getWidth() != width || this.getHeight() != height)
                        this.internalAssign(this.newInstance(width, height));

                final float[][] br = this.bands.get(0).pixels;
                final float[][] bg = this.bands.get(1).pixels;
                final float[][] bb = this.bands.get(2).pixels;

                for (int i = 0, y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                final int red = (bytes[i++]) & 0xff;
                                final int green = (bytes[i++]) & 0xff;
                                final int blue = bytes[i++] & 0xff;
                                br[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[red];
                                bg[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[green];
                                bb[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[blue];
                        }
                }

                return this;
        }

        /*
         * (non-Javadoc)
         *
         * @see org.openimaj.image.Image#internalAssign(int[], int, int)
         */
        @Override
        public MBFImage internalAssign(final int[] data, final int width, final int height) {
                if (this.getWidth() != width || this.getHeight() != height)
                        this.internalAssign(this.newInstance(width, height));

                final float[][] br = this.bands.get(0).pixels;
                final float[][] bg = this.bands.get(1).pixels;
                final float[][] bb = this.bands.get(2).pixels;
                float[][] ba = null;

                if (this.colourSpace == ColourSpace.RGBA)
                        ba = this.bands.get(3).pixels;

                for (int i = 0, y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++, i++) {
                                final int rgb = data[i];
                                final int alpha = ((rgb >> 24) & 0xff);
                                final int red = ((rgb >> 16) & 0xff);
                                final int green = ((rgb >> 8) & 0xff);
                                final int blue = ((rgb) & 0xff);
                                br[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[red];
                                bg[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[green];
                                bb[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[blue];

                                if (ba != null)
                                        ba[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[alpha];
                        }
                }

                return this;
        }

        @Override
        protected Float intToT(final int n) {
                return (float) n;
        }

        @Override
        public FImage newBandInstance(final int width, final int height) {
                return new FImage(width, height);
        }

        @Override
        public MBFImage newInstance() {
                return new MBFImage();
        }

        /*
         * (non-Javadoc)
         *
         * @see uk.ac.soton.ecs.jsh2.image.MultiBandImage#newInstance(int, int)
         */
        @Override
        public MBFImage newInstance(final int width, final int height) {
                final MBFImage ret = new MBFImage(width, height, this.bands.size());

                ret.colourSpace = this.colourSpace;

                return ret;
        }

        @Override
        public MBFImageRenderer createRenderer() {
                return new MBFImageRenderer(this);
        }

        @Override
        public MBFImageRenderer createRenderer(final RenderHints options) {
                return new MBFImageRenderer(this, options);
        }

        /**
         * Get the value of the pixel at coordinate p
         *
         * @param p
         *            The coordinate to get
         *
         * @return The pixel value at (x, y)
         */
        public float[] getPixelNative(final Pixel p) {
                return this.getPixelNative(p.x, p.y);
        }

        /**
         * Get the value of the pixel at coordinate <code>(x, y)</code>.
         *
         * @param x
         *            The x-coordinate to get
         * @param y
         *            The y-coordinate to get
         *
         * @return The pixel value at (x, y)
         */
        public float[] getPixelNative(final int x, final int y) {
                final float[] pixels = new float[this.bands.size()];

                for (int i = 0; i < this.bands.size(); i++) {
                        pixels[i] = this.bands.get(i).getPixelNative(x, y);
                }

                return pixels;
        }

        /**
         * Returns the pixels in this image as a vector (an array of the pixel
         * type).
         *
         * @param f
         *            The array into which to place the data
         * @return The pixels in the image as a vector (a reference to the given
         *         array).
         */
        public float[][] getPixelVectorNative(final float[][] f) {
                for (int y = 0; y < this.getHeight(); y++)
                        for (int x = 0; x < this.getWidth(); x++)
                                f[x + y * this.getWidth()] = this.getPixelNative(x, y);

                return f;
        }

        /**
         * Sets the pixel at <code>(x,y)</code> to the given value. Side-affects
         * this image.
         *
         * @param x
         *            The x-coordinate of the pixel to set
         * @param y
         *            The y-coordinate of the pixel to set
         * @param val
         *            The value to set the pixel to.
         */
        public void setPixelNative(final int x, final int y, final float[] val) {
                final int np = this.bands.size();
                if (np == val.length)
                        for (int i = 0; i < np; i++)
                                this.bands.get(i).setPixel(x, y, val[i]);
                else {
                        final int offset = val.length - np;
                        for (int i = 0; i < np; i++)
                                if (i + offset >= 0)
                                        this.bands.get(i).setPixel(x, y, val[i + offset]);
                }
        }

        /**
         * {@inheritDoc}
         * <p>
         * This method assumes the last band in the multiband image is the alpha
         * channel. This allows a 2-channel MBFImage where the first image is an
         * FImage and the second an alpha channel, as well as a standard RGBA image.
         *
         * @see org.openimaj.image.Image#overlayInplace(org.openimaj.image.Image,
         *      int, int)
         */
        @Override
        public MBFImage overlayInplace(final MBFImage image, final int x, final int y) {
                // Assume the alpha channel is the last band
                final FImage alpha = image.getBand(image.numBands() - 1);

                for (int i = 0; i < this.numBands(); i++)
                        this.bands.get(i).overlayInplace(image.bands.get(i), alpha, x, y);

                return this;
        }

        /**
         * Create a random RGB image.
         *
         * @param width
         *            the width
         * @param height
         *            the height
         * @return the image
         */
        public static MBFImage randomImage(final int width, final int height) {
                final MBFImage img = new MBFImage();
                img.colourSpace = ColourSpace.RGB;

                for (int i = 0; i < 3; i++) {
                        img.bands.add(FImage.randomImage(width, height));
                }

                return img;
        }

        /**
         * Convenience method to create an RGB {@link MBFImage} from an
         * {@link FImage} by cloning the {@link FImage} for each of the R, G and B
         * bands.
         *
         * @param image
         *            the {@link FImage} to convert
         * @return the new RGB {@link MBFImage}
         */
        public static MBFImage createRGB(final FImage image) {
                return new MBFImage(image.clone(), image.clone(), image.clone());
        }

        @Override
        public MBFImage fill(final Float[] colour) {
                return super.fill(this.colourSpace.sanitise(colour));
        }

        @Override
        public void setPixel(final int x, final int y, final Float[] val) {
                // Check if we have an alpha channel. If we do, we'll use alpha
                // compositing, otherwise, we'll simply copy the pixel colour into
                // the pixel position.
                if (this.colourSpace == ColourSpace.RGBA && this.numBands() >= 4 && val.length >= 4
                                && x >= 0 && x < this.getWidth() && y >= 0 && y < this.getHeight())
                {
                        final float[] p = ImageUtilities.alphaCompositePixel(this.getPixel(x, y), val);
                        this.getBand(0).pixels[y][x] = p[0];
                        this.getBand(1).pixels[y][x] = p[1];
                        this.getBand(2).pixels[y][x] = p[2];
                        if (this.numBands() >= 4)
                                this.getBand(3).pixels[y][x] = p[3];
                } else
                        super.setPixel(x, y, val);
        }

        @Override
        protected Float[] createPixelArray(int n) {
                return new Float[n];
        }

        /**
         * Returns the pixels of the image as a vector (array) of doubles.
         *
         * @return the pixels of the image as a vector (array) of doubles.
         */
        public double[] getDoublePixelVector() {
                final int height = getHeight();
                final int width = getWidth();
                final double f[] = new double[width * height * this.numBands()];
                for (int i = 0; i < this.bands.size(); i++) {
                        final float[][] pixels = bands.get(i).pixels;

                        for (int y = 0; y < height; y++)
                                for (int x = 0; x < width; x++)
                                        f[x + y * width + i * height * width] = pixels[y][x];
                }
                return f;
        }
}