/**
    * 
    */
   package de.desy.acop.video;
   
   import java.awt.Graphics;
   import java.awt.Graphics2D;
   import java.awt.geom.GeneralPath;
   import java.awt.geom.Line2D;
  import java.awt.geom.Rectangle2D;
  
  import javax.swing.JPanel;
  
  /**
   * </code>SideProfileDisplayer</code> is a component that displays a one dimensional profile
   * of an image. This displayer can have either horizontal or vertical orientation.
   * It plots a </code>double[]</code> normalized to its height or width. 
   * 
   * @author Tilen Kusterle, Cosylab
   *
   */
  public class SideProfileDisplayer extends JPanel {
  	
  	private static final long serialVersionUID = 1L;
  	
  	private boolean horizontalOrientation = true;
  	
  	private double[] profile = null;
  	private double[] gaussProfile = null;
  	private double[] gaussProfileFit = null;
  	private double max;
  	private double min;
  	
  	private double canvasStart = 0;
  	private double canvasSize = 0;
  	private int roiStart = -1;
  	private int roiLength = -1;
  	private double roi1 = Double.NaN;
  	private double roi2 = Double.NaN;
  	
  	private boolean displayStatistics = true;
  		
  	private Object mutex = new Object();
  	
  	/**
  	 * Constructs this </code>SideProfileDisplayer</code>. The construction parameter
  	 * defines the orientation of this displayer (horizontal or vertical).
  	 * @param horizontalOrientation if </code>true</code> the displayer is horizontally
  	 * oriented; if </code>false</code> the displayer is vertically oriented
  	 */
  	public SideProfileDisplayer(boolean horizontalOrientation) {
  		this.horizontalOrientation = horizontalOrientation;
  		setBackground(Definitions.getBackgroundColor());
  	}
  	
  	/**
  	 * Sets data to this </code>SideProfileDisplayer</code>.
  	 * @param profile the profile to draw
  	 * @param amplitude the amplitude of Gauss fit
  	 * @param mean the mean of Gauss fit
  	 * @param std the STD value of Gauss fit
  	 * @param constant the constant of Gauss fit
  	 * @param roiStart the start index of region of interest
  	 * @param roiLength the length of region of interest
  	 */
  	@SuppressWarnings({"null"})
  	public void setData(double[] profile, double amplitude, double mean, double std, double constant, 
  			double amplitudeFit, double meanFit, double stdFit, double constantFit, double slopeFit, int roiStart, int roiLength,
  			boolean drawFit) {
  		this.profile = profile;
  		this.roiStart = roiStart;
  		this.roiLength = roiLength;
  		
  		int length = profile.length;
  		if (roiStart < 0 || roiLength < 0 || roiStart+roiLength > length) throw new IllegalStateException("Illegal region of interest!");
  		
  		int i = 0;
  		double[] statProfile = new double[roiLength];
  		double[] fitProfile = null;
  		if (drawFit) {
  			fitProfile = new double[roiLength];
      		for(; i < roiLength; i++) {
      			statProfile[i] = amplitude*Math.exp(-(roiStart+i-mean)*(roiStart+i-mean)/(2*std*std))+constant;
      			fitProfile[i] = amplitudeFit*Math.exp(-(roiStart+i-meanFit)*(roiStart+i-meanFit)/(2*stdFit*stdFit))+constantFit + (roiStart+i)*slopeFit;
      		}
  		} else {
  			for(; i < roiLength; i++) {
  				statProfile[i] = amplitude*Math.exp(-(roiStart+i-mean)*(roiStart+i-mean)/(2*std*std))+constant;
      		}
  		}
  		
  		min = Double.MAX_VALUE;
  		max = -Double.MAX_VALUE;
  		for (i = 0; i < length; i++) {
  			if (profile[i] < min) min = profile[i];
  			if (profile[i] > max) max = profile[i];
  		}
  		if (drawFit) {
      		for (i = 0; i < roiLength; i++) {
     			if (statProfile[i] < min) min = statProfile[i];
     			if (statProfile[i] > max) max = statProfile[i];
     			if (fitProfile[i] < min) min = fitProfile[i];
     			if (fitProfile[i] > max) max = fitProfile[i];
     		}
 		} else {
 			for (i = 0; i < roiLength; i++) {
     			if (statProfile[i] < min) min = statProfile[i];
     			if (statProfile[i] > max) max = statProfile[i];
     		}
 		}
     	synchronized(mutex) {
     		if (drawFit) {
     			gaussProfileFit = fitProfile;
     			gaussProfile = statProfile;
     		} else {
     			gaussProfile = statProfile;
     			gaussProfileFit = null;
     		}
 		}
 		
 		repaint();
 	}
 	
 	/**
 	 * Clears this displayer's data.
 	 */
 	public void clearData() {
 		profile = null;
 		gaussProfile = null;
 		gaussProfileFit = null;
 		min = Double.MAX_VALUE;
 		max = -Double.MAX_VALUE;
 		
 		canvasStart = 0;
 		canvasSize = 0;
 		roiStart = -1;
 		roiLength = -1;
 		roi1 = Double.NaN;
 		roi2 = Double.NaN;
 		
 		repaint();
 	}
 	
 	/**
 	 * Sets the position of region of interest markers on this displayer.
 	 * @param c1 the position of the first marker
 	 * @param c2 the position of the second marker
 	 */
 	public void setRoi(double c1, double c2) {
 		roi1 = c1;
 		roi2 = c2;
 		repaint();
 	}
 	
 	public void setCanvasSize(double start, double size, boolean repaintAtOnce) {
 		canvasSize = size;
 		canvasStart = start;
 		if (repaintAtOnce) repaint();
 	}
 	
 	public void setCanvasStart(double start) {
 		if (canvasStart == start) return;
 		canvasStart = start;
 		repaint();
 	}
 	
 	/**
 	 * Clears the region of interest markers on this displayer.
 	 */
 	public void clearRoi() {
 		roi1 = Double.NaN;
 		roi2 = Double.NaN;
 		repaint();
 	}
 	
 	@Override
 	protected void paintComponent(Graphics g) {
 		super.paintComponent(g);
 		drawProfile((Graphics2D) g);
 		drawRoi((Graphics2D) g);
 	}
 	
 	void setDisplayStatistics(boolean display) {
 		this.displayStatistics = display;
 		repaint();
 	}
 		
 	private void drawProfile(Graphics2D g) {
 		if (gaussProfile == null || gaussProfile.length == 0) return;
 		int i = 0;
 		int length = profile.length;
 
 		double coeff = (horizontalOrientation ? getHeight() : getWidth())/(max-min);
 		double delta = canvasSize/(length-1);
 
 		GeneralPath dataPath = new GeneralPath();
 		GeneralPath statisticsPath = new GeneralPath();
 		GeneralPath fitPath = new GeneralPath();
 		double x, y;
 		synchronized (mutex) {
     		if (horizontalOrientation) {
     			for (i = 0; i < length; i++) {
     				x = canvasStart+i*delta;
     				y = getHeight()-(profile[i]-min)*coeff;
     				if (i == 0) dataPath.moveTo(x, y);
     				else dataPath.lineTo(x, y);
     			}
     			for (i = 0; i < roiLength; i++) {
     				x = canvasStart+(roiStart+i)*delta;
     				y = getHeight()-(gaussProfile[i]-min)*coeff;
     				if (i == 0) statisticsPath.moveTo(x, y);
     				else statisticsPath.lineTo(x, y);
     			}
     			if (gaussProfileFit != null) {
         			for (i = 0; i < roiLength; i++) {
         				x = canvasStart+(roiStart+i)*delta;
         				y = getHeight()-(gaussProfileFit[i]-min)*coeff;
         				if (i == 0) fitPath.moveTo(x, y);
         				else fitPath.lineTo(x, y);
         			}
     			}
     		} else {
     			for (i = 0; i < length; i++) {
     				x = canvasStart+i*delta;
     				y = getWidth()-(profile[i]-min)*coeff;
     				if (i == 0) dataPath.moveTo(y, x);
     				else dataPath.lineTo(y, x);
     			}
     			for (i = 0; i < roiLength; i++) {
     				x = canvasStart+(roiStart+i)*delta;
     				y = getWidth()-(gaussProfile[i]-min)*coeff;
     				if (i == 0) statisticsPath.moveTo(y, x);
     				else statisticsPath.lineTo(y, x);
     			}
     			if (gaussProfileFit != null) {
         			for (i = 0; i < roiLength; i++) {
         				x = canvasStart+(roiStart+i)*delta;
         				y = getWidth()-(gaussProfileFit[i]-min)*coeff;
         				if (i == 0) fitPath.moveTo(y,x);
         				else fitPath.lineTo(y,x);
         			}
     			}
     		}
 		}
 		
 		double x1 = horizontalOrientation ? canvasStart : 0;
 		double y1 = horizontalOrientation ? 0 : canvasStart;
 		double x2 = horizontalOrientation ? canvasSize : getWidth();
 		double y2 = horizontalOrientation ? getHeight() : canvasSize;
 		Rectangle2D r = new Rectangle2D.Double(x1, y1, x2, y2);
 		g.setPaint(Definitions.getCanvasColor());
 		g.fill(r);
 		
 		g.setPaint(Definitions.getDataColor());
 		g.draw(dataPath);
 		if (gaussProfileFit != null) {
     		g.setPaint(Definitions.getFitColor());
     		g.draw(fitPath);
 		}
 		if (displayStatistics) {
     		g.setPaint(Definitions.getStatisticsColor());
     		g.draw(statisticsPath);
 		}
 		
 		double p1 = canvasStart+roiStart*delta;
 		double p2 = canvasStart+(roiStart+roiLength-1)*delta;
 		
 		x1 = horizontalOrientation ? p1 : 0;
 		y1 = horizontalOrientation ? 0 : p1;
 		x2 = horizontalOrientation ? p1 : getWidth();
 		y2 = horizontalOrientation ? getHeight() : p1;
 		Line2D l1 = new Line2D.Double(x1, y1, x2, y2);
 		x1 = horizontalOrientation ? p2 : 0;
 		y1 = horizontalOrientation ? 0 : p2;
 		x2 = horizontalOrientation ? p2 : getWidth();
 		y2 = horizontalOrientation ? getHeight() : p2;
 		Line2D l2 = new Line2D.Double(x1, y1, x2, y2);
 		
 		g.setPaint(Definitions.getRoiColor());
 		g.draw(l1);
 		g.draw(l2);
 		
 	}
 	
 	private void drawRoi(Graphics2D g) {
 		if (!Double.isNaN(roi1) && !Double.isNaN(roi2)) {
 			double x1 = horizontalOrientation ? roi1 : 0;
 			double y1 = horizontalOrientation ? 0 : roi1;
 			double x2 = horizontalOrientation ? roi1 : getWidth();
 			double y2 = horizontalOrientation ? getHeight() : roi1;
 			Line2D l1 = new Line2D.Double(x1, y1, x2, y2);
 			x1 = horizontalOrientation ? roi2 : 0;
 			y1 = horizontalOrientation ? 0 : roi2;
 			x2 = horizontalOrientation ? roi2 : getWidth();
 			y2 = horizontalOrientation ? getHeight() : roi2;
 			Line2D l2 = new Line2D.Double(x1, y1, x2, y2);
 			
 			g.setPaint(Definitions.getRoiSelectingColor());
 			g.draw(l1);
 			g.draw(l2);
 		}
 	}
 
 }