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

import org.openimaj.image.DisplayUtilities;
import org.openimaj.image.FImage;
import org.openimaj.image.analysis.algorithm.EdgeDirectionCoherenceVector;
import org.openimaj.image.processor.SinglebandImageProcessor;

/**
 * This implementation is deprecated and is only kept for backward-compatibility
 * of old {@link EdgeDirectionCoherenceVector} features. Use the
 * {@link CannyEdgeDetector} instead.
 * <p>
 * This is an implementation of the canny edge detector that was found somewhere
 * out there on the web with no attribution. If this is your code and you don't
 * want it in OpenIMAJ, please let us know.
 *
 * @author David Dupplaw (dpd@ecs.soton.ac.uk)
 */
@Deprecated
public class CannyEdgeDetector2 implements SinglebandImageProcessor<Float, FImage>
{
        private boolean complete;

        /** The threshold */
        private int threshold = 128;

        /** The first hysteresis threshold */
        private int hystThresh1 = 50;

        /** The second hysteresis threshold */
        private int hystThresh2 = 230;

        /** The Guassian kernel size */
        private int kernelSize = 15;

        final float ORIENT_SCALE = 40F;
        private int height;
        private int width;
        private int picsize;
        private float[] data;
        private int derivative_mag[];
        private float magnitude[];
        private float orientation[];
        private FImage sourceImage;
        private FImage edgeImage;

        /**
         * Default constructor
         */
        public CannyEdgeDetector2()
        {
                complete = false;
        }

