/**
 * 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.renderer;

import org.openimaj.image.FImage;
import org.openimaj.image.pixel.Pixel;
import org.openimaj.image.renderer.ScanRasteriser.ScanLineListener;
import org.openimaj.math.geometry.line.Line2d;
import org.openimaj.math.geometry.point.Point2d;
import org.openimaj.math.geometry.point.Point2dImpl;
import org.openimaj.math.geometry.shape.Polygon;

/**
 * {@link ImageRenderer} for {@link FImage} images. Supports both anti-aliased
 * and fast rendering.
 *
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 *
 */
public class FImageRenderer extends ImageRenderer<Float, FImage> {

        /**
         * Construct with given target image.
         *
         * @param targetImage
         *            the target image.
         */
        public FImageRenderer(final FImage targetImage) {
                super(targetImage);
        }

        /**
         * Construct with given target image and rendering hints.
         *
         * @param targetImage
         *            the target image.
         * @param hints
         *            the render hints
         */
        public FImageRenderer(final FImage targetImage, final RenderHints hints) {
                super(targetImage, hints);
        }

        @Override
        public Float defaultForegroundColour() {
                return 1f;
        }

        @Override
        public Float defaultBackgroundColour() {
                return 0f;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.renderer.ImageRenderer#drawLine(int, int, double,
         *      int, int, java.lang.Object)
         */
        @Override
        public void drawLine(final int x1, final int y1, final double theta, final int length, final int thickness,
                        final Float grey)
        {
                final int x2 = x1 + (int) Math.round(Math.cos(theta) * length);
                final int y2 = y1 + (int) Math.round(Math.sin(theta) * length);

                this.drawLine(x1, y1, x2, y2, thickness, grey);
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.renderer.ImageRenderer#drawLine(int, int, int,
         *      int, int, java.lang.Object)
         */
        @Override
        public void drawLine(final int x0, final int y0, final int x1, final int y1, final int thickness, final Float grey) {
                this.drawLine((float) x0, (float) y0, (float) x1, (float) y1, thickness, grey);
        }

        @Override
        public void drawLine(final float x0, final float y0, final float x1, final float y1, final int thickness,
                        final Float grey)
        {
                switch (this.hints.drawingAlgorithm) {
                case ANTI_ALIASED:
                        if (thickness <= 1) {
                                this.drawLineXiaolinWu(x0, y0, x1, y1, grey);
                        } else {
                                final double theta = Math.atan2(y1 - y0, x1 - x0);
                                final double t = thickness / 2;
                                final double sin = t * Math.sin(theta);
                                final double cos = t * Math.cos(theta);

                                final Polygon p = new Polygon();
                                p.addVertex(new Point2dImpl((float) (x0 - sin), (float) (y0 + cos)));
                                p.addVertex(new Point2dImpl((float) (x0 + sin), (float) (y0 - cos)));
                                p.addVertex(new Point2dImpl((float) (x1 + sin), (float) (y1 - cos)));
                                p.addVertex(new Point2dImpl((float) (x1 - sin), (float) (y1 + cos)));

                                this.drawPolygonFilled(p, grey);
                        }
                        break;
                default:
                        this.drawLineBresenham(Math.round(x0), Math.round(y0), Math.round(x1), Math.round(y1), thickness, grey);
                }
        }

        private float fpart(final float f) {
                return f - (int) f;
        }

        private float rfpart(final float f) {
                return 1 - this.fpart(f);
        }

        private void plot(final int a, final int b, final float c, final float grey, final boolean reversed) {
                int x, y;
                if (reversed) {
                        y = a;
                        x = b;
                } else {
                        x = a;
                        y = b;
                }

                if (x >= 0 && x < this.targetImage.width && y >= 0 && y < this.targetImage.height && !Float.isNaN(c)) {
                        this.targetImage.pixels[y][x] = c * grey + (1 - c) * this.targetImage.pixels[y][x];
                }
        }

