/**
    * 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.transform;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.openimaj.image.FImage;
  import org.openimaj.image.Image;
  import org.openimaj.image.MBFImage;
  import org.openimaj.image.combiner.AccumulatingImageCombiner;
  import org.openimaj.math.geometry.point.Point2d;
  import org.openimaj.math.geometry.point.Point2dImpl;
  import org.openimaj.math.geometry.shape.Rectangle;
  import org.openimaj.math.geometry.shape.Shape;
  
  import Jama.Matrix;
  
  /**
   * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
   * @author Sina Samangooei (ss@ecs.soton.ac.uk)
   * 
   *         Perform a set of matrix transforms on a set of images and construct a
   *         single image containing all the pixels (or a window of the pixels) in
   *         the projected space.
   * 
   * @param <Q>
   *            The image pixel type
   * @param <T>
   *            the image type
   */
  public class ProjectionProcessor<Q, T extends Image<Q, T>>
  		implements
  		AccumulatingImageCombiner<T, T>
  {
  	protected int minc;
  	protected int minr;
  	protected int maxc;
  	protected int maxr;
  	protected boolean unset;
  	protected List<Matrix> transforms;
  	protected List<Matrix> transformsInverted;
  	protected List<T> images;
  	protected List<Shape> projectedShapes;
  	protected List<Rectangle> projectedRectangles;
  
  	protected Matrix currentMatrix = new Matrix(new double[][] { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } });
  
  	/**
  	 * Construct a projection processor starting with an identity matrix for any
  	 * images processed (i.e., don't do anything)
  	 */
  	public ProjectionProcessor() {
  		unset = true;
  		this.minc = 0;
  		this.minr = 0;
  		this.maxc = 0;
  		this.maxr = 0;
  
  		transforms = new ArrayList<Matrix>();
  		this.transformsInverted = new ArrayList<Matrix>();
  		images = new ArrayList<T>();
  		this.projectedShapes = new ArrayList<Shape>();
  		this.projectedRectangles = new ArrayList<Rectangle>();
  	}
  
  	/**
  	 * Set the matrix, any images processed from this point forward will be
  	 * projected using this matrix
  	 * 
 	 * @param matrix
 	 *            a 3x3 matrix representing a 2d transform
 	 */
 	public void setMatrix(Matrix matrix) {
 		if (matrix.getRowDimension() == 2) {
 			final int c = matrix.getColumnDimension() - 1;
 
 			currentMatrix = new Matrix(3, 3);
 			currentMatrix.setMatrix(0, 1, 0, c, matrix);
 			currentMatrix.set(2, 2, 1);
 		} else {
 			this.currentMatrix = matrix;
 		}
 	}
 
 	/**
 	 * Prepare an image to be transformed using the current matrix. The bounds
 	 * of the image post transform are calculated so the default
 	 * {@link ProjectionProcessor#performProjection} knows what range of pixels
 	 * to draw
 	 * 
 	 * @param image
 	 *            to be transformed
 	 */
 	@Override
 	public void accumulate(T image) {
 		final Rectangle actualBounds = image.getBounds();
 		final Shape transformedActualBounds = actualBounds.transform(this.currentMatrix);
 		final double tminX = transformedActualBounds.minX();
 		final double tmaxX = transformedActualBounds.maxX();
 		final double tminY = transformedActualBounds.minY();
 		final double tmaxY = transformedActualBounds.maxY();
 		if (unset) {
 			this.minc = (int) Math.floor(tminX);
 			this.minr = (int) Math.floor(tminY);
 			this.maxc = (int) Math.floor(tmaxX);
 			this.maxr = (int) Math.floor(tmaxY);
 			unset = false;
 		}
 		else {
 			if (tminX < minc)
 				minc = (int) Math.floor(tminX);
 			if (tmaxX > maxc)
 				maxc = (int) Math.floor(tmaxX);
 			if (tminY < minr)
 				minr = (int) Math.floor(tminY);
 			if (tmaxY > maxr)
 				maxr = (int) Math.floor(tmaxY);
 		}
 		// Expand the borders by 1 pixel so we get a nicer effect around the
 		// edges
 		final float padding = 1f;
 		final Rectangle expandedBounds = new Rectangle(actualBounds.x - padding, actualBounds.y - padding,
 				actualBounds.width + padding * 2, actualBounds.height + padding * 2);
 		final Shape transformedExpandedBounds = expandedBounds.transform(this.currentMatrix);
 		Matrix minv = null, m = null;
 		try {
 			m = this.currentMatrix.copy();
 			minv = this.currentMatrix.copy().inverse();
 		} catch (final Throwable e) {
 			// the matrix might be singular, return
 			return;
 		}
 
 		this.images.add(image);
 		this.transforms.add(m);
 		this.transformsInverted.add(minv);
 		// this.projectedShapes.add(new
 		// TriangulatedPolygon(transformedExpandedBounds));
 		this.projectedShapes.add(transformedExpandedBounds);
 		this.projectedRectangles.add(transformedExpandedBounds.calculateRegularBoundingBox());
 
 		// System.out.println("added image with transform: ");
 		// this.currentMatrix.print(5,5);
 		// System.out.println("and the inverse:");
 		// this.currentMatrix.inverse().print(5,5);
 		// System.out.println("New min/max become:" + minc + "x" + minr + "/" +
 		// maxc + "x" + maxr);
 	}
 
 	/**
 	 * Using all the images currently processed, perform the projection on each
 	 * image and draw every pixel with valid data. Pixels within the bounding
 	 * box but with no data are set to black (more specifically 0, whatever that
 	 * may mean for this kind of image)
 	 * 
 	 * @return the image containing all the pixels drawn
 	 */
 	public T performProjection() {
 		// The most long winded way to get a black pixel EVER
 		return performProjection(false, this.images.get(0).newInstance(1, 1).getPixel(0, 0));
 	}
 
 	/**
 	 * Perform projection specifying the background colour (i.e. the colour of
 	 * pixels with no data).
 	 * 
 	 * @param backgroundColour
 	 *            the background colour
 	 * @return projected images
 	 */
 	public T performProjection(Q backgroundColour) {
 		final int projectionMinC = minc, projectionMaxC = maxc, projectionMinR = minr, projectionMaxR = maxr;
 		return performProjection(projectionMinC, projectionMaxC, projectionMinR, projectionMaxR, backgroundColour);
 	}
 
 	/**
 	 * Perform projection specifying the background colour (i.e. the colour of
 	 * pixels with no data) and whether the original window size should be kept.
 	 * If set to true the window of pixels drawn post projection are within the
 	 * window of the first image processed.
 	 * 
 	 * @param keepOriginalWindow
 	 *            whether to keep the original image's window
 	 * @param backgroundColour
 	 *            the background colour
 	 * @return projected images
 	 */
 	public T performProjection(boolean keepOriginalWindow, Q backgroundColour) {
 		int projectionMinC = minc, projectionMaxC = maxc, projectionMinR = minr, projectionMaxR = maxr;
 		if (keepOriginalWindow)
 		{
 			projectionMinC = 0;
 			projectionMinR = 0;
 			projectionMaxR = images.get(0).getRows();
 			projectionMaxC = images.get(0).getCols();
 		}
 		return performProjection(projectionMinC, projectionMaxC, projectionMinR, projectionMaxR, backgroundColour);
 	}
 
 	/**
 	 * Perform projection but only request data for pixels within the windowed
 	 * range provided. Specify the background colour, i.e. the value of pixels
 	 * with no data post projection.
 	 * 
 	 * @param windowMinC
 	 *            left X
 	 * @param windowMaxC
 	 *            right X
 	 * @param windowMinR
 	 *            top Y
 	 * @param windowMaxR
 	 *            bottom Y
 	 * @return projected image within the window
 	 */
 	public T performProjection(int windowMinC, int windowMaxC, int windowMinR, int windowMaxR) {
 		return performProjection(windowMinC, windowMaxC, windowMinR, windowMaxR, this.images.get(0).newInstance(1, 1)
 				.getPixel(0, 0));
 	}
 
 	/**
 	 * Perform projection but only request data for pixels within the windowed
 	 * range provided. Specify the background colour, i.e. the value of pixels
 	 * with no data post projection.
 	 * 
 	 * @param windowMinC
 	 *            left X
 	 * @param windowMaxC
 	 *            right X
 	 * @param windowMinR
 	 *            top Y
 	 * @param windowMaxR
 	 *            bottom Y
 	 * @param backgroundColour
 	 *            background colour of pixels with no data
 	 * @return projected image within the window
 	 */
 	public T performProjection(int windowMinC, int windowMaxC, int windowMinR, int windowMaxR, Q backgroundColour) {
 		T output = null;
 		output = images.get(0).newInstance(windowMaxC - windowMinC, windowMaxR - windowMinR);
 		if (backgroundColour != null)
 			output.fill(backgroundColour);
 
 		final Shape[][] projectRectangleShapes = getCurrentShapes();
 
 		for (int y = 0; y < output.getHeight(); y++)
 		{
 			for (int x = 0; x < output.getWidth(); x++) {
 				final Point2d realPoint = new Point2dImpl(windowMinC + x, windowMinR + y);
 				int i = 0;
 				for (int shapeIndex = 0; shapeIndex < this.projectedShapes.size(); shapeIndex++) {
 					if (backgroundColour == null || isInside(shapeIndex, projectRectangleShapes, realPoint)) {
 						final double[][] transform = this.transformsInverted.get(i).getArray();
 
 						float xt = (float) transform[0][0] * realPoint.getX() + (float) transform[0][1]
 								* realPoint.getY() + (float) transform[0][2];
 						float yt = (float) transform[1][0] * realPoint.getX() + (float) transform[1][1]
 								* realPoint.getY() + (float) transform[1][2];
 						final float zt = (float) transform[2][0] * realPoint.getX() + (float) transform[2][1]
 								* realPoint.getY() + (float) transform[2][2];
 
 						xt /= zt;
 						yt /= zt;
 						final T im = this.images.get(i);
 						if (backgroundColour != null)
 							output.setPixel(x, y, im.getPixelInterp(xt, yt, backgroundColour));
 						else
 							output.setPixel(x, y, im.getPixelInterp(xt, yt));
 					}
 					i++;
 				}
 			}
 		}
 		return output;
 	}
 
 	/**
 	 * Get the current shapes as an array for efficient access, first entry for
 	 * each shape is its rectangle, second entry is the shape
 	 * 
 	 * @return
 	 */
 	protected Shape[][] getCurrentShapes() {
 		final Shape[][] currentShapes = new Shape[this.projectedShapes.size()][2];
 		for (int i = 0; i < this.projectedShapes.size(); i++) {
 			currentShapes[i][0] = this.projectedRectangles.get(i);
 			currentShapes[i][1] = this.projectedShapes.get(i);
 		}
 		return currentShapes;
 	}
 
 	protected boolean isInside(int shapeIndex, Shape[][] projectRectangleShapes, Point2d realPoint) {
 		return projectRectangleShapes[shapeIndex][0].isInside(realPoint)
 				&& projectRectangleShapes[shapeIndex][1].isInside(realPoint);
 	}
 
 	/**
 	 * Perform projection but only request data for pixels within the windowed
 	 * range provided. Specify the background colour, i.e. the value of pixels
 	 * with no data post projection.
 	 * 
 	 * @param windowMinC
 	 *            left X
 	 * @param windowMinR
 	 *            top Y
 	 * @param output
 	 *            the target image in which to project
 	 * @return projected image within the window
 	 */
 	public T performProjection(int windowMinC, int windowMinR, T output) {
 
 		for (int y = 0; y < output.getHeight(); y++)
 		{
 			for (int x = 0; x < output.getWidth(); x++) {
 				final Point2d realPoint = new Point2dImpl(windowMinC + x, windowMinR + y);
 				int i = 0;
 				for (final Shape s : this.projectedShapes) {
 					if (s.calculateRegularBoundingBox().isInside(realPoint) && s.isInside(realPoint)) {
 						final double[][] transform = this.transformsInverted.get(i).getArray();
 
 						float xt = (float) transform[0][0] * realPoint.getX() + (float) transform[0][1]
 								* realPoint.getY() + (float) transform[0][2];
 						float yt = (float) transform[1][0] * realPoint.getX() + (float) transform[1][1]
 								* realPoint.getY() + (float) transform[1][2];
 						final float zt = (float) transform[2][0] * realPoint.getX() + (float) transform[2][1]
 								* realPoint.getY() + (float) transform[2][2];
 
 						xt /= zt;
 						yt /= zt;
 						final T im = this.images.get(i);
 						output.setPixel(x, y, im.getPixelInterp(xt, yt, output.getPixel(x, y)));
 					}
 					i++;
 				}
 			}
 		}
 
 		return output;
 	}
 
 	/**
 	 * Perform blended projection but only request data for pixels within the
 	 * windowed range provided. Specify the background colour, i.e. the value of
 	 * pixels with no data post projection. This blends any existing pixels to
 	 * newly added pixels
 	 * 
 	 * @param windowMinC
 	 *            left X
 	 * @param windowMaxC
 	 *            right X
 	 * @param windowMinR
 	 *            top Y
 	 * @param windowMaxR
 	 *            bottom Y
 	 * @param backgroundColour
 	 *            background colour of pixels with no data
 	 * @return projected image within the window
 	 */
 	public T performBlendedProjection(int windowMinC, int windowMaxC, int windowMinR, int windowMaxR, Q backgroundColour)
 	{
 		T output = null;
 		output = images.get(0).newInstance(windowMaxC - windowMinC, windowMaxR - windowMinR);
 		final Map<Integer, Boolean> setMap = new HashMap<Integer, Boolean>();
 		final T blendingPallet = output.newInstance(2, 1);
 		for (int y = 0; y < output.getHeight(); y++)
 		{
 			for (int x = 0; x < output.getWidth(); x++) {
 				final Point2d realPoint = new Point2dImpl(windowMinC + x, windowMinR + y);
 				int i = 0;
 				for (final Shape s : this.projectedShapes) {
 					if (s.isInside(realPoint)) {
 						final double[][] transform = this.transformsInverted.get(i).getArray();
 
 						float xt = (float) transform[0][0] * realPoint.getX() + (float) transform[0][1]
 								* realPoint.getY() + (float) transform[0][2];
 						float yt = (float) transform[1][0] * realPoint.getX() + (float) transform[1][1]
 								* realPoint.getY() + (float) transform[1][2];
 						final float zt = (float) transform[2][0] * realPoint.getX() + (float) transform[2][1]
 								* realPoint.getY() + (float) transform[2][2];
 
 						xt /= zt;
 						yt /= zt;
 						Q toSet = null;
 						if (backgroundColour != null)
 							toSet = this.images.get(i).getPixelInterp(xt, yt, backgroundColour);
 						else if (setMap.get(y * output.getWidth() + x) != null)
 							toSet = this.images.get(i).getPixelInterp(xt, yt, output.getPixelInterp(x, y));
 						else
 							toSet = this.images.get(i).getPixelInterp(xt, yt);
 						// Blend the pixel with the existing pixel
 						if (setMap.get(y * output.getWidth() + x) != null) {
 							blendingPallet.setPixel(1, 0, toSet);
 							blendingPallet.setPixel(0, 0, output.getPixel(x, y));
 
 							toSet = blendingPallet.getPixelInterp(0.1, 0.5);
 						}
 						setMap.put(y * output.getWidth() + x, true);
 						output.setPixel(x, y, toSet);
 					}
 					i++;
 				}
 			}
 		}
 		return output;
 	}
 
 	/**
 	 * @return Current matrix
 	 */
 	public Matrix getMatrix() {
 		return this.currentMatrix;
 	}
 
 	/**
 	 * Utility function, project one image with one matrix. Every valid pixel in
 	 * the space the image is projected into is displayed in the final image.
 	 * 
 	 * @param <Q>
 	 *            the image pixel type
 	 * @param <T>
 	 *            image type
 	 * @param image
 	 *            the image to project
 	 * @param matrix
 	 *            the matrix to project against
 	 * @return projected image
 	 */
 	@SuppressWarnings("unchecked")
 	public static <Q, T extends Image<Q, T>> T project(T image, Matrix matrix) {
 		// Note: extra casts to work around compiler bug
 		if ((Image<?, ?>) image instanceof FImage) {
 			final FProjectionProcessor proc = new FProjectionProcessor();
 			proc.setMatrix(matrix);
 			((FImage) (Image<?, ?>) image).accumulateWith(proc);
 			return (T) (Image<?, ?>) proc.performProjection();
 		}
 		if ((Image<?, ?>) image instanceof MBFImage) {
 			final MBFProjectionProcessor proc = new MBFProjectionProcessor();
 			proc.setMatrix(matrix);
 			((MBFImage) (Image<?, ?>) image).accumulateWith(proc);
 			return (T) (Image<?, ?>) proc.performProjection();
 		} else {
 			final ProjectionProcessor<Q, T> proc = new ProjectionProcessor<Q, T>();
 			proc.setMatrix(matrix);
 			image.accumulateWith(proc);
 			return proc.performProjection();
 		}
 	}
 
 	/**
 	 * Utility function, project one image with one matrix. Every valid pixel in
 	 * the space the image is projected into is displayed in the final image.
 	 * 
 	 * @param <Q>
 	 *            the image pixel type
 	 * @param <T>
 	 *            image type
 	 * @param image
 	 *            the image to project
 	 * @param matrix
 	 *            the matrix to project against
 	 * @param backgroundColour
 	 *            The colour of pixels with no data
 	 * @return projected image
 	 */
 	public static <Q, T extends Image<Q, T>> T project(T image, Matrix matrix, Q backgroundColour) {
 		final ProjectionProcessor<Q, T> proc = new ProjectionProcessor<Q, T>();
 		proc.setMatrix(matrix);
 		image.accumulateWith(proc);
 		return proc.performProjection(backgroundColour);
 	}
 
 	@Override
 	public T combine() {
 		return performProjection();
 	}
 }