/***
 * Neuroph  http://neuroph.sourceforge.net
 * Copyright by Neuroph Project (C) 2008
 *
 * This file is part of Neuroph framework.
 *
 * Neuroph is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Neuroph is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Neuroph. If not, see <http://www.gnu.org/licenses/>.
 */

package org.neuroph.contrib.imgrec;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.util.Arrays;

/**
 * The intention of this class is to allow you to pay up front (at construction) 
 * the compute cost of converting the RGB values in a BufferedImage into a derived form.
 * 
 * The major benefit of using this class is a single loop that grabs all 3 color channels
 * (red, green, and blue) from each (x,y) coordinate, as opposed to looping through each
 * color channel (red, green, or blue) when you need it.
 * 
 * If you only need a single color from the channels (red, green, or blue) then
 * using this class may be more expensive than a custom solution.
 * 
 * In the event that it needs to be parsed, the flattened rgb values array contains 
 * all the red first, followed by all the green, followed by all the blue values.  
 * The flattened array size should be divisible by 3. 
 * 
 * @author Jon Tait
 *
 */
public class FractionRgbData
{
        /**
         * Image width
         */
	private int width;

        /**
         * Image height
         */
	private int height;

        /**
         * Array which contains red componenet of the color for each image pixel
         */
	protected double[][] redValues;

        /**
         * Array which contains green componenet of the color for each image pixel
         */
	protected double[][] greenValues;

        /**
         * Array which contains blue componenet of the color for each image pixel
         */
	protected double[][] blueValues;

        /**
         * Single array with the red, green and blue componenets of the color for each image pixel
         */
	protected double[] flattenedRgbValues;

        /**
         * Creates rgb data for the specified image.
         * @param img image to cretae rgb data for
         */
	public FractionRgbData(BufferedImage img)
	{
		width = img.getWidth();
		height = img.getHeight();
		
		redValues = new double[height][width];
		greenValues = new double[height][width];
		blueValues = new double[height][width];
		flattenedRgbValues = new double[width * height * 3];
		
		populateRGBArrays(img);
	}

        /**
         * Fills the rgb arrays from image
         * @param img image to get rgb data from
         */
	protected void populateRGBArrays(BufferedImage img)
	{
		for (int y = 0; y < height; y++) {
			for (int x = 0; x < width; x++) {
				Color color = new Color(img.getRGB(x, y));

				double red = ((double) color.getRed()) / 256d;
				redValues[y][x] = red;
				flattenedRgbValues[(y * width + x)] = red;

				double green = ((double) color.getGreen()) / 256d;
				greenValues[y][x] = green;
				flattenedRgbValues[(width * height + y * width + x)] = green;

				double blue = ((double) color.getBlue()) / 256d;
				blueValues[y][x] = blue;
				flattenedRgbValues[(2 * width * height + y * width + x)] = blue;
			}
		}
	}

        /**
         * Converts image rgb data to binary black and white data
         * @param inputRGB flatten rgb data
         * @return binary black and white representation of image
         */
        public static double[] convertRgbInputToBinaryBlackAndWhite(double[] inputRGB) {
            double inputBinary[]= new double[inputRGB.length/3];

            for(int i=0; i<inputRGB.length/3; i+=3) {
                if (inputRGB[i]>0) inputBinary[i] = 0;
                    else inputBinary[i] = 1;
            }

            return inputBinary;
        }

        /**
         * Get image width
         * @return image width
         */
	public int getWidth()
	{
		return width;
	}

        /**
         * Get image height
         * @return image height
         */
	public int getHeight()
	{
		return height;
	}

	/**
	 * Returns red color component for the entire image
	 * @return 2d array in the form: [row][column]
	 */
	public double[][] getRedValues()
	{
		return redValues;
	}

	/**
	 * Returns green color component for the entire image
	 * @return 2d array in the form: [row][column]
	 */
	public double[][] getGreenValues()
	{
		return greenValues;
	}

	/**
	 * Returns blue color component for the entire image
	 * @return 2d array in the form: [row][column]
	 */
	public double[][] getBlueValues()
	{
		return blueValues;
	}

	/**
	 * Returns rgb data in a form: all red rows, all green rows, all blue rows
	 * @return All the red rows, followed by all the green rows, 
	 * followed by all the blue rows.
	 */
	public double[] getFlattenedRgbValues()
	{
		return flattenedRgbValues;
	}
	
	@Override
	public boolean equals(Object obj)
	{
		if(obj == null || !(obj instanceof FractionRgbData)) {
			return false;
		}
		FractionRgbData other = (FractionRgbData) obj;
		return Arrays.equals(flattenedRgbValues, other.getFlattenedRgbValues());
	}
	
	@Override
	public int hashCode()
	{
		return Arrays.hashCode(flattenedRgbValues);
	}
	
	@Override
	public String toString()
	{
		return Arrays.toString(flattenedRgbValues);
	}
}