package de.desy.acop.video.analysis;
   
   /**
    * 
    * <code>AnalyzedImage</code> is a wrapper for the image, which provides
    * statistical parameters of the supplied image. This class accepts an intensity
    * image (given at construction) and performs statistical analysis. The
    * calculated values can be obtained through the getter methods for each of the
    * specific calculated parameters.
   * 
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @deprecated not used anymore; relevant things moved to {@link ImageAnalysisEngine}.
   */
  @Deprecated
  public class AnalyzedImage {
  	
  	private final ColorDecoder decoder;
  	private final int[] image;
  	private final int scan;
  	private final int roiX;
  	private final int roiY;
  	private final int roiW;
  	private final int roiH;
  	private final double threshold;
  
  	private double[] sideViewX;
  	private double[] sideViewY;
  	private double meanX = Double.NaN;
  	private double meanY = Double.NaN;
  	private double stdX = Double.NaN;
  	private double stdY = Double.NaN;
  	private double sideViewAmplitudeX = Double.NaN;
  	private double sideViewAmplitudeY = Double.NaN;
  	private double sideViewConstX = Double.NaN;
  	private double sideViewConstY = Double.NaN;
  	private double stdA = Double.NaN;
  	private double stdB = Double.NaN;
  	private double angle2D = Double.NaN;
  	private double amplitude2D = Double.NaN;
  	private double const2D = Double.NaN;
  	
  
  	/**
  	 * Constructs a new AnalyzedImage, which accepts an image matrix. The
  	 * provided image describes the intensity of pixels in a 2D image. This
  	 * image will be analyzed for statistical parameters and will not be changed
  	 * in any way during the analysis. Only the region given by the additional
  	 * parameters will be analyzed (region of interest is always a rectangle).
  	 * 
  	 * @param decoder 
  	 *            the </code>ColorDecoder</code> to be used for transforming 
  	 *            the </code>TYPE_INT_ARGB</code> integer color code into a
  	 *            meaningful double value
  	 * @param image
  	 *            the image represented by an array of intensity values.
  	 *            Consider this array to be an intensity image matrix combined
  	 *            into a single array one row after another
  	 * @param scan
  	 *            the length of a single row in the image matrix
  	 * @param x
  	 *            region of interest left coordinate
  	 * @param y
  	 *            region of interest upper coordinate
  	 * @param w
  	 *            the width of the region of interest
  	 * @param h
  	 *            the height of the region of interest
  	 * @param threshold
  	 *            the threshold below which all values are neglected
  	 * @throws Exception 
  	 */
  	public AnalyzedImage(ColorDecoder decoder, int[] image, int scan, int x, int y, int w, int h, double threshold)
  			throws Exception {
  		if (decoder == null) {
  			decoder = new IdentityColorDecoder();
  		}
  		if (image == null) {
  			throw new IllegalArgumentException("Image cannot be null.");
  		}
  		if (image.length % scan != 0) {
  			throw new IllegalArgumentException("The scan parameter '" + scan
  					+ "' does not match image length '" + image.length + "'.");
  		}
  		int height = image.length / scan;
  		if (x < 0 || x >= scan || x + w > scan || x + w < 0 || w < 0 || y < 0
  				|| y >= height || y + h > height || y + h < 0 || h < 0) {
  			throw new IllegalArgumentException("Region of interest is invalid.");
  		}
  		
  		this.decoder = decoder;
  		this.image = image;
  		this.scan = scan;
  		this.roiX = x;
  		this.roiY = y;
  		this.roiW = w;
  		this.roiH = h;
  		this.threshold = threshold;
  
  		analyzeImage();
 	}
 
 	private double getValue(int x, int y) {
 		// int position = y*scan + x;
 		return decoder.transform(image[y * scan + x]);
 	}
 
 	private void analyzeImage() throws Exception {
 //		sideViewAnalysis();
 //		gauss2DFit();
 		
 		sideViewX = new double [scan];
 		sideViewY = new double [image.length/scan];
 		int imageHeight = image.length/scan;
 		
 		double maxValue = -Double.MAX_VALUE;
 		double minValue = Double.MAX_VALUE;
 		double value;
 		for (int i = 0; i < scan; ++i) {
 			for (int j = 0; j < imageHeight; ++j) {
 				value = getValue(i, j);
 				if (value < threshold) continue;
 				if (maxValue < value) maxValue = value;
 				if (minValue > value) minValue = value;
 				sideViewX[i] += value;
 				sideViewY[j] += value;
 			}
 		}
 		
 		double[] roiSideViewX = new double[roiW];
 		double[] roiSideViewY = new double[roiH];
 		
 		for (int i = 0; i < roiW; ++i){
 			roiSideViewX [i]= sideViewX [i+roiX];
 		}
 		
 		for (int j = 0; j < roiH; ++j){
 			roiSideViewY [j]= sideViewY [j+roiY];
 		}
 		
 		int y = 0 , x = 0;
 		
 		double sum = 0;
 		double sumX = 0;
 		double sumY = 0;
 		double sumXX = 0;
 		double sumYY = 0;
 		double sumXY = 0;
 		
 		for(y = 0; y < roiH; y++)
 		{
 			for(x = 0; x < roiW; x++)
 			{
 				value = getValue(x+roiX, y+roiY);
 				if(threshold < value)
 				{
 					sum = sum+value;
 					sumX = sumX+value*(x+roiX);
 					sumY = sumY+value*(y+roiY);
 				}
 			}
 		}
 		
 		double Y = sumY/sum;
 		double X = sumX/sum;
 		
 		double argx, argy;
 		for(y = 0; y < roiH; y++)
 		{
 			for(x = 0; x < roiW; x++)
 			{
 				value = getValue(x+roiX, y+roiY);
 				if(threshold < value)
 				{
 					argx = x+roiX-X;
 					argy = y+roiY-Y;
 					sumXX = sumXX+value*argx*argx;
 					sumXY = sumXY+value*argx*argy;
 					sumYY = sumYY+value*argy*argy;
 				}
 			}
 		}
 
 		double XX = sumXX/sum;
 		double XY = sumXY/sum;
 		double YY = sumYY/sum;
 
 		double b = 0;
 		double c = 0;
 		double D = 0;
 		double A = 0;
 		double B = 0;
 		b = -2*(XX+YY);
 		c = (XX*YY)-(XY*XY);
 		D = Math.sqrt((b*b)-(4*c));
 		A = (-b-D)/2;
 		B = (-b+D)/2;
 		double phase = Math.atan2(2*XX, YY-XX)*(90/Math.PI);
 		
 		double[] xMinMax = findMinMax(sideViewX);
 		double[] yMinMax = findMinMax(sideViewY);
 		
 		meanX = X;
 		stdX = Math.sqrt(XX);
 		sideViewAmplitudeX = xMinMax[1]-xMinMax[0];
 		sideViewConstX = xMinMax[0];
 		
 		meanY = Y;
 		stdY = Math.sqrt(YY);
 		sideViewAmplitudeY = yMinMax[1]-yMinMax[0];
 		sideViewConstY = yMinMax[0];
 		
 		stdA = Math.sqrt(A);
 		stdB = Math.sqrt(B);
 		angle2D = phase;
 		amplitude2D = maxValue-minValue;
 		const2D = minValue;
 		
 //		System.out.println("---RESULTS---");
 //		System.out.println("mean X = "+meanX);
 //		System.out.println("std X = "+stdX);
 //		System.out.println("amplitude X = "+sideViewAmplitudeX);
 //		System.out.println("const X = "+sideViewConstX);
 //		System.out.println("---");
 //		System.out.println("mean Y = "+meanY);
 //		System.out.println("std Y = "+stdY);
 //		System.out.println("amplitude Y = "+sideViewAmplitudeY);
 //		System.out.println("const Y = "+sideViewConstY);
 //		System.out.println("---");
 //		System.out.println("std A = "+stdA);
 //		System.out.println("std B = "+stdB);
 //		System.out.println("theta = "+angle2D);
 //		System.out.println("amplitude = "+amplitude2D);
 //		System.out.println("const = "+const2D);
 //		System.out.println("---");
 		
 	}
 	
 	private double[] findMinMax(double[] values) {
 		double min = Double.MAX_VALUE;
 		double max = -Double.MAX_VALUE;
 		for (int i = 0; i < values.length; i++) {
 			if (values[i] > max) max = values[i];
 			if (values[i] < min) min = values[i];
 		}
 		return new double[] {min, max};
 	}
 
 //	private void gauss2DFit() throws MathException {
 //		double [] roi = new double [roiW*roiH]; 
 //		int width = roiX + roiW;
 //		int height = roiY + roiH;
 //		
 //		
 //		for (int i = roiY; i < height; ++i) {
 //			for (int j = roiX; j < width; ++j) {
 //				roi[j - roiX + ((i-roiY) * roiW)] = getValue(i, j);
 //			}
 //		}
 //		
 //		double[][] x = new double [roi.length][2];
 //		double[] a2D = new double[] {1,1,1,1,1,1,1};
 //		LMfunc f = new LM2DGauss();
 //		
 //		for (int i =0; i < roiH; i++){
 //			for (int j = 0; j < roiW; j++) {
 //				x[j][0]=j;
 //				x[j][1]=i;
 //			}
 //		}
 //		
 //		LM.solve(x, a2D, roi, f, TERM_EPSILON, MAX_ITER);
 //		amplitude2D = a2D[0];
 //		gauss2DFitXMean = a2D[1];
 //		gauss2DFitYMean = a2D[2];
 //		a = a2D[3];
 //		b = a2D[4];
 //		c = a2D[5];
 //		const2D = a2D[6];
 //		const2D = 0;
 //		
 //		double[]sigma = NonLinearSystem.calculate(a, b, c, stdX, stdY, 0 );
 //		
 //		gauss2DFitXMean = Math.sqrt(sigma[0]);
 //		gauss2DFitYMean = Math.sqrt(sigma[1]);
 //		angle2D = sigma[2];
 //
 //	}
 //
 //	private void sideViewAnalysis() throws Exception {
 //		
 //		sideViewX = new double [scan];
 //		sideViewY = new double [image.length/scan];
 //		int imageHeight = image.length/scan;
 //		
 //		for (int i = 0; i < scan; ++i) {
 //			for (int j = 0; j < imageHeight; ++j) {
 //				sideViewX[i] += getValue(i, j);
 //			}
 //		}
 //
 //		for (int i = 0; i < imageHeight; ++i) {
 //			for (int j = 0; j < scan; ++j) {
 //				sideViewY[i] += getValue(j, i);
 //			}
 //		}
 //		
 //		double[] roiSideViewX = new double[roiW];
 //		double[] roiSideViewY = new double[roiH];
 //		
 //		for (int i = 0; i < roiW; ++i){
 //			roiSideViewX [i]= sideViewX [i+roiX];
 //		}
 //		
 //		for (int j = 0; j < roiH; ++j){
 //			roiSideViewY [j]= sideViewY [j+roiY];
 //		}
 //		
 //		/*
 //		int width = roiX + roiW;
 //		int height = roiY + roiH;
 //
 //		for (int i = roiX; i < width; ++i) {
 //			for (int j = roiY; j < height; ++j) {
 //				roiSideViewX[i - roiX] += getValue(i, j);
 //			}
 //		}
 //
 //		for (int i = roiY; i < height; ++i) {
 //			for (int j = roiX; j < width; ++j) {
 //				roiSideViewY[i - roiY] += getValue(j, i);
 //			}
 //		}
 //		*/
 //		
 //		double[][]x = new double [roiW][1];
 //		
 //		for (int i = 0; i < roiW; i++){
 //			x[i][0]=i;
 //		}
 //		
 //		double[] aX = new double[] {1,1,1,1};
 //		double[] aY = new double[] {1,1,1,1};
 //		LMfunc f = new LMGauss();
 //		
 //		LM.solve(x, aX, roiSideViewX, f, TERM_EPSILON, MAX_ITER);
 //		sideViewAmplitudeX = aX[0];
 //		meanX = aX[1];
 //		stdX = aX[2];
 //		sideViewConstX = aX[3];
 //		
 //		double[][]y = new double [roiH][1];
 //		
 //		for (int i = 0; i < roiH; i++){
 //			y[i][0]=i;
 //		}
 //		
 //		LM.solve(y, aY, roiSideViewY, f, TERM_EPSILON, MAX_ITER);
 //		sideViewAmplitudeY = aY[0];
 //		meanY = aY[1];
 //		stdY = aY[2];
 //		sideViewConstY = aY[3];
 //
 //	}
 
 	/**
 	 * Returns the intensity image, which was analyzed by this class. The
 	 * statistical parameters of this AnalyzedImage match the image returned by
 	 * this method. This is a 2D intensity matrix concatenated row-by-row into a
 	 * 1-dimensional array.
 	 * 
 	 * @return the original image
 	 */
 	public int[] getImage() {
 		return image;
 	}
 	
 	/**
 	 * Returns the width of the row in the image matrix (the matrix is combined
 	 * into a single array returned by {@link #getImage()});
 	 * 
 	 * @return
 	 */
 	public int getScan() {
 		return scan;
 	}
 
 	/**
 	 * The height of the region of interest.
 	 * 
 	 * @return the height
 	 */
 	public int getROIH() {
 		return roiH;
 	}
 
 	/**
 	 * The width of the region of interest.
 	 * 
 	 * @return the width
 	 */
 	public int getROIW() {
 		return roiW;
 	}
 
 	/**
 	 * Left coordinate of the region of interest.
 	 * 
 	 * @return the left coordinate
 	 */
 	public int getROIX() {
 		return roiX;
 	}
 
 	/**
 	 * Upper coordinate of the region of interest.
 	 * 
 	 * @return the upper coordinate
 	 */
 	public int getROIY() {
 		return roiY;
 	}
 
 	/**
 	 * Returns the standard deviation of the 2-dimensional intensity image in the
 	 * direction of the "a" axis of the profile (assuming an elliptical profile).
 	 * 
 	 * @return the standard deviation in a direction
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getStdA() {
 		return stdA;
 	}
 
 	/**
 	 * Returns the standard deviation of the 2-dimensional intensity image in the
 	 * direction of the "b" axis of the profile (assuming an elliptical profile).
 	 *  
 	 * @return the standard deviation in b direction
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getStdB() {
 		return stdB;
 	}
 
 	/**
 	 * Returns the angle of rotation of the 2-dimensional intensity profile around
 	 * its center (the angle between x and a and y and b axes).
 	 * 
 	 * @return the angle of rotation of the 2-dimensional intensity profile
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getAngle2D() {
 		return angle2D;
 	}
 	
 	/**
 	 * Returns the minimum pixel value (as returned by </code>ColorDecoder</code> 
 	 * assigned to this </code>AnalyzedImage</code>) across the entire image. This
 	 * value represents the background of the image.
 	 * 
 	 * @return the constant value of the intensity profile
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getConst2D() {
 		return const2D;
 	}
 
 	/**
 	 * Returns the maximum pixel value (as returned by </code>ColorDecoder</code> 
 	 * assigned to this </code>AnalyzedImage</code>) across the entire image.
 	 * 
 	 * @return the amplitude
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getAmplitude2D() {
 		return amplitude2D;
 	}
 
 	/**
 	 * Returns the array representing the side projection of the intensity image
 	 * on the X axis.
 	 * 
 	 * @return the projection on the x axis
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double[] getSideViewX() {
 		return sideViewX;
 	}
 
 	/**
 	 * Returns the array representing the side projection of the intensity image
 	 * on the Y axis.
 	 * 
 	 * @return the projection on the y axis
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double[] getSideViewY() {
 		return sideViewY;
 	}
 
 	/**
 	 * Returns the standard deviation of the side view projection
 	 * of the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the standard deviation
 	 */
 	public double getStdX() {
 		return stdX;
 	}
 
 	/**
 	 * Returns the standard deviation of the side view projection
 	 * of the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the standard deviation
 	 */
 	public double getStdY() {
 		return stdY;
 	}
 
 	/**
 	 * Returns the mean value of the side view projection of the
 	 * image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the mean value
 	 */
 	public double getMeanX() {
 		return meanX;
 	}
 
 	/**
 	 * Returns the mean value of the side view projection of the
 	 * image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the mean value
 	 */
 	public double getMeanY() {
 		return meanY;
 	}
 
 	/**
 	 * Returns the amplitude (maximum minus minimum) value of the side view 
 	 * projection of the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the amplitude
 	 */
 	public double getSideViewAmplitudeX() {
 		return sideViewAmplitudeX;
 	}
 
 	/**
 	 * Returns the amplitude (maximum minus minimum) value of the side view 
 	 * projection of the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the amplitude
 	 */
 	public double getSideViewAmplitudeY() {
 		return sideViewAmplitudeY;
 	}
 	
 	/**
 	 * Returns the constant (minimum) value of the side view projection of
 	 * the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the constant
 	 */
 	public double getSideViewConstX() {
 		return sideViewConstX;
 	}
 
 	/**
 	 * Returns the constant (minimum) value of the side view projection of
 	 * the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the constant
 	 */
 	public double getSideViewConstY() {
 		return sideViewConstY;
 	}
 }