        /**
         * @return Returns whether the processing has completed.
         */
        public boolean isImageReady()
        {
                return complete;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.image.processor.ImageProcessor#processImage(org.openimaj.image.Image)
         */
        @Override
        public void processImage(FImage image)
        {
                complete = false;

                final int widGaussianKernel = kernelSize;
                final int threshold = this.threshold;
                final int threshold1 = hystThresh1;
                final int threshold2 = hystThresh2;

                if (threshold < 0 || threshold > 255)
                {
                        throw new IllegalArgumentException("The value of the threshold " +
                                        "is out of its valid range.");
                }

                if (widGaussianKernel < 3 || widGaussianKernel > 40)
                {
                        throw new IllegalArgumentException("The value of the widGaussianKernel " +
                                        "is out of its valid range.");
                }

                width = image.getWidth();
                height = image.getHeight();
                picsize = width * height;
                sourceImage = image;

                data = new float[picsize];
                magnitude = new float[picsize];
                orientation = new float[picsize];

                final float f = 1.0F;
                canny_core(f, widGaussianKernel);
                thresholding_tracker(threshold1, threshold2);

                for (int i = 0; i < picsize; i++)
                        if (data[i] > threshold)
                                data[i] = 1;
                        else
                                data[i] = -1;

                edgeImage = new FImage(data, width, height).normalise();
                data = null;

                complete = true;

                image.internalAssign(edgeImage);
        }

        /**
         * Assumes the input is a one-dimensional representation of an image.
         * Displays the image.
         *
         * @param data
         *            A one-dimensional representation of an image.
         */
        protected void display(int[] data)
        {
                final FImage tmp = new FImage(width, height);
                for (int r = 0; r < height; r++)
                        for (int c = 0; c < width; c++)
                                tmp.pixels[r][c] = data[c + r * width] / 255f;
                DisplayUtilities.display(tmp);
        }

        /**
         * Assumes the input is a one-dimensional representation of an image.
         * Displays the image.
         *
         * @param data
         *            A one-dimensional representation of an image.
         */
        protected void display(float[] data)
        {
                final FImage tmp = new FImage(width, height);
                for (int r = 0; r < height; r++)
                        for (int c = 0; c < width; c++)
                                tmp.pixels[r][c] = data[c + r * width] / 255f;
                DisplayUtilities.display(tmp);
        }

        /**
         * @param f
         * @param i
         */
        private void canny_core(float f, int i)
        {
                derivative_mag = new int[picsize];
                final float af4[] = new float[i];
                final float af5[] = new float[i];
                final float af6[] = new float[i];
                // data = image2pixels( sourceImage );
                data = sourceImage.clone().multiply(255.0f).getFloatPixelVector();
                int k4 = 0;
                do {
                        if (k4 >= i)
                                break;
                        final float f1 = gaussian(k4, f);
                        if (f1 <= 0.005F && k4 >= 2)
                                break;
                        final float f2 = gaussian(k4 - 0.5F, f);
                        final float f3 = gaussian(k4 + 0.5F, f);
                        final float f4 = gaussian(k4, f * 0.5F);
                        af4[k4] = (f1 + f2 + f3) / 3F / (6.283185F * f * f);
                        af5[k4] = f3 - f2;
                        af6[k4] = 1.6F * f4 - f1;
                        k4++;
                } while (true);

                final int j = k4;
                float af[] = new float[picsize];
                float af1[] = new float[picsize];
                int j1 = width - (j - 1);
                int l = width * (j - 1);
                int i1 = width * (height - (j - 1));
                for (int l4 = j - 1; l4 < j1; l4++) {
                        for (int l5 = l; l5 < i1; l5 += width) {
                                final int k1 = l4 + l5;
                                float f8 = data[k1] * af4[0];
                                float f10 = f8;
                                int l6 = 1;
                                int k7 = k1 - width;
                                for (int i8 = k1 + width; l6 < j; i8 += width) {
                                        f8 += af4[l6] * (data[k7] + data[i8]);
                                        f10 += af4[l6] * (data[k1 - l6] + data[k1 + l6]);
                                        l6++;
                                        k7 -= width;
                                }

                                af[k1] = f8;
                                af1[k1] = f10;
                        }

                }

                float af2[] = new float[picsize];
                for (int i5 = j - 1; i5 < j1; i5++) {
                        for (int i6 = l; i6 < i1; i6 += width) {
                                float f9 = 0.0F;
                                final int l1 = i5 + i6;
                                for (int i7 = 1; i7 < j; i7++)
                                        f9 += af5[i7] * (af[l1 - i7] - af[l1 + i7]);

                                af2[l1] = f9;
                        }

                }

                af = null;
                float af3[] = new float[picsize];
                for (int j5 = k4; j5 < width - k4; j5++) {
                        for (int j6 = l; j6 < i1; j6 += width) {
                                float f11 = 0.0F;
                                final int i2 = j5 + j6;
                                int j7 = 1;
                                for (int l7 = width; j7 < j; l7 += width) {
                                        f11 += af5[j7] * (af1[i2 - l7] - af1[i2 + l7]);
                                        j7++;
                                }

                                af3[i2] = f11;
                        }

                }

                // display(af3);

                af1 = null;
                j1 = width - j;
                l = width * j;
                i1 = width * (height - j);
                for (int k5 = j; k5 < j1; k5++) {
                        for (int k6 = l; k6 < i1; k6 += width) {
                                final int j2 = k5 + k6;
                                final int k2 = j2 - width;
                                final int l2 = j2 + width;
                                final int i3 = j2 - 1;
                                final int j3 = j2 + 1;
                                final int k3 = k2 - 1;
                                final int l3 = k2 + 1;
                                final int i4 = l2 - 1;
                                final int j4 = l2 + 1;
                                final float f6 = af2[j2];
                                final float f7 = af3[j2];
                                final float f12 = hypotenuse(f6, f7);
                                final int k = (int) (f12 * 20D);
                                derivative_mag[j2] = k >= 256 ? 255 : k;
                                final float f13 = hypotenuse(af2[k2], af3[k2]);
                                final float f14 = hypotenuse(af2[l2], af3[l2]);
                                final float f15 = hypotenuse(af2[i3], af3[i3]);
                                final float f16 = hypotenuse(af2[j3], af3[j3]);
                                final float f18 = hypotenuse(af2[l3], af3[l3]);
                                final float f20 = hypotenuse(af2[j4], af3[j4]);
                                final float f19 = hypotenuse(af2[i4], af3[i4]);
                                final float f17 = hypotenuse(af2[k3], af3[k3]);
                                float f5;
                                if (f6 * f7 <= 0
                                                ? Math.abs(f6) >= Math.abs(f7)
                                                ? (f5 = Math.abs(f6 * f12))
                                                                >= Math.abs(f7 * f18 - (f6 + f7) * f16)
                                                                && f5
                                                                > Math.abs(f7 * f19 - (f6 + f7) * f15) : (
                                                                                f5 = Math.abs(f7 * f12))
                                                                                >= Math.abs(f6 * f18 - (f7 + f6) * f13)
                                                                                && f5
                                                                                > Math.abs(f6 * f19 - (f7 + f6) * f14) : Math.abs(f6)
                                                                                >= Math.abs(f7)
                                                                                ? (f5 = Math.abs(f6 * f12))
                                                                                                >= Math.abs(f7 * f20 + (f6 - f7) * f16)
                                                                                                && f5
                                                                                                > Math.abs(f7 * f17 + (f6 - f7) * f15) : (
                                                                                                                f5 = Math.abs(f7 * f12))
                                                                                                                >= Math.abs(f6 * f20 + (f7 - f6) * f14)
                                                                                                                && f5 > Math.abs(f6 * f17 + (f7 - f6) * f13))
                                {
                                        magnitude[j2] = derivative_mag[j2];
                                        orientation[j2] = (float) Math.toDegrees(
                                                        Math.atan2(f7, f6));
                                }
                        }

                }

                derivative_mag = null;
                af2 = null;
                af3 = null;
        }

        /**
         * If <code>f</code> and <code>f1</code> are the shorter sides of a
         * triangle, calculates the hypotenuse of the triangle.
         *
         * @param f
         *            short side of a triangle
         * @param f1
         *            short side of a triangle
         * @return The length of the hypotenuse.
         */
        private float hypotenuse(float f, float f1)
        {
                if (f == 0.0F && f1 == 0.0F)
                        return 0.0F;
                else
                        return (float) Math.sqrt(f * f + f1 * f1);
        }

        private float gaussian(float f, float f1) {
                return (float) Math.exp((-f * f) / (2 * f1 * f1));
        }

        private void thresholding_tracker(int i, int j) {
                for (int k = 0; k < picsize; k++)
                        data[k] = 0;

                for (int l = 0; l < width; l++) {
                        for (int i1 = 0; i1 < height; i1++)
                                if (magnitude[l + width * i1] >= i)
                                        follow(l, i1, j);

                }

        }

        /**
         * @param i
         * @param j
         * @param k
         * @return
         */
        private boolean follow(int i, int j, int k)
        {
                int j1 = i + 1;
                int k1 = i - 1;
                int l1 = j + 1;
                int i2 = j - 1;
                final int j2 = i + j * width;
                if (l1 >= height)
                        l1 = height - 1;
                if (i2 < 0)
                        i2 = 0;
                if (j1 >= width)
                        j1 = width - 1;
                if (k1 < 0)
                        k1 = 0;
                if (data[j2] == 0) {
                        data[j2] = magnitude[j2];
                        boolean flag = false;
                        int l = k1;
                        do {
                                if (l > j1)
                                        break;
                                int i1 = i2;
                                do {
                                        if (i1 > l1)
                                                break;
                                        final int k2 = l + i1 * width;
                                        if ((i1 != j || l != i)
                                                        && magnitude[k2] >= k
                                                        && follow(l, i1, k))
                                        {
                                                flag = true;
                                                break;
                                        }
                                        i1++;
                                } while (true);
                                if (!flag)
                                        break;
                                l++;
                        } while (true);
                        return true;
                } else {
                        return false;
                }
        }

        /**
         * @param image
         */
        public void setSourceImage(FImage image)
        {
                sourceImage = image;
        }

        /**
         * @return edgeImage
         */
        public FImage getEdgeImage()
        {
                return edgeImage;
        }

        /**
         * @return magnitude
         */
        public float[] getMagnitude()
        {
                return magnitude;
        }

        /**
         * @return orientation
         */
        public float[] getOrientation()
        {
                return orientation;
        }

        /**
         * Get the threshold above which an edge pixel will be considered an edge.
         *
         * @return the threshold above which edge pixels will be considered edges.
         */
        public int getThreshold()
        {
                return threshold;
        }

        /**
         * Get the threshold above which an edge pixel will be considered an edge.
         *
         * @param threshold
         *            the threshold above which an edge pixel will be considered an
         *            edge.
         */
        public void setThreshold(int threshold)
        {
                this.threshold = threshold;
        }

        /**
         * Get the first hysteresis threshold.
         *
         * @return the first hysteresis threshold.
         */
        public int getHystThresh1()
        {
                return hystThresh1;
        }

        /**
         * Set the fist hysteresis threshold.
         *
         * @param hystThresh1
         *            the threshold value
         */
        public void setHystThresh1(int hystThresh1)
        {
                this.hystThresh1 = hystThresh1;
        }

        /**
         * Get the second hysteresis threshold.
         *
         * @return the second hysteresis threshold.
         */
        public int getHystThresh2()
        {
                return hystThresh2;
        }

        /**
         * Set the second hysteresis threshold.
         *
         * @param hystThresh2
         *            the threshold value
         */
        public void setHystThresh2(int hystThresh2)
        {
                this.hystThresh2 = hystThresh2;
        }

        /**
         * Get the kernel size being used.
         *
         * @return the kernel size being used for blurring
         */
        public int getKernelSize()
        {
                return kernelSize;
        }

        /**
         * Set the kernel size to use.
         *
         * @param kernelSize
         *            the size of the kernel to use for blurring.
         */
        public void setKernelSize(int kernelSize)
        {
                this.kernelSize = kernelSize;
        }
}