/**
 * 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.apache.log4j.Logger;
import org.openimaj.image.analyser.PixelAnalyser;
import org.openimaj.image.colour.ColourSpace;
import org.openimaj.image.pixel.FValuePixel;
import org.openimaj.image.pixel.Pixel;
import org.openimaj.image.processor.KernelProcessor;
import org.openimaj.image.processor.PixelProcessor;
import org.openimaj.image.renderer.FImageRenderer;
import org.openimaj.image.renderer.RenderHints;
import org.openimaj.math.geometry.shape.Rectangle;
import org.openimaj.math.util.Interpolation;

import Jama.Matrix;

/**
 * Class representing a single-band floating-point image; that is an image where
 * each pixel is represented by a floating-point number.
 * <p>
 * {@link FImage}s can be created from PGM files or from pixel arrays. If you
 * wish to read other types of files then use the {@link ImageUtilities} class
 * that provides read/write functions for {@link Image} objects.
 *
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 */
public class FImage extends SingleBandImage<Float, FImage>
{
        private static final long serialVersionUID = 1L;

        /** The logging class */
        protected static Logger logger = Logger.getLogger(FImage.class);

        /**
         * The default number of sigmas at which the Gaussian function is truncated
         * when building a kernel
         */
        protected static final float DEFAULT_GAUSS_TRUNCATE = 4.0f;

        /** The underlying pixels */
        public float pixels[][];

        /**
         * Create an {@link FImage} from an array of floating point values with the
         * given width and height. The length of the array must equal the width
         * multiplied by the height.
         *
         * @param array
         *            An array of floating point values.
         * @param width
         *            The width of the resulting image.
         * @param height
         *            The height of th resulting image.
         */
        public FImage(final float[] array, final int width, final int height)
        {
                assert (array.length == width * height);

                this.pixels = new float[height][width];
                this.height = height;
                this.width = width;

                for (int y = 0; y < height; y++)
                        for (int x = 0; x < width; x++)
                                this.pixels[y][x] = array[y * width + x];
        }

        /**
         * Create an {@link FImage} 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. The values will be downcast to floats.
         *
         * @param array
         *            An array of floating point values.
         * @param width
         *            The width of the resulting image.
         * @param height
         *            The height of th resulting image.
         */
        public FImage(final double[] array, final int width, final int height)
        {
                assert (array.length == width * height);

                this.pixels = new float[height][width];
                this.height = height;
                this.width = width;

                for (int y = 0; y < height; y++)
                        for (int x = 0; x < width; x++)
                                this.pixels[y][x] = (float) array[y * width + x];
        }

        /**
         * Create an {@link FImage} 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. The values will be downcast to floats.
         *
         * @param array
         *            An array of floating point values.
         * @param width
         *            The width of the resulting image.
         * @param height
         *            The height of the resulting image.
         * @param offset
         *            The offset in the array to begin reading from
         */
        public FImage(final double[] array, final int width, final int height, int offset)
        {
                assert (array.length == width * height);

                this.pixels = new float[height][width];
                this.height = height;
                this.width = width;

                for (int y = 0; y < height; y++)
                        for (int x = 0; x < width; x++)
                                this.pixels[y][x] = (float) array[offset + y * width + x];
        }

        /**
         * Create an {@link FImage} from an array of floating point values.
         *
         * @param array
         *            the array representing pixel values to copy data from.
         */
        public FImage(final float[][] array)
        {
                this.pixels = array;
                this.height = array.length;
                this.width = array[0].length;
        }

        /**
         * Create an empty {@link FImage} of the given size.
         *
         * @param width
         *            image width (number of columns)
         * @param height
         *            image height (number of rows)
         */
        public FImage(final int width, final int height) {
                this.pixels = new float[height][width];

                this.height = height;
                this.width = width;
        }

        /**
         * Construct an {@link FImage} from an array of packed ARGB integers.
         *
         * @param data
         *            array of packed ARGB pixels
         * @param width
         *            the image width
         * @param height
         *            the image height
         */
        public FImage(final int[] data, final int width, final int height) {
                this.internalAssign(data, width, height);
        }