        /*
         * Implementation of Xiaolin Wu's anti-aliased line drawing algorithm. Based
         * on the wikipedia article:
         * http://en.wikipedia.org/wiki/Xiaolin_Wu's_line_algorithm
         */
        protected void drawLineXiaolinWu(float x1, float y1, float x2, float y2, final Float grey) {
                float dx = x2 - x1;
                float dy = y2 - y1;
                boolean reversed = false;

                if (Math.abs(dx) < Math.abs(dy)) {
                        float tmp;
                        tmp = x1;
                        x1 = y1;
                        y1 = tmp;
                        tmp = x2;
                        x2 = y2;
                        y2 = tmp;
                        tmp = dx;
                        dx = dy;
                        dy = tmp;
                        reversed = true;
                }

                if (x2 < x1) {
                        float tmp;
                        tmp = x1;
                        x1 = x2;
                        x2 = tmp;
                        tmp = y1;
                        y1 = y2;
                        y2 = tmp;
                }

                final float gradient = dy / dx;

                // handle first endpoint
                int xend = Math.round(x1);
                float yend = y1 + gradient * (xend - x1);
                float xgap = this.rfpart(x1 + 0.5f);
                final int xpxl1 = xend; // this will be used in the main loop
                final int ypxl1 = (int) (yend);
                this.plot(xpxl1, ypxl1, this.rfpart(yend) * xgap, grey, reversed);
                this.plot(xpxl1, ypxl1 + 1, this.fpart(yend) * xgap, grey, reversed);
                float intery = yend + gradient; // first y-intersection for the main
                // loop

                // handle second endpoint
                xend = Math.round(x2);
                yend = y2 + gradient * (xend - x2);
                xgap = this.fpart(x2 + 0.5f);
                final int xpxl2 = xend; // this will be used in the main loop
                final int ypxl2 = (int) (yend);
                this.plot(xpxl2, ypxl2, this.rfpart(yend) * xgap, grey, reversed);
                this.plot(xpxl2, ypxl2 + 1, this.fpart(yend) * xgap, grey, reversed);

                // main loop
                for (int x = xpxl1 + 1; x <= xpxl2 - 1; x++) {
                        this.plot(x, (int) (intery), this.rfpart(intery), grey, reversed);
                        this.plot(x, (int) (intery) + 1, this.fpart(intery), grey, reversed);
                        intery += gradient;
                }
        }

        /*
         * Implementation of Bresenham's fast line drawing algorithm. Based on the
         * wikipedia article:
         * http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
         */
        protected void drawLineBresenham(int x0, int y0, int x1, int y1, int thickness, final Float grey) {
                final Line2d line = new Line2d(new Point2dImpl(x0, y0), new Point2dImpl(x1, y1))
                                .lineWithinSquare(this.targetImage
                                                .getBounds());
                if (line == null)
                        return;

                x0 = (int) line.begin.getX();
                y0 = (int) line.begin.getY();
                x1 = (int) line.end.getX();
                y1 = (int) line.end.getY();

                final double theta = Math.atan2(y1 - y0, x1 - x0);
                thickness = (int) Math.round(thickness * Math.max(Math.abs(Math.cos(theta)), Math.abs(Math.sin(theta))));

                final int offset = thickness / 2;
                final int extra = thickness % 2;

                // implementation of Bresenham's algorithm from Wikipedia.
                int Dx = x1 - x0;
                int Dy = y1 - y0;
                final boolean steep = (Math.abs(Dy) >= Math.abs(Dx));
                if (steep) {
                        int tmp;
                        // SWAP(x0, y0);
                        tmp = x0;
                        x0 = y0;
                        y0 = tmp;
                        // SWAP(x1, y1);
                        tmp = x1;
                        x1 = y1;
                        y1 = tmp;

                        // recompute Dx, Dy after swap
                        Dx = x1 - x0;
                        Dy = y1 - y0;
                }
                int xstep = 1;
                if (Dx < 0) {
                        xstep = -1;
                        Dx = -Dx;
                }
                int ystep = 1;
                if (Dy < 0) {
                        ystep = -1;
                        Dy = -Dy;
                }
                final int TwoDy = 2 * Dy;
                final int TwoDyTwoDx = TwoDy - 2 * Dx; // 2*Dy - 2*Dx
                int E = TwoDy - Dx; // 2*Dy - Dx
                int y = y0;
                int xDraw, yDraw;
                for (int x = x0; x != x1; x += xstep) {
                        if (steep) {
                                xDraw = y;
                                yDraw = x;
                        } else {
                                xDraw = x;
                                yDraw = y;
                        }
                        // plot
                        if (xDraw >= 0 && xDraw < this.targetImage.width && yDraw >= 0 && yDraw < this.targetImage.height) {
                                if (thickness == 1) {
                                        this.targetImage.pixels[yDraw][xDraw] = grey;
                                } else if (thickness > 1) {
                                        for (int yy = yDraw - offset; yy < yDraw + offset + extra; yy++)
                                                for (int xx = xDraw - offset; xx < xDraw + offset + extra; xx++)
                                                        if (xx >= 0 && yy >= 0 && xx < this.targetImage.width && yy < this.targetImage.height)
                                                                this.targetImage.pixels[yy][xx] = grey;
                                }
                        }

                        // next
                        if (E > 0) {
                                E += TwoDyTwoDx; // E += 2*Dy - 2*Dx;
                                y = y + ystep;
                        } else {
                                E += TwoDy; // E += 2*Dy;
                        }
                }
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.renderer.ImageRenderer#drawPoint(org.openimaj.math.geometry.point.Point2d,
         *      java.lang.Object, int)
         */
        @Override
        public void drawPoint(final Point2d p, final Float grey, final int size) {

                if (!this.targetImage.getBounds().isInside(p))
                        return;
                final int halfsize = (size + 1) / 2; // 3 == 2, 4 = 2, 5 = 3, 6 = 3 etc.
                // TODO anti-aliased point rendering
                final int x = Math.round(p.getX());
                final int y = Math.round(p.getY());
                final int startx = Math.max(0, x - (halfsize - 1));
                final int starty = Math.max(0, y - (halfsize - 1));
                final int endx = Math.min(this.targetImage.width, x + halfsize);
                final int endy = Math.min(this.targetImage.height, y + halfsize);

                for (int j = starty; j < endy; j++) {
                        for (int i = startx; i < endx; i++) {
                                this.targetImage.pixels[j][i] = grey;
                        }
                }
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.renderer.ImageRenderer#drawPolygon(org.openimaj.math.geometry.shape.Polygon,
         *      int, java.lang.Object)
         */
        @Override
        public void drawPolygon(final Polygon p, final int thickness, final Float grey) {
                if (p.nVertices() < 2)
                        return;

                Point2d p1, p2;
                for (int i = 0; i < p.nVertices() - 1; i++) {
                        p1 = p.getVertices().get(i);
                        p2 = p.getVertices().get(i + 1);
                        this.drawLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(), thickness, grey);
                }