        /**
         * Construct an {@link FImage} from an array of packed ARGB integers using
         * the specified plane.
         *
         * @param data
         *            array of packed ARGB pixels
         * @param width
         *            the image width
         * @param height
         *            the image height
         * @param plane
         *            The {@link ARGBPlane} to copy data from
         */
        public FImage(final int[] data, final int width, final int height, final ARGBPlane plane) {
                this.width = width;
                this.height = height;
                this.pixels = new float[height][width];

                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                final int rgb = data[x + y * width];

                                int colour = 0;
                                switch (plane)
                                {
                                case RED:
                                        colour = ((rgb >> 16) & 0xff);
                                        break;
                                case GREEN:
                                        colour = ((rgb >> 8) & 0xff);
                                        break;
                                case BLUE:
                                        colour = ((rgb) & 0xff);
                                        break;
                                default:
                                        break;
                                }

                                this.pixels[y][x] = colour;
                        }
                }
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#abs()
         */
        @Override
        public FImage abs() {
                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                this.pixels[r][c] = Math.abs(this.pixels[r][c]);
                return this;
        }

        /**
         * Adds the pixel values of the given {@link FImage} to the pixels of this
         * image. Returns a new {@link FImage} and does not affect this image or the
         * given image. This is a version of {@link Image#add(Image)} which takes an
         * {@link FImage}. This method directly accesses the underlying float[][]
         * and is therefore fast. This function returns a new {@link FImage}.
         *
         * @see org.openimaj.image.Image#add(Image)
         * @param im
         *            {@link FImage} to add into this one.
         * @return A new {@link FImage}
         */
        public FImage add(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                final FImage newImage = new FImage(im.width, im.height);

                for (int r = 0; r < im.height; r++)
                        for (int c = 0; c < im.width; c++)
                                newImage.pixels[r][c] = this.pixels[r][c] + im.pixels[r][c];

                return newImage;
        }

        /**
         * Returns a new {@link FImage} that contains the pixels of this image
         * increased by the given value. {@inheritDoc}
         *
         * @see org.openimaj.image.Image#add(java.lang.Object)
         */
        @Override
        public FImage add(final Float num)
        {
                final FImage newImage = new FImage(this.width, this.height);
                final float fnum = num;

                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                newImage.pixels[r][c] = this.pixels[r][c] + fnum;

                return newImage;
        }

        /**
         * {@inheritDoc} This method throws an {@link UnsupportedOperationException}
         * if the given image is not an {@link FImage}.
         *
         * @see org.openimaj.image.Image#add(org.openimaj.image.Image)
         * @exception UnsupportedOperationException
         *                if an unsupported type is added
         * @return a reference to this {@link FImage}
         */
        @Override
        public FImage add(final Image<?, ?> im)
        {
                if (im instanceof FImage)
                        return this.add((FImage) im);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /***
         * Adds the given image pixel values to the pixel values of this image.
         * Version of {@link Image#addInplace(Image)} which takes an {@link FImage}.
         * This directly accesses the underlying float[][] and is therefore fast.
         * This function side-affects the pixels in this {@link FImage}.
         *
         * @see Image#addInplace(Image)
         * @param im
         *            the FImage to add
         * @return a reference to this
         */
        public FImage addInplace(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                for (int r = 0; r < im.height; r++)
                        for (int c = 0; c < im.width; c++)
                                this.pixels[r][c] += im.pixels[r][c];

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#addInplace(java.lang.Object)
         */
        @Override
        public FImage addInplace(final Float num)
        {
                final float fnum = num;
                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                this.pixels[r][c] += fnum;

                return this;
        }

        /**
         * {@inheritDoc} This method throws an {@link UnsupportedOperationException}
         * if the given image is not an {@link FImage}.
         *
         * @see org.openimaj.image.Image#addInplace(org.openimaj.image.Image)
         * @exception UnsupportedOperationException
         *                if an unsupported type is added
         * @return a reference to this {@link FImage}
         */
        @Override
        public FImage addInplace(final Image<?, ?> im)
        {
                if (im instanceof FImage)
                        return this.addInplace((FImage) im);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#clip(java.lang.Object, java.lang.Object)
         */
        @Override
        public FImage clip(final Float min, final Float max)
        {
                int r, c;

                for (r = 0; r < this.height; r++)
                {
                        for (c = 0; c < this.width; c++)
                        {
                                if (this.pixels[r][c] < min)
                                        this.pixels[r][c] = 0;
                                if (this.pixels[r][c] > max)
                                        this.pixels[r][c] = 1;
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#clipMax(java.lang.Object)
         */
        @Override
        public FImage clipMax(final Float thresh)
        {
                final float fthresh = thresh;
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                if (this.pixels[r][c] > fthresh)
                                        this.pixels[r][c] = 1;
                        }
                }
                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#clipMin(java.lang.Object)
         */
        @Override
        public FImage clipMin(final Float thresh)
        {
                final float fthresh = thresh;
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                if (this.pixels[r][c] < fthresh)
                                        this.pixels[r][c] = 0;
                        }
                }
                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.SingleBandImage#clone()
         */
        @Override
        public FImage clone()
        {
                final FImage cpy = new FImage(this.width, this.height);
                int r;

                for (r = 0; r < this.height; r++)
                        System.arraycopy(this.pixels[r], 0, cpy.pixels[r], 0, this.width);

                return cpy;
        }

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

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

        /**
         * Divides the pixels values of this image with the values from the given
         * image. This is a version of {@link Image#divide(Image)} which takes an
         * {@link FImage}. This directly accesses the underlying float[][] and is
         * therefore fast. This function returns a new {@link FImage}.
         *
         * @see Image#divide(Image)
         * @param im
         *            the {@link FImage} to be the denominator.
         * @return A new {@link FImage}
         */
        public FImage divide(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                final FImage newImage = new FImage(im.width, im.height);
                int r, c;

                for (r = 0; r < im.height; r++)
                        for (c = 0; c < im.width; c++)
                                newImage.pixels[r][c] = this.pixels[r][c] / im.pixels[r][c];

                return newImage;
        }

        /**
         * Divides the pixel values of this image with the values from the given
         * image. This is a version of {@link Image#divideInplace(Image)} which
         * takes an {@link FImage}. This directly accesses the underlying float[][]
         * and is therefore fast. This function side-affects this image.
         *
         * @see Image#divideInplace(Image)
         * @param im
         *            the {@link FImage} to be the denominator
         * @return a reference to this {@link FImage}
         */
        public FImage divideInplace(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                for (int y = 0; y < this.height; y++)
                {
                        for (int x = 0; x < this.width; x++)
                        {
                                this.pixels[y][x] /= im.pixels[y][x];
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#divideInplace(java.lang.Object)
         */
        @Override
        public FImage divideInplace(final Float val)
        {
                final float fval = val;

                for (int y = 0; y < this.height; y++)
                        for (int x = 0; x < this.width; x++)
                                this.pixels[y][x] /= fval;

                return this;
        }

        /**
         * Divide all pixels by a given value
         *
         * @param fval
         *            the value
         * @return this image
         * @see org.openimaj.image.Image#divideInplace(java.lang.Object)
         */
        public FImage divideInplace(final float fval)
        {
                for (int y = 0; y < this.height; y++)
                        for (int x = 0; x < this.width; x++)
                                this.pixels[y][x] /= fval;

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#divideInplace(org.openimaj.image.Image)
         */
        @Override
        public FImage divideInplace(final Image<?, ?> im)
        {
                if (im instanceof FImage)
                        return this.divideInplace((FImage) im);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#extractROI(int, int,
         *      org.openimaj.image.Image)
         */
        @Override
        public FImage extractROI(final int x, final int y, final FImage out)
        {
                for (int r = y, rr = 0; rr < out.height; r++, rr++)
                {
                        for (int c = x, cc = 0; cc < out.width; c++, cc++)
                        {
                                if (r < 0 || r >= this.height || c < 0 || c >= this.width)
                                        (out).pixels[rr][cc] = 0;
                                else
                                        (out).pixels[rr][cc] = this.pixels[r][c];
                        }
                }

                return out;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#extractROI(int, int, int, int)
         */
        @Override
        public FImage extractROI(final int x, final int y, final int w, final int h)
        {
                final FImage out = new FImage(w, h);

                for (int r = y, rr = 0; rr < h; r++, rr++)
                {
                        for (int c = x, cc = 0; cc < w; c++, cc++)
                        {
                                if (r < 0 || r >= this.height || c < 0 || c >= this.width)
                                        out.pixels[rr][cc] = 0;
                                else
                                        out.pixels[rr][cc] = this.pixels[r][c];
                        }
                }

                return out;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.SingleBandImage#fill(java.lang.Comparable)
         */
        @Override
        public FImage fill(final Float colour)
        {
                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                this.pixels[r][c] = colour;

                return this;
        }

        /**
         * Fill an image with the given colour
         *
         * @param colour
         *            the colour
         * @return the image
         * @see org.openimaj.image.SingleBandImage#fill(java.lang.Comparable)
         */
        public FImage fill(final float colour)
        {
                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                this.pixels[r][c] = colour;

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getContentArea()
         */
        @Override
        public Rectangle getContentArea() {
                int minc = this.width, maxc = 0, minr = this.height, maxr = 0;

                for (int r = 0; r < this.height; r++) {
                        for (int c = 0; c < this.width; c++) {
                                if (this.pixels[r][c] > 0) {
                                        if (c < minc)
                                                minc = c;
                                        if (c > maxc)
                                                maxc = c;
                                        if (r < minr)
                                                minr = r;
                                        if (r > maxr)
                                                maxr = r;
                                }
                        }
                }

                return new Rectangle(minc, minr, maxc - minc + 1, maxr - minr + 1);
        }

        /**
         * 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 double f[] = new double[this.height * this.width];
                for (int y = 0; y < this.height; y++)
                        for (int x = 0; x < this.width; x++)
                                f[x + y * this.width] = this.pixels[y][x];

                return f;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getField(org.openimaj.image.Image.Field)
         */
        @Override
        public FImage getField(final Field f)
        {
                final FImage img = new FImage(this.width, this.height / 2);

                int r, r2, c;
                final int init = (f.equals(Field.ODD) ? 1 : 0);
                for (r = init, r2 = 0; r < this.height && r2 < this.height / 2; r += 2, r2++)
                {
                        for (c = 0; c < this.width; c++)
                        {
                                img.pixels[r2][c] = this.pixels[r][c];
                        }
                }

                return img;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getFieldCopy(org.openimaj.image.Image.Field)
         */
        @Override
        public FImage getFieldCopy(final Field f)
        {
                final FImage img = new FImage(this.width, this.height);

                int r, c;
                for (r = 0; r < this.height; r += 2)
                {
                        for (c = 0; c < this.width; c++)
                        {
                                if (f.equals(Field.EVEN))
                                {
                                        img.pixels[r][c] = this.pixels[r][c];
                                        img.pixels[r + 1][c] = this.pixels[r][c];
                                }
                                else
                                {
                                        img.pixels[r][c] = this.pixels[r + 1][c];
                                        img.pixels[r + 1][c] = this.pixels[r + 1][c];
                                }
                        }
                }

                return img;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getFieldInterpolate(org.openimaj.image.Image.Field)
         */
        @Override
        public FImage getFieldInterpolate(final Field f)
        {
                final FImage img = new FImage(this.width, this.height);

                int r, c;
                for (r = 0; r < this.height; r += 2)
                {
                        for (c = 0; c < this.width; c++)
                        {
                                if (f.equals(Field.EVEN))
                                {
                                        img.pixels[r][c] = this.pixels[r][c];

                                        if (r + 2 == this.height)
                                        {
                                                img.pixels[r + 1][c] = this.pixels[r][c];
                                        }
                                        else
                                        {
                                                img.pixels[r + 1][c] = 0.5F * (this.pixels[r][c] + this.pixels[r + 2][c]);
                                        }
                                }
                                else
                                {
                                        img.pixels[r + 1][c] = this.pixels[r + 1][c];

                                        if (r == 0)
                                        {
                                                img.pixels[r][c] = this.pixels[r + 1][c];
                                        }
                                        else
                                        {
                                                img.pixels[r][c] = 0.5F * (this.pixels[r - 1][c] + this.pixels[r + 1][c]);
                                        }
                                }
                        }
                }

                return img;
        }

        /**
         * Returns the pixels of the image as a vector (array) of floats.
         *
         * @return the pixels of the image as a vector (array) of floats.
         */
        public float[] getFloatPixelVector()
        {
                final float f[] = new float[this.height * this.width];
                for (int y = 0; y < this.height; y++)
                        for (int x = 0; x < this.width; x++)
                                f[x + y * this.width] = this.pixels[y][x];

                return f;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getPixel(int, int)
         */
        @Override
        public Float getPixel(final int x, final int y)
        {
                return this.pixels[y][x];
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getPixelComparator()
         */
        @Override
        public Comparator<? super Float> getPixelComparator() {
                return new Comparator<Float>() {

                        @Override
                        public int compare(final Float o1, final Float o2) {
                                return o1.compareTo(o2);
                        }

                };
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getPixelInterp(double, double)
         * @see Interpolation#bilerp(double, double, double, double, double, double)
         */
        @Override
        public Float getPixelInterp(final double x, final double y)
        {
                int x0 = (int) Math.floor(x);
                int x1 = x0 + 1;
                int y0 = (int) Math.floor(y);
                int y1 = y0 + 1;

                if (x0 < 0)
                        x0 = 0;
                if (x0 >= this.width)
                        x0 = this.width - 1;
                if (y0 < 0)
                        y0 = 0;
                if (y0 >= this.height)
                        y0 = this.height - 1;

                if (x1 < 0)
                        x1 = 0;
                if (x1 >= this.width)
                        x1 = this.width - 1;
                if (y1 < 0)
                        y1 = 0;
                if (y1 >= this.height)
                        y1 = this.height - 1;

                final float f00 = this.pixels[y0][x0];
                final float f01 = this.pixels[y1][x0];
                final float f10 = this.pixels[y0][x1];
                final float f11 = this.pixels[y1][x1];
                float dx = (float) (x - x0);
                float dy = (float) (y - y0);
                if (dx < 0)
                        dx = 1 + dx;
                if (dy < 0)
                        dy = 1 + dy;

                return Interpolation.bilerp(dx, dy, f00, f01, f10, f11);
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#getPixelInterp(double, double)
         * @see Interpolation#bilerp(double, double, double, double, double, double)
         */
        @Override
        public Float getPixelInterp(final double x, final double y, final Float background)
        {
                final int x0 = (int) Math.floor(x);
                final int x1 = x0 + 1;
                final int y0 = (int) Math.floor(y);
                final int y1 = y0 + 1;

                boolean tx0, tx1, ty0, ty1;
                tx0 = ty0 = tx1 = ty1 = true;
                if (x0 < 0)
                        tx0 = false;
                if (x0 >= this.width)
                        tx0 = false;
                if (y0 < 0)
                        ty0 = false;
                if (y0 >= this.height)
                        ty0 = false;

                if (x1 < 0)
                        tx1 = false;
                if (x1 >= this.width)
                        tx1 = false;
                if (y1 < 0)
                        ty1 = false;
                if (y1 >= this.height)
                        ty1 = false;

                final double f00 = (ty0 && tx0 ? this.pixels[y0][x0] : background.floatValue()); // this.pixels[y0][x0];
                final double f01 = (ty1 && tx0 ? this.pixels[y1][x0] : background.floatValue()); // this.pixels[y1][x0];
                final double f10 = (ty0 && tx1 ? this.pixels[y0][x1] : background.floatValue()); // this.pixels[y0][x1];
                final double f11 = (ty1 && tx1 ? this.pixels[y1][x1] : background.floatValue()); // this.pixels[y1][x1];

                double dx = x - x0;
                double dy = y - y0;
                if (dx < 0)
                        dx = 1 + dx;
                if (dy < 0)
                        dy = 1 + dy;

                final double interpVal = Interpolation.bilerp(dx, dy, f00, f01, f10, f11);
                return (float) interpVal;
        }

        /**
         * Interpolate the value of a pixel at the given coordinates
         *
         * @param x
         *            the x-ordinate
         * @param y
         *            the y-ordinate
         * @param background
         *            the background colour
         * @return the interpolated pixel value
         * @see org.openimaj.image.Image#getPixelInterp(double, double)
         * @see Interpolation#bilerp(double, double, double, double, double, double)
         */
        public float getPixelInterpNative(final float x, final float y, final float background)
        {
                final int x0 = (int) Math.floor(x);
                final int x1 = x0 + 1;
                final int y0 = (int) Math.floor(y);
                final int y1 = y0 + 1;

                boolean tx0, tx1, ty0, ty1;
                tx0 = ty0 = tx1 = ty1 = true;
                if (x0 < 0)
                        tx0 = false;
                if (x0 >= this.width)
                        tx0 = false;
                if (y0 < 0)
                        ty0 = false;
                if (y0 >= this.height)
                        ty0 = false;

                if (x1 < 0)
                        tx1 = false;
                if (x1 >= this.width)
                        tx1 = false;
                if (y1 < 0)
                        ty1 = false;
                if (y1 >= this.height)
                        ty1 = false;

                final float f00 = (ty0 && tx0 ? this.pixels[y0][x0] : background); // this.pixels[y0][x0];
                final float f01 = (ty1 && tx0 ? this.pixels[y1][x0] : background); // this.pixels[y1][x0];
                final float f10 = (ty0 && tx1 ? this.pixels[y0][x1] : background); // this.pixels[y0][x1];
                final float f11 = (ty1 && tx1 ? this.pixels[y1][x1] : background); // this.pixels[y1][x1];

                float dx = x - x0;
                float dy = y - y0;
                if (dx < 0)
                        dx = 1 + dx;
                if (dy < 0)
                        dy = 1 + dy;

                final float interpVal = Interpolation.bilerpf(dx, dy, f00, f01, f10, f11);
                return interpVal;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#internalAssign(org.openimaj.image.Image)
         */
        @Override
        public FImage internalCopy(final FImage im)
        {
                final int h = im.height;
                final int w = im.width;
                final float[][] impixels = im.pixels;

                for (int r = 0; r < h; r++)
                        System.arraycopy(impixels[r], 0, this.pixels[r], 0, w);

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#internalAssign(org.openimaj.image.Image)
         */
        @Override
        public FImage internalAssign(final FImage im)
        {
                this.pixels = im.pixels;
                this.height = im.height;
                this.width = im.width;

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#internalAssign(int [] data, int width, int
         *      height)
         */
        @Override
        public FImage internalAssign(final int[] data, final int width, final int height) {
                if (this.height != height || this.width != width) {
                        this.height = height;
                        this.width = width;
                        this.pixels = new float[height][width];
                }

                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                final int rgb = data[x + width * y];

                                final int red = ((rgb >> 16) & 0xff);
                                final int green = ((rgb >> 8) & 0xff);
                                final int blue = ((rgb) & 0xff);

                                // NTSC colour conversion:
                                // This improves keypoint detection for some reason!
                                final float fpix = 0.299f * red + 0.587f * green + 0.114f * blue;

                                this.pixels[y][x] = ImageUtilities.BYTE_TO_FLOAT_LUT[(int) fpix];
                        }
                }
                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#inverse()
         */
        @Override
        public FImage inverse()
        {
                int r, c;
                final float max = this.max();

                for (r = 0; r < this.height; r++)
                        for (c = 0; c < this.width; c++)
                                this.pixels[r][c] = max - this.pixels[r][c];

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#max()
         */
        @Override
        public Float max()
        {
                int r, c;
                float max = Float.MIN_VALUE;

                for (r = 0; r < this.height; r++)
                        for (c = 0; c < this.width; c++)
                                if (max < this.pixels[r][c])
                                        max = this.pixels[r][c];

                return max;
        }

        /**
         * Get the pixel with the maximum value. Returns an {@link FValuePixel}
         * which contains the location and value of the pixel. If there are multiple
         * pixels with the same value then the first is returned. Note that this
         * method assumes all pixel values are greater than 0.
         *
         * @return the maximum pixel as an {@link FValuePixel}.
         */
        public FValuePixel maxPixel()
        {
                final FValuePixel max = new FValuePixel(-1, -1);
                max.value = -Float.MAX_VALUE;

                for (int y = 0; y < this.height; y++) {
                        for (int x = 0; x < this.width; x++) {
                                if (max.value < this.pixels[y][x]) {
                                        max.value = this.pixels[y][x];
                                        max.x = x;
                                        max.y = y;
                                }
                        }
                }

                return max;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#min()
         */
        @Override
        public Float min()
        {
                int r, c;
                float min = Float.MAX_VALUE;

                for (r = 0; r < this.height; r++)
                        for (c = 0; c < this.width; c++)
                                if (min > this.pixels[r][c])
                                        min = this.pixels[r][c];

                return min;
        }

        /**
         * Get the pixel with the minimum value. Returns an {@link FValuePixel}
         * which contains the location and value of the pixel. If there are multiple
         * pixels with the same value then the first is returned. Note that this
         * method assumes all pixel values are greater than 0.
         *
         * @return The minimum pixel as an {@link FValuePixel}.
         */
        public FValuePixel minPixel()
        {
                final FValuePixel min = new FValuePixel(-1, -1);
                min.value = Float.MAX_VALUE;

                for (int y = 0; y < this.height; y++)
                        for (int x = 0; x < this.width; x++)
                                if (min.value > this.pixels[y][x]) {
                                        min.value = this.pixels[y][x];
                                        min.x = x;
                                        min.y = y;
                                }

                return min;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#multiply(java.lang.Object)
         */
        @Override
        public FImage multiply(final Float num)
        {
                return super.multiply(num);
        }

        /**
         * Multiplies this image's pixel values by the corresponding pixel values in
         * the given image side-affecting this image. This is a version of
         * {@link Image#multiplyInplace(Image)} which takes an {@link FImage}. This
         * directly accesses the underlying float[][] and is therefore fast. This
         * function works inplace.
         *
         * @see Image#multiplyInplace(Image)
         * @param im
         *            the {@link FImage} to multiply with this image
         * @return a reference to this image
         */
        public FImage multiplyInplace(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] *= im.pixels[r][c];
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#multiplyInplace(java.lang.Object)
         */
        @Override
        public FImage multiplyInplace(final Float num)
        {
                final float fnum = num;
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] *= fnum;
                        }
                }

                return this;
        }

        /**
         * Multiply all pixel values by the given value
         *
         * @param fnum
         *            the value
         * @return this image
         * @see org.openimaj.image.Image#multiplyInplace(java.lang.Object)
         */
        public FImage multiplyInplace(final float fnum)
        {
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] *= fnum;
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc} This method will throw an
         * {@link UnsupportedOperationException} if the input input is not an
         * {@link FImage}.
         *
         * @see org.openimaj.image.Image#multiplyInplace(org.openimaj.image.Image)
         * @throws UnsupportedOperationException
         *             if the given image is not an {@link FImage}
         */
        @Override
        public FImage multiplyInplace(final Image<?, ?> im)
        {
                if (im instanceof FImage)
                        return this.multiplyInplace((FImage) im);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /**
         * {@inheritDoc}
         *
         * @return A new {@link FImage}
         * @see org.openimaj.image.Image#newInstance(int, int)
         */
        @Override
        public FImage newInstance(final int width, final int height)
        {
                return new FImage(width, height);
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#normalise()
         */
        @Override
        public FImage normalise()
        {
                final float min = this.min();
                final float max = this.max();

                if (max == min)
                        return this;

                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] = (this.pixels[r][c] - min) / (max - min);
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.SingleBandImage#process(org.openimaj.image.processor.KernelProcessor)
         */
        @Override
        public FImage process(final KernelProcessor<Float, FImage> p) {
                return this.process(p, false);
        }

        /**
         * {@inheritDoc} This method has been overridden in {@link FImage} for
         * performance.
         *
         * @see org.openimaj.image.SingleBandImage#process(org.openimaj.image.processor.KernelProcessor,
         *      boolean)
         */
        @Override
        public FImage process(final KernelProcessor<Float, FImage> p, final boolean pad)
        {
                final FImage newImage = new FImage(this.width, this.height);
                final int kh = p.getKernelHeight();
                final int kw = p.getKernelWidth();

                final FImage tmp = new FImage(kw, kh);

                final int hh = kh / 2;
                final int hw = kw / 2;

                if (!pad) {
                        for (int y = hh; y < this.height - (kh - hh); y++) {
                                for (int x = hw; x < this.width - (kw - hw); x++) {
                                        newImage.pixels[y][x] = p.processKernel(this.extractROI(x - hw, y - hh, tmp));
                                }
                        }
                } else {
                        for (int y = 0; y < this.height; y++) {
                                for (int x = 0; x < this.width; x++) {
                                        newImage.pixels[y][x] = p.processKernel(this.extractROI(x - hw, y - hh, tmp));
                                }
                        }
                }

                return newImage;
        }

        /**
         * {@inheritDoc} This method has been overridden in {@link FImage} for
         * performance.
         *
         * @see org.openimaj.image.Image#processInplace(org.openimaj.image.processor.PixelProcessor)
         */
        @Override
        public FImage processInplace(final PixelProcessor<Float> p)
        {
                for (int y = 0; y < this.height; y++)
                {
                        for (int x = 0; x < this.width; x++)
                        {
                                this.pixels[y][x] = p.processPixel(this.pixels[y][x]);
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc} This method has been overridden in {@link FImage} for
         * performance.
         *
         * @see org.openimaj.image.Image#analyseWith(org.openimaj.image.analyser.PixelAnalyser)
         */
        @Override
        public void analyseWith(final PixelAnalyser<Float> p)
        {
                p.reset();

                for (int y = 0; y < this.height; y++)
                {
                        for (int x = 0; x < this.width; x++)
                        {
                                p.analysePixel(this.pixels[y][x]);
                        }
                }
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#setPixel(int, int, java.lang.Object)
         */
        @Override
        public void setPixel(final int x, final int y, final Float val) {
                if (x >= 0 && x < this.width && y >= 0 && y < this.height)
                        this.pixels[y][x] = val;
        }

        /**
         * Subtracts the given {@link FImage} from this image returning a new image
         * containing the result.
         *
         * @param im
         *            The image to subtract from this image.
         * @return A new image containing the result.
         */
        public FImage subtract(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                final FImage newImage = new FImage(im.width, im.height);
                int r, c;

                for (r = 0; r < im.height; r++)
                        for (c = 0; c < im.width; c++)
                                newImage.pixels[r][c] = this.pixels[r][c] - im.pixels[r][c];
                return newImage;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#subtract(java.lang.Object)
         */
        @Override
        public FImage subtract(final Float num)
        {
                final FImage newImage = new FImage(this.width, this.height);

                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                newImage.pixels[r][c] = this.pixels[r][c] - num;
                        }
                }
                return newImage;
        }

        /**
         * {@inheritDoc} Throws an {@link UnsupportedOperationException} if the
         * given image is not an {@link FImage}.
         *
         * @see org.openimaj.image.Image#subtract(org.openimaj.image.Image)
         * @throws UnsupportedOperationException
         *             if the given image is not an {@link FImage}.
         */
        @Override
        public FImage subtract(final Image<?, ?> input)
        {
                if (input instanceof FImage)
                        return this.subtract((FImage) input);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /**
         * Subtracts (pixel-by-pixel) the given {@link FImage} from this image.
         * Side-affects this image.
         *
         * @param im
         *            The {@link FImage} to subtract from this image.
         * @return A reference to this image containing the result.
         */
        public FImage subtractInplace(final FImage im)
        {
                if (!ImageUtilities.checkSameSize(this, im))
                        throw new AssertionError("images must be the same size");

                float pix1[][], pix2[][];
                int r, c;

                pix1 = this.pixels;
                pix2 = im.pixels;

                for (r = 0; r < this.height; r++)
                        for (c = 0; c < this.width; c++)
                                pix1[r][c] -= pix2[r][c];

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#subtractInplace(java.lang.Object)
         */
        @Override
        public FImage subtractInplace(final Float num)
        {
                final float fnum = num;
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] -= fnum;
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#subtractInplace(org.openimaj.image.Image)
         */
        @Override
        public FImage subtractInplace(final Image<?, ?> im)
        {
                if (im instanceof FImage)
                        return this.subtractInplace((FImage) im);
                else
                        throw new UnsupportedOperationException("Unsupported Type");
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#threshold(java.lang.Object)
         */
        @Override
        public FImage threshold(final Float thresh)
        {
                final float fthresh = thresh;
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                if (this.pixels[r][c] <= fthresh)
                                        this.pixels[r][c] = 0;
                                else
                                        this.pixels[r][c] = 1;
                        }
                }
                return this;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#toByteImage()
         */
        @Override
        public byte[] toByteImage()
        {
                final byte[] pgmData = new byte[this.height * this.width];

                for (int j = 0; j < this.height; j++)
                {
                        for (int i = 0; i < this.width; i++)
                        {
                                int v = (int) (255.0f * this.pixels[j][i]);

                                v = Math.max(0, Math.min(255, v));

                                pgmData[i + j * this.width] = (byte) (v & 0xFF);
                        }
                }
                return pgmData;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#toPackedARGBPixels()
         */
        @Override
        public int[] toPackedARGBPixels()
        {
                final int[] bimg = new int[this.width * this.height];

                for (int r = 0; r < this.height; r++) {
                        for (int c = 0; c < this.width; c++) {
                                final int v = (Math.max(0, Math.min(255, (int) (this.pixels[r][c] * 255))));

                                final int rgb = 0xff << 24 | v << 16 | v << 8 | v;
                                bimg[c + this.width * r] = rgb;
                        }
                }

                return bimg;
        }

        /**
         * {@inheritDoc}
         *
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
                String imageString = "";
                for (int y = 0; y < this.height; y++) {
                        for (int x = 0; x < this.width; x++) {
                                imageString += String.format("%+.3f ", this.pixels[y][x]);
                                if (x == 16) {
                                        if (this.width - 16 <= x)
                                                continue;
                                        imageString += "... ";
                                        x = this.width - 16;
                                }
                        }
                        imageString += "\n";
                        if (y == 16) {
                                if (this.height - 16 <= y)
                                        continue;
                                y = this.height - 16;
                                imageString += "... \n";
                        }

                }
                return imageString;
        }

        /**
         * Returns a string representation of every pixel in this image using the
         * format string (see {@link String#format(String, Object...)}) to format
         * each pixel value.
         *
         * @param format
         *            The format string to use for each pixel output
         * @return A string representation of the image
         * @see String#format(String, Object...)
         */
        public String toString(final String format) {
                String imageString = "";
                for (int y = 0; y < this.height; y++) {
                        for (int x = 0; x < this.width; x++) {
                                imageString += String.format(format, this.pixels[y][x]);
                        }
                        imageString += "\n";
                }
                return imageString;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#transform(Jama.Matrix)
         */
        @Override
        public FImage transform(final Matrix transform) {
                return super.transform(transform);
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.Image#zero()
         */
        @Override
        public FImage zero()
        {
                for (int r = 0; r < this.height; r++)
                {
                        for (int c = 0; c < this.width; c++)
                        {
                                this.pixels[r][c] = 0;
                        }
                }
                return this;
        }

        @Override
        public boolean equals(final Object o) {
                if (!(o instanceof FImage)) {
                        return false;
                }
                return this.equalsThresh((FImage) o, 0);
        }

        /**
         * Compare this image against another using a threshold on the absolute
         * difference between pixel values in order to determine equality.
         *
         * @param o
         *            the image to compare against
         * @param thresh
         *            the threshold for determining equality
         * @return true images are the same size and if all pixel values have a
         *         difference less than threshold; false otherwise.
         */
        public boolean equalsThresh(final FImage o, final float thresh) {
                final FImage that = o;
                if (that.height != this.height || that.width != this.width)
                        return false;
                for (int i = 0; i < this.height; i++) {
                        for (int j = 0; j < this.width; j++) {
                                if (Math.abs(that.pixels[i][j] - this.pixels[i][j]) > thresh) {
                                        return false;
                                }
                        }
                }
                return true;
        }

        /**
         * 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) {
                return this.pixels[y][x];
        }

        /**
         * 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.pixels[y][x];

                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) {
                this.pixels[y][x] = val;
        }

        /**
         * Convenience method to initialise an array of FImages
         *
         * @param num
         *            array length
         * @param width
         *            width of images
         * @param height
         *            height of images
         * @return array of newly initialised images
         */
        public static FImage[] createArray(final int num, final int width, final int height) {
                final FImage[] array = new FImage[num];

                for (int i = 0; i < num; i++) {
                        array[i] = new FImage(width, height);
                }

                return array;
        }

        /**
         * @return The sum of all the pixels in the image
         */
        public float sum() {
                float sum = 0;
                for (final float[] row : this.pixels) {
                        for (int i = 0; i < row.length; i++) {
                                sum += row[i];
                        }
                }
                return sum;
        }

        /**
         * Convert this {@link FImage} to an RGB {@link MBFImage}.
         *
         * @return a new RGB colour image.
         */
        public MBFImage toRGB() {
                return new MBFImage(ColourSpace.RGB, this.clone(), this.clone(), this.clone());
        }

        @Override
        public FImage flipX() {
                final int hwidth = this.width / 2;

                for (int y = 0; y < this.height; y++) {
                        for (int x = 0; x < hwidth; x++) {
                                final int xx = this.width - x - 1;

                                final float tmp = this.pixels[y][x];

                                this.pixels[y][x] = this.pixels[y][xx];
                                this.pixels[y][xx] = tmp;
                        }
                }
                return this;
        }

        @Override
        public FImage flipY() {
                final int hheight = this.height / 2;

                for (int y = 0; y < hheight; y++) {
                        final int yy = this.height - y - 1;

                        for (int x = 0; x < this.width; x++) {
                                final float tmp = this.pixels[y][x];

                                this.pixels[y][x] = this.pixels[yy][x];
                                this.pixels[yy][x] = tmp;
                        }
                }

                return this;
        }

        /**
         * Overlay the given image on this image with the given alpha channel at the
         * given location.
         *
         * @param img
         *            The image to overlay
         * @param alpha
         *            The alpha channel to use
         * @param x
         *            The location to draw the image
         * @param y
         *            The location to draw the image
         * @return This image with the overlay on it
         */
        public FImage overlayInplace(final FImage img, final FImage alpha, final int x, final int y)
        {
                final int sx = Math.max(x, 0);
                final int sy = Math.max(y, 0);
                final int ex = Math.min(this.width, x + img.getWidth());
                final int ey = Math.min(this.height, y + img.getHeight());

                for (int yc = sy; yc < ey; yc++)
                {
                        for (int xc = sx; xc < ex; xc++)
                        {
                                final float a = alpha.pixels[yc - sy][xc - sx];
                                this.pixels[yc][xc] = (a * img.pixels[yc - sy][xc - sx] +
                                                (1 - a) * this.pixels[yc][xc]);
                        }
                }

                return this;
        }

        /**
         * {@inheritDoc}
         * <p>
         * This method will overlay the given image at the given location with full
         * opacity.
         *
         * @see org.openimaj.image.Image#overlayInplace(org.openimaj.image.Image,
         *      int, int)
         */
        @Override
        public FImage overlayInplace(final FImage image, final int x, final int y)
        {
                return this.overlayInplace(image, this.clone().fill(1f), x, y);
        }

        /**
         * Create a random image of the given size.
         *
         * @param width
         *            the width
         * @param height
         *            the height
         * @return the image
         */
        public static FImage randomImage(final int width, final int height) {
                final FImage img = new FImage(width, height);

                for (int y = 0; y < height; y++)
                        for (int x = 0; x < width; x++)
                                img.pixels[y][x] = (float) Math.random();

                return img;
        }

        @Override
        public FImage replace(Float target, Float replacement) {
                return replace((float) target, (float) replacement);
        }

        /**
         * Replace pixels of a certain colour with another colour. Side-affects this
         * image.
         *
         * @param target
         *            the colour to fill the image with
         * @param replacement
         *            the colour to fill the image with
         * @return A reference to this image.
         */
        public FImage replace(float target, float replacement) {
                for (int r = 0; r < this.height; r++)
                        for (int c = 0; c < this.width; c++)
                                if (this.pixels[r][c] == target)
                                        this.pixels[r][c] = replacement;

                return this;
        }

        @Override
        public FImage extractCentreSubPix(float cx, float cy, FImage out) {
                final int width = out.width;
                final int height = out.height;
                for (int y = 0; y < height; y++) {
                        for (int x = 0; x < width; x++) {
                                final float ix = (float) (x + cx - (width - 1) * 0.5);
                                final float iy = (float) (y + cy - (height - 1) * 0.5);
                                out.pixels[y][x] = this.getPixelInterpNative(ix, iy, 0f);
                        }
                }
                return out;
        }
}