                p1 = p.getVertices().get(p.nVertices() - 1);
                p2 = p.getVertices().get(0);
                this.drawLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(), thickness, grey);

                for (final Polygon i : p.getInnerPolys())
                        drawPolygon(i, thickness, grey);
        }

        @Override
        protected void drawHorizLine(final int x1, final int x2, final int y, final Float col) {
                if (y < 0 || y > this.targetImage.getHeight() - 1)
                        return;

                final int startx = Math.max(0, Math.min(x1, x2));
                final int stopx = Math.min(Math.max(x1, x2), this.targetImage.getWidth() - 1);
                final float[][] img = this.targetImage.pixels;
                final float c = col;

                for (int x = startx; x <= stopx; x++) {
                        img[y][x] = c;
                }
        }

        @Override
        protected Float sanitise(final Float colour) {
                return colour;
        }

        @Override
        public void drawPolygonFilled(Polygon p, final Float col) {
                // clip to the frame
                // p = p.intersect(this.targetImage.getBounds().asPolygon());

                this.drawPolygon(p, col);

                if (p.getNumInnerPoly() == 1) {
                        ScanRasteriser.scanFill(p.points, new ScanLineListener() {
                                @Override
                                public void process(final int x1, final int x2, final int y) {
                                        FImageRenderer.this.drawHorizLine(x1, x2, y, col);
                                }
                        });
                } else {
                        final int minx = Math.max(0, (int) Math.round(p.minX()));
                        final int maxx = Math.min((int) Math.round(p.maxX()), targetImage.width - 1);
                        final int miny = Math.max(0, (int) Math.round(p.minY()));
                        final int maxy = Math.min((int) Math.round(p.maxY()), targetImage.height - 1);

                        final Pixel tmp = new Pixel();
                        for (tmp.y = miny; tmp.y <= maxy; tmp.y++) {
                                for (tmp.x = minx; tmp.x <= maxx; tmp.x++) {
                                        if (p.isInside(tmp))
                                                this.targetImage.pixels[tmp.y][tmp.x] = col;
                                }
                        }
                }
        }
}