/**
    * 
    */
   package de.desy.acop.video.analysis;
   
   
   import java.awt.Rectangle;
   import java.awt.image.BufferedImage;
   import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  import java.util.concurrent.Executor;
  import java.util.concurrent.Executors;
  import java.util.concurrent.RejectedExecutionHandler;
  import java.util.concurrent.ThreadFactory;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.TimeUnit;
  import java.util.logging.Level;
  
  import de.desy.acop.displayers.tools.DismissableBlockingQueue;
  import de.desy.acop.displayers.tools.TINEThreadFactory;
  import de.desy.acop.transport.ConnectionFailed;
  import de.desy.acop.transport.ConnectionParameters;
  import de.desy.acop.video.VideoServerConnection;
  import de.desy.acop.video.displayer.ImageFormat;
  import de.desy.acop.video.displayer.TineHandler;
  import de.desy.acop.video.displayer.TineImageReceiver;
  import de.desy.acop.video.displayer.timage.TImageConverter;
  import de.desy.acop.video.timageio.TBufferedImage;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.types.IMAGE.FrameHeader;
  
  /**
   * </code>ImageAnalysisEngine</code> provides </code>AImage</code> image analysis 
   * data. It has two modes of operation: local and remote analysis. In local analysis
   * mode, the </code>IMAGE</code> arguments of the </code>updateValue</code> method
   * are processed locally. In remote mode this engine reads </code>AImage</code> data
   * from a video analysis server. 
   * 
   * @author Tilen Kusterle, Cosylab
   *
   */
  @SuppressWarnings("deprecation")
  public class ImageAnalysisEngine implements TineImageReceiver {
  
  	private class AnalysisExecutor implements Runnable {
  		final int iW;
  		final int iH;
  		final int rX;
  		final int rY;
  		final int rW;
  		final int rH;
  		final int r2X;
  		final int r2Y;
  		final int r2W;
  		final int r2H;
  		final double th;
  		final IMAGE im;
  		final double[] bg;
  		final boolean calculateThreshold;
  		final boolean performFit;
  		final boolean smoothing;
  		public AnalysisExecutor(IMAGE im, double[] bg, int iW, int iH, int rX, int rY, int rW, int rH, 
  				int r2X, int r2Y, int r2W, int r2H, double threshold, boolean calculateThreshold, boolean performFit, boolean smoothing) {
  			this.iW = iW;
  			this.iH = iH;
  			this.rX = rX;
  			this.rY = rY;
  			this.rW = rW;
  			this.rH = rH;
  			this.th = threshold;
  			this.im = im;
  			this.bg = bg;
  			this.r2X = r2X;
  			this.r2Y = r2Y;
  			this.r2W = r2W;
  			this.r2H = r2H;
  			this.calculateThreshold = calculateThreshold;
  			this.performFit = performFit;
  			this.smoothing = smoothing;
  		}
  		public void run() {
  			analyzeImage(im, bg, iW, iH, rX, rY, rW, rH, r2X, r2Y, r2W, r2H, th, calculateThreshold, performFit,smoothing);
  		}
  	}
  	
  	public static final String PROPERTY_A_IMAGE = "aImage";
  	public static final String PROPERTY_BACKGROUND = "background";
  	public static final String PROPERTY_PRECISE_BACKGROUND = "preciseBackground";
  	public static final String PROPERTY_RESET = "reset";
  		
  	private PropertyChangeSupport pcSupport;
  	private Executor executor;
  	private ThreadPoolExecutor analysisExecutor;
  	private boolean localAnalysis = true;
  	
  	private VideoServerConnection videoServerConnection;
  	
  //	private TImageConverter imageConverter = new TImageConverter(); // mdavid: added
 	
 	private ColorDecoder decoder;
 	
 	private AImage aImage;
 	private IMAGE image;
 	private IMAGE background;
 	private double[] preciseBackground;
 	private int imageWidth = -1;
 	private int imageHeight = -1;
 	private int backgroundWidth = -1;
 	private int backgroundHeight = -1;
 	private int roiX = -1;
 	private int roiY = -1;
 	private int roiW = -1;
 	private int roiH = -1;
 	private int roi2X = -1;
 	private int roi2Y = -1;
 	private int roi2W = -1;
 	private int roi2H = -1;
 	private double threshold = Double.NaN;
 	private boolean calculateThreshold = true;
 	private boolean performFit = false;
 	private boolean performSmoothing = false;
 	
 //	private double[] previousStartValuesX = new double[5];
 //	private double[] previousStartValuesY = new double[5];
 	private double[] previousStartValuesX = null;
 	private double[] previousStartValuesY = null;
 	/**
 	 * Constructs this </code>ImageAnalysisEngine</code>. 
 	 * @param decoder the </code>ColorDecoder</code> to be used with this 
 	 * </code>ImageAnalysisEngine</code>
 	 */
 	public ImageAnalysisEngine(ColorDecoder decoder) {
 		this.decoder = decoder;
 	}
 		
 	@Override
 	public void resetForReceiving() {
 		getPcSupport().firePropertyChange(PROPERTY_RESET, false, true);
 	}
 
 	@Override
 	public synchronized void updateValue(IMAGE newImage) {
 		if (!localAnalysis) return;
 //		logger.log(Level.INFO,"New update received.");
 //		image = TImageUtils.clone(newImage); // mdavid: commented
 		image = newImage.clone();
 
 		FrameHeader hdr = image.getFrameHeader();
 		int w = hdr.aoiWidth == -1 ? hdr.sourceWidth : hdr.aoiWidth;
 		int h = hdr.aoiHeight == -1 ? hdr.sourceHeight : hdr.aoiHeight;
 		
 		if (w != imageWidth || h != imageHeight) {
 			roiX = 0;
 			roiY = 0;
 			roiW = w;
 			roiH = h;
 			roi2X = 0;
 			roi2Y = 0;
 			roi2W = w;
 			roi2H = h;
 		}
 		
 		imageWidth = w;
 		imageHeight = h;
 
 		if ((imageWidth != backgroundWidth || imageHeight != backgroundHeight) && background != null) {
 			setBackground(null);
 		}
 		else performAnalysis();
 	}
 	
 	/**
 	 * Sets the precise background array. This is the array that holds values per pixels
 	 * for whole background image, but instead of int values, pixel values are given as
 	 * luminosity doubles. Negative values are permitted and will be taken into account
 	 * during analysis, but forced to 0, when real image is constructed.
 	 * 
 	 * @param background the pixel value array
 	 * @param width the width of the image
 	 */
 	public synchronized void setPreciseBackground(double[] background, int width) {
 		TineHandler.logger.log(Level.INFO, "Background image set.");
 		setPreciseBackground(background,width, true);
 	}
 	
 	/**
 	 * Returns the double array that is used as background image.
 	 * 
 	 * @see #setPreciseBackground(double[], boolean)
 	 * @return the double array image
 	 */
 	public synchronized double[] getPreciseBackground() {
 		return preciseBackground;
 	}
 	
 	/**
 	 * Returns the width of the background image.
 	 * 
 	 * @return the width
 	 */
 	public synchronized int getBackgroundWidth() {
 		return backgroundWidth;
 	}
 	
 	/**
 	 * Sets the background image and initiates required actions.
 	 * 
 	 * @param background the background image array
 	 * @param width the width of the image
 	 * @param reanalyze true if the image should be reanalyzed
 	 */
 	private synchronized void setPreciseBackground(final double[] preciseBackground, final int width, boolean reanalyze) {
 		this.background = null;
 		this.preciseBackground = null;
 		backgroundWidth = -1;
 		backgroundHeight = -1;
 		if (preciseBackground != null) {
 			int w = width;
 			int h = preciseBackground.length/width;
 			
 			if (w == imageWidth && h == imageHeight) {
 				backgroundWidth = w;
 				backgroundHeight = h;
 				this.preciseBackground = preciseBackground;
 				this.background = toImage(preciseBackground,width);
 			}
 		}
 		
 		if (reanalyze) {
 			if (localAnalysis) performAnalysis();
 			else {
 				executeTask(new Runnable() {
 					@Override
 					public void run() {
 						try {
 							getVideoServerConnection().setBackground(background);
 						} catch (ConnectionFailed e) {
 							e.printStackTrace();
 						}
 					}
 				});
 			}
 			getPcSupport().firePropertyChange(PROPERTY_PRECISE_BACKGROUND, null, this.preciseBackground);
 			getPcSupport().firePropertyChange(PROPERTY_BACKGROUND, null, this.background);
 		}
 	}
 	
 	/**
 	 * Transforms the double array to a Gray image.
 	 * 
 	 * @param image the image to transform 
 	 * @param width the width of the image
 	 * @return generated IMAGE
 	 */
 	public static IMAGE toImage(double[] image,int width) {
 		if (image == null || image.length == 0) return null;
 		if (width < 1 || image.length/width < 1) return null;
 		BufferedImage bi = toBufferedImage(image,width);
 //		return TBufferedImage.toIMAGE(bi);
 		return TImageConverter.parseBufferedImage(bi);
 	}	
 	
 	/**
 	 * Transforms teh double array to a gray buffered image.
 	 * 
 	 * @param image the double image array 
 	 * @param width the width of the image
 	 * @return buffered image
 	 */
 	public static BufferedImage toBufferedImage(double[] image,int width) {
 		if (image == null || image.length == 0) return null;
 		if (width < 1 || image.length/width < 1) return null;
 		int i = 0;
 		int length = image.length;
 		int[] rgb = new int[length];
 		try {
 			int alpha = (255 << 24);
 			int val;
     		for (;;) {
     			val = (int)(image[i]+0.5);
     			if (val < 0) val = 0;
     			rgb[i] =  alpha + (val << 16) + (val << 8) + (val);
     			i++;
     		}
 		} catch (ArrayIndexOutOfBoundsException e) {
 			//ignore
 		}
 		BufferedImage bi = new BufferedImage(width,length/width,BufferedImage.TYPE_BYTE_GRAY);
 		
 		bi.setRGB(0,0,width,length/width,rgb,0,width);
 		return bi;
 	}	
 	
 	/**
 	 * Gets the background image used by this </code>ImageAnalysisEngine</code>.
 	 * @return the background image
 	 */
 	public synchronized IMAGE getBackground() {
 		return background;
 	}
 		
 	/**
 	 * Sets the background image to be used by this </code>ImageAnalysisEngine</code>.
 	 * @param background the image to set
 	 */
 	public synchronized void setBackground(IMAGE background) {
 		TineHandler.logger.log(Level.INFO, "Background image set.");
 		setBackground(background, true);
 		this.background = background;
 	}
 	
 	private synchronized void setBackground(final IMAGE background, boolean reanalyze) {
 		if (background == null) {
 			setPreciseBackground(null,-1);
 		} else {
 			int[] rgb = toBufferedImage(background).getRGB(0, 0, background.getFrameHeader().sourceWidth, 
 					background.getFrameHeader().sourceHeight, null, 0, background.getFrameHeader().sourceWidth);
 			double[] data = getDecoder().transform(rgb);
 			setPreciseBackground(data,background.getFrameHeader().sourceWidth,reanalyze);
 			this.background = background;
 		}
 	}
 	
 	/**
 	 * Sets the region of interest and reanalyzes pixels.
 	 * @param roiX the starting x coordinate
 	 * @param roiY the starting y coordinate
 	 * @param roiW the width of the region
 	 * @param roiH the height of the region
 	 */
 	public synchronized void setRoi(final int roiX, final int roiY, final int roiW, final int roiH) {
 		if (this.roiX == roiX && this.roiY == roiY && this.roiW == roiW && this.roiH == roiH) return;
 		TineHandler.logger.log(Level.INFO, "ROI: x="+roiX+", y="+roiY +", w="+roiW + ", h="+roiH);
 		setAnalysisParameters(threshold,roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Sets the region of interest and reanalyzes pixels.
 	 * @param roiX the starting x coordinate
 	 * @param roiY the starting y coordinate
 	 * @param roiW the width of the region
 	 * @param roiH the height of the region
 	 */
 	public synchronized void setRoi2(final int roi2X, final int roi2Y, final int roi2W, final int roi2H) {
 		if (this.roi2X == roi2X && this.roi2Y == roi2Y && this.roi2W == roi2W && this.roi2H == roi2H) return;
 		TineHandler.logger.log(Level.INFO, "Threshold ROI: x="+roi2X+", y="+roi2Y +", w="+roi2W + ", h="+roi2H);
 		setAnalysisParameters(threshold,roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Gets the </code>IMAGE</code>.
 	 * @return the </code>IMAGE</code>
 	 */
 	public synchronized IMAGE getImage() {
 		return image;
 	}
 	
 	/**
 	 * Gets the </code>AImage</code>.
 	 * @return the </code>AImage</code>
 	 */
 	public synchronized AImage getAImage() {
 		return aImage;
 	}
 	
 	/**
 	 * Returns the rectangle describing the region of interest.
 	 * 
 	 * @return the region of intereset
 	 */
 	public synchronized Rectangle getROI() {
 		return new Rectangle(roiX,roiY,roiW,roiH);
 	}
 	
 	/**
 	 * Returns the rectangle describing the region of interest used for
 	 * threshold calculation.
 	 * 
 	 * @return the threshold region of interest 
 	 */
 	public synchronized Rectangle getThresholdROI() {
 		return new Rectangle(roi2X,roi2Y,roi2W,roi2H);
 	}
 	
 	/**
 	 * Gets the threshold value.
 	 * 
 	 * @see #setThreshold(double)
 	 * 
 	 * @return the threshold value
 	 */
 	public synchronized double getThreshold() {
 		return threshold;
 	}
 	
 	/**
 	 * Sets the threshold value, which discards all pixels which have
 	 * returned by <code>ColorDecoder</code> lover than threshold value. 
 	 * Threshold value has effect only between values Const2D and Amplitude2D 
 	 * as described by <code>AImage</code>.
 	 * 
 	 * @see AImage
 	 * @see AImage#getAmplitude2D()
 	 * @see AImage#getConst2D()
 	 * 
 	 * @param threshold the threshold value to set
 	 */
 	public synchronized void setThreshold(final double threshold) {
 		if (this.threshold == threshold) return;
 //		this.threshold = threshold;
 		TineHandler.logger.log(Level.INFO, "Threshold: " + threshold);
 		setAnalysisParameters(threshold,roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Sets the calculate thershold parameter. When true the threshold values
 	 * is calculated at each image analysis performed and the original user
 	 * defined threshold is overridden with the calculated one.
 	 * 
 	 * @param calculateThreshold true if the threshold should be calculated or false
 	 * 			otherwise
 	 */
 	public synchronized void setCalculateThreshold(final boolean calculateThreshold) {
 		if (this.calculateThreshold == calculateThreshold) return;
 		TineHandler.logger.log(Level.INFO, "Calculate threshold: " + calculateThreshold);
 		setAnalysisParameters(roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Returns true if the threshold is calculated by this engine, or false if
 	 * the user defined the threshold to be used.
 	 * 
 	 * @return true if threshold calculation is automatic
 	 */
 	public boolean isCalculateThreshold() {
 		return calculateThreshold;
 	}
 	
 	/**
 	 * Sets the perform fit parameter. When true fitting is performed on the data.
 	 * When true, the time required to perform the analysis might be significantly
 	 * longer
 	 * 
 	 * @param performFit true if fitting should be performed or false otherwise
 	 */
 	public synchronized void setPerformFit(final boolean performFit) {
 		if (this.performFit == performFit) return;
 		TineHandler.logger.log(Level.INFO, "Perform fit: " + performFit);
 		setAnalysisParameters(roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Sets the perform smoothing parameter. When true smoothing is performed on the side
 	 * view data. 
 	 * 
 	 * @param performSmoothing true if smoothing should be performed or false otherwise
 	 */
 	public synchronized void setPerformSmoothing(final boolean performSmoothing) {
 		if (this.performSmoothing == performSmoothing) return;
 		TineHandler.logger.log(Level.INFO, "Perform smoothing: " + performSmoothing);
 		setAnalysisParameters(roiX,roiY,roiW,roiH,roi2X,roi2Y,roi2W,roi2H,calculateThreshold,performFit,performSmoothing);
 	}
 	
 	/**
 	 * Returns true if fitting is performed by this engine, or false if
 	 * otherwise
 	 * 
 	 * @return true if fitting is performed
 	 */
 	public boolean isPerformFit() {
 		return performFit;
 	}
 	
 	/**
 	 * Gets the decoder used by this </code>ImageAnalysisEngine</code>.
 	 * @return the </code>ColorDecoder</code> used
 	 */
 	public synchronized ColorDecoder getDecoder() {
 		return decoder;
 	}
 	
 	/**
 	 * Sets a </code>ColorDecoder</code> to this </code>ImageAnalysisEngine</code>
 	 * @param decoder the </code>ColorDecoder</code> to set
 	 */
 	public synchronized void setDecoder(ColorDecoder decoder) {
 		if (this.decoder == decoder) return;
 		this.decoder = decoder;
 		if (localAnalysis) performAnalysis();
 		else {
 			// set to server?
 		}
 	}
 	
 	/**
 	 * Sets the analysis parameters (only region of interest, threshold remains the 
 	 * same) and reanalyzes pixels.
 	 * @param roiX the starting x coordinate
 	 * @param roiY the starting y coordinate
 	 * @param roiW the width of the region
 	 * @param roiH the height of the region
 	 * @param calculateThreshold true if the threshold is calculated by the server or false otherwise
 	 * @param performFit true if the fitting should be performed or false otherwise
 	 */
 	public void setAnalysisParameters(final int roiX, final int roiY, final int roiW, final int roiH, 
 			final int roi2X, final int roi2Y, final int roi2W, final int roi2H, 
 			final boolean calculateThreshold, boolean performFit, boolean performSmoothing) {
 		setAnalysisParameters(threshold, roiX, roiY, roiW, roiH, roi2X, 
 				roi2Y, roi2W, roi2H, calculateThreshold,performFit, performSmoothing);
 	}
 	
 	/**
 	 * Sets the analysis parameters (threshold and region of interest) and reanalyzes pixels.
 	 * @param threshold the threshold
 	 * @param roiX the starting x coordinate
 	 * @param roiY the starting y coordinate
 	 * @param roiW the width of the region
 	 * @param roiH the height of the region
 	 */
 	public synchronized void setAnalysisParameters(final double threshold, 
 			final int roiX,	final int roiY, final int roiW, final int roiH, 
 			final int roi2X, final int roi2Y, final int roi2W, final int roi2H,
 			final boolean calculateThreshold, final boolean performFit,final boolean performSmoothing) {
 		
 		if (!localAnalysis) {
 			executeTask(new Runnable() {
 				@Override
 				public void run() {
 					try {
 						getVideoServerConnection().setAnalysisParameters(threshold, roiX, roiY, roiW, roiH, roi2X, roi2Y, roi2W, roi2H,calculateThreshold,performFit);
 					} catch (ConnectionFailed e) {
 						e.printStackTrace();
 					}
 				}
 			});
 		} else {
 			this.calculateThreshold = calculateThreshold;
 			this.performFit = performFit;
 			this.performSmoothing = performSmoothing;
 			if (this.threshold == threshold && this.roiX == roiX && this.roiY == roiY && this.roiW == roiW && this.roiH == roiH
 					&& this.roi2X == roi2X && this.roi2Y == roi2Y && this.roi2H == roi2H && this.roi2W == roi2W) return;
 			this.threshold = threshold;
 			if (roiX >= imageWidth) this.roiX = imageWidth-1;
 			else if (roiX < 0) this.roiX = 0;
 			else this.roiX = roiX;
 			if (roiY >= imageHeight) this.roiY = imageHeight-1;
 			else if (roiY < 0) this.roiY = 0;
 			else this.roiY = roiY;
 			if (this.roiX+roiW > imageWidth) this.roiW = imageWidth-this.roiX;
 			else if (roiW <= 0) this.roiW = 1;
 			else this.roiW = roiW;
 			if (this.roiY+roiH > imageHeight) this.roiH = imageHeight-this.roiY;
 			else if (roiH <= 0) this.roiH = 1;
 			else this.roiH = roiH;
 
 			if (roi2X >= imageWidth) this.roi2X = imageWidth-1;
 			else if (roi2X < 0) this.roi2X = 0;
 			else this.roi2X = roi2X;
 			if (roi2Y >= imageHeight) this.roi2Y = imageHeight-1;
 			else if (roi2Y < 0) this.roi2Y = 0;
 			else this.roi2Y = roi2Y;
 			if (this.roi2X+roi2W > imageWidth) this.roi2W = imageWidth-this.roi2X;
 			else if (roi2W <= 0) this.roi2W = 1;
 			else this.roi2W = roi2W;
 			if (this.roi2Y+roi2H > imageHeight) this.roi2H = imageHeight-this.roi2Y;
 			else if (roi2H <= 0) this.roi2H = 1;
 			else this.roi2H = roi2H;
 			performAnalysis();
 		}
 		
 	}
 	
 	/**
 	 * Sets the analysis mode for this </code>ImageAnalysisEngine</code>.
 	 * @param local </code>true</code> for local analysis and
 	 * </code>false</code> for remote analysis
 	 */
 	public void setLocalAnalysisMode(boolean local) {
 		if (localAnalysis == local) return;
 		TineHandler.logger.log(Level.INFO, "Analysis mode: " + local);
 		localAnalysis = local;
 		if (localAnalysis) {
 			executeTask(new Runnable() {
 				@Override
 				public void run() {
 					getVideoServerConnection().disconnect();
 				}
 			});
 			setRoi(0, 0, imageWidth, imageHeight);
 		}
 	}
 	
 	/**
 	 * Gets the analysis mode for this </code>ImageAnalysisEngine</code>.
 	 * @return the </code>true</code> if local analysis is selected and
 	 * </code>false</code> if remote analysis is selected
 	 */
 	public boolean isLocalAnalysisMode() {
 		return localAnalysis;
 	}
 	
 	/**
 	 * Starts connection to remote video analysis server.
 	 */
 	public void startRemoteAnalysis() {
 		TineHandler.logger.log(Level.INFO, "Start remote analysis.");
 		try {
 			getVideoServerConnection().connect();
 		} catch (ConnectionFailed e) {
 			e.printStackTrace();
 		}
 	}
 	
 	/**
 	 * Stops connection to remote video analysis server.
 	 */
 	public void stopRemoteAnalysis() {
 		TineHandler.logger.log(Level.INFO, "Stop remote analysis.");
 		getVideoServerConnection().disconnect();
 	}
 	
 	/**
 	 * Sets </code>ConnectionParameters</code> for remote video analysis server.
 	 * @param cp the </code>ConnectionParameters</code> to set
 	 */
 	public void setAnalysisServerConnectionParameters(ConnectionParameters cp) {
 		getVideoServerConnection().setConnectionParameters(cp);
 	}
 	
 	private VideoServerConnection getVideoServerConnection() {
 		if (videoServerConnection == null) {
 			videoServerConnection = new VideoServerConnection();
 			videoServerConnection.addPropertyChangeListener(new PropertyChangeListener() {
 				@Override
 				public void propertyChange(PropertyChangeEvent evt) {
 					if (localAnalysis) return;
 					if (evt.getPropertyName() == VideoServerConnection.PROPERTY_A_IMAGE) {
 						setAImage((AImage) evt.getNewValue());
 					}
 					else if (evt.getPropertyName() == VideoServerConnection.PROPERTY_BACKGROUND) {
 						setBackground((IMAGE) evt.getNewValue(), false);
 					}
 					else if (evt.getPropertyName() == VideoServerConnection.PROPERTY_PRECISE_BACKGROUND) {
 						//TODO handle this
 //						setPreciseBackground((double[]) evt.getNewValue(), videoServerConnection.getPreciseBackgroundWidth(),false);
 					}
 				}
 			});
 		}
 		return videoServerConnection;
 	}
 	
 	private synchronized void setAImage(AImage aImage) {
 		this.aImage = aImage;
 		getPcSupport().firePropertyChange(PROPERTY_A_IMAGE, null, aImage);
 	}
 	
 	private synchronized void performAnalysis() {
 		if (image == null) return;
 		executeAnalysis(new AnalysisExecutor(image,preciseBackground,imageWidth,imageHeight,roiX,roiY,roiW,roiH,
 				roi2X, roi2Y, roi2W, roi2H, threshold,calculateThreshold,performFit,performSmoothing));
 	}
 		
 	private void executeAnalysis(Runnable r) {
 		if (analysisExecutor == null) {
 			ThreadFactory factory = new TINEThreadFactory("TINE-Dismissable");
 			analysisExecutor = new  ThreadPoolExecutor(1, 1, 0, TimeUnit.NANOSECONDS,
 		              new DismissableBlockingQueue<Runnable>(2, true), factory){
 				@Override
 				protected void afterExecute(Runnable r, Throwable t) {
 					super.afterExecute(r, t);
 					if (t != null) {
 						t.printStackTrace();
 					}
 				}
 			};
 			analysisExecutor.setRejectedExecutionHandler(new RejectedExecutionHandler(){
 				public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
 					//ignore
 				}
 			});
 		}
 
 		analysisExecutor.execute(r);
 	}
 	
 	@Deprecated
 	@SuppressWarnings("unused")
 	private static int tineFormatToBufferedType(IMAGE im) {
 		int format = im.getFrameHeader().imageFormat;
 		if (format == ImageFormat.IMAGE_FORMAT_GRAY.getId()) {
 			return BufferedImage.TYPE_BYTE_GRAY;
 		} else if (format == ImageFormat.IMAGE_FORMAT_RGB.getId()) {
 			return BufferedImage.TYPE_INT_RGB;
 		}
 		return BufferedImage.TYPE_INT_RGB;
 	}
 	
 	private void analyzeImage(final IMAGE im, double[] bg, int iW, int iH, int rX, int rY, int rW, int rH,
 			int r2X, int r2Y, int r2W, int r2H, double threshold, boolean calculateThreshold,
 			boolean performFit, boolean smoothing) {
 //		logger.log(Level.FINE, "Analysis: Starting analysis.");
 		IMAGE newImage = im;
 		BufferedImage bufferedImage = toBufferedImage(im);
 		int aH = im.getFrameHeader().aoiHeight;
 		int aW = im.getFrameHeader().aoiWidth;
 
 		if (aH != -1) {
 			iW = aW;
 			iH = aH;
 		}
 		
 		if (bufferedImage == null) throw new IllegalStateException("No BufferedImage!");
 		
 		int[] data = bufferedImage.getRGB(0, 0, iW, iH, null, 0, iW);
 		double[] values = decoder.transform(data);
 		
 		int i, j;
 		
 		if (bg != null) {		
 			int[] newImageVals = new int[values.length];
 			try { 
 				i = 0;
 				//this is actually faster
     			for (;;) {
     				values[i] -= bg[i];
     				newImageVals[i] = (int)(values[i]+0.5);
     				if (newImageVals[i] < 0) {
     					newImageVals[i] = 0;
     				}
     				i++;
     			}
 			} catch (ArrayIndexOutOfBoundsException e) {
 				//ignore
 			}
 			bufferedImage = new BufferedImage(bufferedImage.getWidth(),bufferedImage.getHeight(),BufferedImage.TYPE_BYTE_GRAY);
 			bufferedImage.setRGB(0,0,iW,iH,newImageVals,0,iW);
 			newImage = TImageConverter.parseBufferedImage(bufferedImage,im.getFrameHeader().clone(),im.getSourceHeader().clone());
 			newImage.getFrameHeader().aoiWidth = im.getFrameHeader().aoiWidth;
 			newImage.getFrameHeader().aoiHeight = im.getFrameHeader().aoiHeight;
 			newImage.getFrameHeader().xStart = im.getFrameHeader().xStart;
 			newImage.getFrameHeader().yStart = im.getFrameHeader().yStart;
 			newImage.getFrameHeader().sourceHeight = im.getFrameHeader().sourceHeight;
 			newImage.getFrameHeader().sourceWidth = im.getFrameHeader().sourceWidth;
 		}
 		
 	
 		
 		//calculate the threshold value
 		//we want to "fit" A e^(x-B)^2/2C^2 + D + F x, where D is the threshold
 		//to find D, sum up the values in the threshold ROI and outside ROI and calculate the
 		//average value. That is the new threshold, if there wasn't any specified by the user
 //		logger.log(Level.FINE, "Analysis: Calculating threshold.");
 		int thresholdPointsCount = 0;
 		if (calculateThreshold) {
 			double sum = 0;
 			int r = rX + rW, b = rY+rH;
 			boolean inside = false;
 			for(j = 0; j < r2H; j++)	{
 				inside = rY <= r2Y + j && r2Y + j < b;
 				for(i = 0; i < r2W; i++) {
 					//do not include indexes, which are in normal ROI
 					if (rX <= r2X + i && r2X + i < r && inside) continue;
 					sum += values[i+r2X+iW*(j+r2Y)];
 					thresholdPointsCount++;
 				}
 			}
 			if (thresholdPointsCount != 0) {
 				threshold = sum/thresholdPointsCount;
 			} else {
 				threshold = Double.NaN;
 			}
 		}
 //		logger.log(Level.FINE, "Analysis: Performing statistical analysis.");
 		double[] sideViewX = new double [iW];
 		double[] sideViewY = new double [iH];
 		
 		double maxValue = -Double.MAX_VALUE;
 		double minValue = Double.MAX_VALUE;
 		double value;
 		//if threshold is less than 0 (that can happen if such background
 		//is substracted, that the values of background are larger than the
 		//image values), do not subtract the threshold.
 		if (Double.isNaN(threshold)) {
 			for (i = 0; i < iW; ++i) {
     			for (j = 0; j < iH; ++j) {
     				value = values[i+j*iW];
     //		for (i = 0; i < rW; ++i) {
     //			for (j = 0; j < rH; ++j) {
     //				value = values[i+rX+iW*(j+rY)];
     				if (minValue > value) minValue = value;
     				if (maxValue < value) maxValue = value;
     				sideViewX[i] += (value);
     				sideViewY[j] += (value);
     			}
     		}
 		} else {
     		for (i = 0; i < iW; ++i) {
     			for (j = 0; j < iH; ++j) {
     				value = values[i+j*iW];
     //		for (i = 0; i < rW; ++i) {
     //			for (j = 0; j < rH; ++j) {
     //				value = values[i+rX+iW*(j+rY)];
     				if (minValue > value) minValue = value;
     				if (value < threshold) continue;
     				if (maxValue < value) maxValue = value;
     				sideViewX[i] += (value-threshold);
     				sideViewY[j] += (value-threshold);
     			}
     		}
 		}
 			
 		//Do not do these: request from Gero
 //		for (i = 0; i < iW; i++) {
 //			if (sideViewX[i] < 0) {
 //				sideViewX[i] = 0;
 //			}
 //		}
 //		for (j = 0; j < iH; j++) {
 //			if (sideViewY[j] < 0) {
 //				sideViewY[j] = 0;
 //			}
 //		}
 		
 		//smoothing 	
 		if (smoothing) {
 			sideViewX = FittingUtilities.smooth(sideViewX);
 			sideViewY = FittingUtilities.smooth(sideViewY);
 		}
 		//end of smoothing
 		double[] roiSideViewX = new double[rW];
 		double[] roiSideViewY = new double[rH];
 		
 		for (i = 0; i < rW; ++i){
 			roiSideViewX[i]= sideViewX[rX+i];
 		}
 		
 		for (j = 0; j < rH; ++j){
 			roiSideViewY[j]= sideViewY[rY+j];
 		}
 		
 		try {
 			i = 0;
 			for (;;) {
 				if (values[i] < 0) values[i] = 0;
 				i++;
 			}
 		} catch (ArrayIndexOutOfBoundsException e) {
 			//ignore
 		}
 		
 		double sum = 0;
 		double sumX = 0;
 		double sumY = 0;
 		double sumXX = 0;
 		double sumYY = 0;
 		double sumXY = 0;
 		
 		if (Double.isNaN(threshold)) {
     		for(j = 0; j < rH; j++)
     		{
     			for(i = 0; i < rW; i++)
     			{
     				value = values[i+rX+iW*(j+rY)];
 					sum = sum+value;
 					sumX = sumX+value*(i+rX);
 					sumY = sumY+value*(j+rY);
     			}
     		}
 		} else {
 			for(j = 0; j < rH; j++)
 			{
 				for(i = 0; i < rW; i++)
 				{
 					value = values[i+rX+iW*(j+rY)];
 					if(threshold < value)
 					{
 						value -=threshold;
 						sum = sum+value;
 						sumX = sumX+value*(i+rX);
 						sumY = sumY+value*(j+rY);
 					}
 				}
 			}
 		}
 		
 		double Y = sumY/sum;
 		double X = sumX/sum;
 		
 		double argx, argy;
 		if (Double.isNaN(threshold)) {
 			for(j = 0; j < rH; j++)
     		{
     			for(i = 0; i < rW; i++)
     			{
     				value = values[i+rX+iW*(j+rY)];
 					argx = i+rX-X;
 					argy = j+rY-Y;
 					sumXX = sumXX+value*argx*argx;
 					sumXY = sumXY+value*argx*argy;
 					sumYY = sumYY+value*argy*argy;
     			}
     		}
 		} else {
     		for(j = 0; j < rH; j++)
     		{
     			for(i = 0; i < rW; i++)
     			{
     				value = values[i+rX+iW*(j+rY)];
     				if(threshold < value)
     				{
     					value -=threshold;
     					argx = i+rX-X;
     					argy = j+rY-Y;
     					sumXX = sumXX+value*argx*argx;
     					sumXY = sumXY+value*argx*argy;
     					sumYY = sumYY+value*argy*argy;
     				}
     			}
     		}
 		}
 		//TODO
 //		if (calculateThreshold && threshold < 0) {
 //			threshold = Double.NaN;
 //		}
 		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(roiSideViewX,0,rW);
 		double[] yMinMax = findMinMax(roiSideViewY,0,rH);
 
 		//perform the statistics calculation on the sideview data
 		double xM = 0;
 		double yM = 0;
 		double suma = 0;
 		double xSTD = 0;
 		double ySTD = 0;
 		double constX = xMinMax[0];
 		double constY = yMinMax[0];
 		for (i = 0; i < rW; i++) {
 			value = roiSideViewX[i]-constX;
 			if (value < 0) value = 0;
 			xM += i*value;
 			xSTD += i*i*value;
 			suma += value;
 		}
 		xM = xM/suma;
 		xSTD = Math.sqrt(xSTD/suma-xM*xM);
 		suma = 0;
 		for (i = 0; i < rH; i++) {
 			value = roiSideViewY[i]-constY;
 			if (value < 0) value = 0;
 			yM += i*value;
 			ySTD += i*i*value;
 			suma += value;
 		}
 		yM = yM/suma;
 		ySTD = Math.sqrt(ySTD/suma-yM*yM);
 		
 		double[] startValuesX = new double[]{xMinMax[1]-constX,xSTD,xM,constX,0};
 		double[] startValuesY = new double[]{yMinMax[1]-constY,ySTD,yM,constY,0};
 		
 		if (performFit) {
 //				logger.log(Level.FINE, "Analysis: Fitting gauss function to side views.");
 						
     		int l = roiSideViewX.length;
     		double[] steps = new double[l];
     		double[] weights = new double[l];
     		for (i = 0; i < l; i++) {
     			steps[i] = i;
     			weights[i] = 1;
     		}
     		
     		try {
         		startValuesX = FittingUtilities.lmLinear(steps,roiSideViewX,weights,startValuesX);
         		//fallback: try again with different starting vector
         		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1)) {
         			if (previousStartValuesX != null) {
         				startValuesX = previousStartValuesX;
         				i = 0;
                 		do {
                 			startValuesX = FittingUtilities.lmLinear(steps,roiSideViewX,weights,startValuesX);
                 			i++;
                 		} while ((startValuesX[0] > 7000000 || startValuesX[0] <= 1 || startValuesX[1] <= 1) && i < 3);
                 		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1 || startValuesX[1] <= 1) ) {
                 			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
                 			previousStartValuesX = null;
                 		} else {
                 			previousStartValuesX = startValuesX;
                 		}
         			} else {
             			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
             			previousStartValuesX = null;
         			}
         		} else {
     				//in case there is not enough tail, the fit will over/undershot in the constant
     				//we need to add some tail	
             		if (rW < iW) {
             			double slope = startValuesX[4];
             			startValuesX = new double[]{xMinMax[1]-constX,xSTD,rX+xM,constX,0};
     					double[] roiSX = new double[iW];
     					for (i = 0; i < iW; i++) {
     						roiSX[i] = sideViewX[i] - slope*i;
     					}
     					
     					steps = new double[iW];
                 		weights = new double[iW];
                 		for (i = 0; i < iW; i++) {
                 			steps[i] = i;
                 			weights[i] = 1;
                 		}
                 		startValuesX = FittingUtilities.lmLinear(steps,roiSX,weights,startValuesX);
                 		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1) && previousStartValuesX != null) {
                 			startValuesX = previousStartValuesX;
                      		do {
                          		startValuesX = FittingUtilities.lmLinear(steps,roiSX,weights,startValuesX);
                     			i++;
                     		} while ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1) && i < 3);
                 		}
                   		startValuesX[4] += slope;
                   		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1)) {
                 			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
                 			previousStartValuesX = null;
                   		} else {
                   			previousStartValuesX = startValuesX;
                   		}
     				} else {
     					previousStartValuesX = startValuesX;
     				}
         		}
     		} catch (Exception e) {
     			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
     			previousStartValuesX = null;
     		}
 
     		try {
         		l = roiSideViewY.length;
         		steps = new double[l];
         		weights = new double[l];
         		for (i = 0; i < l; i++) {
         			steps[i] = i;
         			weights[i] = 1;
         		}
         		
         		startValuesY = FittingUtilities.lmLinear(steps,roiSideViewY,weights,startValuesY);
         		//fallback: try again with different starting vector
         		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) ) {
         			if (previousStartValuesY != null) {
         				startValuesY = previousStartValuesY;
         				i = 0;
                 		do {
                 			startValuesY = FittingUtilities.lmLinear(steps,roiSideViewY,weights,startValuesY);
                 			i++;
                 		} while ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) && i < 3);
                 		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) ) {
                 			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
                 			previousStartValuesY = null;
                 		} else {
                 			previousStartValuesY = startValuesY;
                 		}
         			} else {
         				startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
         				previousStartValuesY = null;
         			}
         		}  else {
     				//in case there is not enough tail, the fit will over/undershot in the constant
     				//we need to add some tailvalues	
             		if (rH < iH) {
             			double slope = startValuesY[4];
             			startValuesY = new double[]{yMinMax[1]-constY,ySTD,rY+yM,constY,0};
     					double[] roiSY = new double[iH];
     					for (i = 0; i < iH; i++) {
     						roiSY[i] = sideViewY[i] - slope*i;
     					}
     					steps = new double[iH];
                 		weights = new double[iH];
                 		for (i = 0; i < iH; i++) {
                 			steps[i] = i;
                 			weights[i] = 1;
                 		}
                 		i = 0;
                 		startValuesY = FittingUtilities.lmLinear(steps,roiSY,weights,startValuesY);
                 		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) && previousStartValuesY != null) {
                 			startValuesY = previousStartValuesY;
                     		do {
                     			startValuesY = FittingUtilities.lmLinear(steps,roiSY,weights,startValuesY);
                     			i++;
                     		} while ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) && i < 3);
                 		}
     
                 		startValuesY[4] += slope;
                 		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) ) {
                 			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
                 			previousStartValuesY = null;
                 		} else {
                 			previousStartValuesY = startValuesY;
                 		}
     				} else {
     					previousStartValuesY = startValuesY;
     				}
         		}
     		} catch (Exception e) {
     			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
     			previousStartValuesY = null;
     		}
     		
     		if (FittingUtilities.isNaN(startValuesY)) {
     			startValuesY = new double[]{yMinMax[1]-constY,ySTD,rY+yM,constY,0};
     		}
     		if (FittingUtilities.isNaN(startValuesX)) {
     			startValuesX = new double[]{xMinMax[1]-constX,ySTD,rX+xM,constX,0};
     		}
 		} else {
 			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 			previousStartValuesY = null;
 			previousStartValuesX = null;
 		}
 		
 
 		try {
 			if (!Double.isNaN(threshold)){
 				maxValue = maxValue - threshold; 
 			}
 			AImage newAImage = new AImage(
 					newImage, rX, rY, rW, rH, r2X, r2Y, r2W, r2H, threshold,
 					sideViewX,rX+xM,xSTD,xMinMax[1]-constX,constX,
 					startValuesX[2], startValuesX[1], startValuesX[0], startValuesX[3], startValuesX[4],
 					sideViewY,rY+yM,ySTD,yMinMax[1]-constY,constY,
 					startValuesY[2], startValuesY[1], startValuesY[0], startValuesY[3], startValuesY[4],
 //					Math.sqrt(A), Math.sqrt(B), phase, maxValue-threshold, minValue, 
 					Math.sqrt(A), Math.sqrt(B), phase, maxValue, minValue,
 					thresholdPointsCount,calculateThreshold,performFit,smoothing
 			);
 			setAImage(newAImage);
 			
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		
 	}
 	
 //	private void analyzeImage(final IMAGE im, final IMAGE bg, int iW, int iH, int rX, int rY, int rW, int rH,
 //			int r2X, int r2Y, int r2W, int r2H, double threshold, boolean calculateThreshold,
 //			boolean performFit) {
 ////		logger.log(Level.FINE, "Analysis: Starting analysis.");
 //		IMAGE newImage = im;
 //		BufferedImage bufferedImage = toBufferedImage(im);
 //		//imageConverter.parseTineImageNoClone(im, false); // mdavid: changed
 //		if (bufferedImage == null) throw new IllegalStateException("No BufferedImage!");
 //		
 //		int[] data = bufferedImage.getRGB(0, 0, iW, iH, null, 0, iW);
 //		double[] values = decoder.transform(data);
 //		
 //		int i, j;
 //		
 //		if (bg != null) {
 ////			logger.log(Level.FINE, "Analysis: Subtracting background.");
 //			bufferedImage = toBufferedImage(bg);
 ////			bufferedImage = imageConverter.parseTineImage(bg, false); // mdavid: changed
 //			if (bufferedImage == null) throw new IllegalStateException("No BufferedImage!");
 //
 //			
 //			int[] backData = bufferedImage.getRGB(0, 0, iW, iH, null, 0, iW);
 //			double[] backVals = decoder.transform(backData);
 //			try { 
 //				i = 0;
 //				//this is actually faster
 //    			for (;;) {
 //    				values[i] -= backVals[i];
 //    				data[i] -= backData[i];
 //    				if (values[i] < 0) {
 //    					values[i] = 0;
 //    					data[i] = 0;
 //    				}
 //    				i++;
 //    			}
 //			} catch (ArrayIndexOutOfBoundsException e) {
 //				//ignore
 //			}
 //			
 ////			BufferedImage bf = new BufferedImage(bufferedImage.getWidth(),bufferedImage.getHeight(),bufferedImage.getType() != BufferedImage.TYPE_CUSTOM ? bufferedImage.getType() : BufferedImage.TYPE_INT_RGB);
 //			
 //			bufferedImage = new BufferedImage(bufferedImage.getWidth(),bufferedImage.getHeight(),tineFormatToBufferedType(im));
 //			bufferedImage.setRGB(0,0,iW,iH,data,0,iW);
 //			newImage = TImageConverter.parseBufferedImage(bufferedImage,im.getFrameHeader().clone(),im.getSourceHeader().clone());
 //		}
 //		
 //	
 //		
 //		//calculate the threshold value
 //		//we want to "fit" A e^(x-B)^2/2C^2 + D, where D is the threshold
 //		//to find D, sum up the boundary values (10 pixels) around the ROI and calculate
 //		//the average value. that is the new threshold, if there wasn't any specified by the
 //		//user
 ////		logger.log(Level.FINE, "Analysis: Calculating threshold.");
 //		int thresholdPointsCount = 0;
 //		if (calculateThreshold) {
 //			double sum = 0;
 //			int r = rX + rW, b = rY+rH;
 //			boolean inside = false;
 //			for(j = 0; j < r2H; j++)	{
 //				inside = rY <= r2Y + j && r2Y + j < b;
 //				for(i = 0; i < r2W; i++) {
 //					//do not include indexes, which are in normal ROI
 //					if (rX <= r2X + i && r2X + i < r && inside) continue;
 //					sum += values[i+r2X+iW*(j+r2Y)];
 //					thresholdPointsCount++;
 //				}
 //			}
 //			if (thresholdPointsCount != 0) {
 //				threshold = sum/thresholdPointsCount;
 //			} else {
 //				threshold = 0;
 //			}
 //
 //		}
 //		
 ////		logger.log(Level.FINE, "Analysis: Performing statistical analysis.");
 //		double[] sideViewX = new double [iW];
 //		double[] sideViewY = new double [iH];
 //		
 //		double maxValue = -Double.MAX_VALUE;
 //		double minValue = Double.MAX_VALUE;
 //		double value;
 //		for (i = 0; i < iW; ++i) {
 //			for (j = 0; j < iH; ++j) {
 //				value = values[i+j*iW];
 //				if (minValue > value) minValue = value;
 //				if (value < threshold) continue;
 //				if (maxValue < value) maxValue = value;
 //				sideViewX[i] += (value-threshold);
 //				sideViewY[j] += (value-threshold);
 //			}
 //		}
 //		
 //		double[] roiSideViewX = new double[iW];
 //		double[] roiSideViewY = new double[iH];
 //		
 //		value = sideViewX[rX];
 //		for (i = 0; i < rX; i++) {
 //			roiSideViewX[i] = value;
 //		}
 //		for (i = rX; i < rX+rW; ++i){
 //			roiSideViewX[i]= sideViewX[i];
 //		}
 //		value = sideViewX[rX+rW-1];
 //		for (i = rX+rW; i < iW; i++) {
 //			roiSideViewX[i] = value;
 //		}
 //		
 //		value = sideViewY[rY];
 //		for (i = 0; i < rY; i++) {
 //			roiSideViewY[i] = value;
 //		}
 //		for (j = rY; j < rY+rH; ++j){
 //			roiSideViewY[j]= sideViewY[j];
 //		}
 //		value = sideViewY[rY+rH-1];
 //		for (i = rY+rH; i < iH; i++) {
 //			roiSideViewY[i] = value;
 //		}
 //		
 //		double sum = 0;
 //		double sumX = 0;
 //		double sumY = 0;
 //		double sumXX = 0;
 //		double sumYY = 0;
 //		double sumXY = 0;
 //		
 //		for(j = 0; j < rH; j++)
 //		{
 //			for(i = 0; i < rW; i++)
 //			{
 //				value = values[i+rX+iW*(j+rY)];
 //				if(threshold < value)
 //				{
 //					value -=threshold;
 //					sum = sum+value;
 //					sumX = sumX+value*(i+rX);
 //					sumY = sumY+value*(j+rY);
 //				}
 //			}
 //		}
 //		
 //		double Y = sumY/sum;
 //		double X = sumX/sum;
 //		
 //		double argx, argy;
 //		for(j = 0; j < rH; j++)
 //		{
 //			for(i = 0; i < rW; i++)
 //			{
 //				value = values[i+rX+iW*(j+rY)];
 //				if(threshold < value)
 //				{
 //					value -=threshold;
 //					argx = i+rX-X;
 //					argy = j+rY-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(roiSideViewX,rX,rW);
 //		double[] yMinMax = findMinMax(roiSideViewY,rY,rH);
 //
 //		//perform the statistics calculation on the sideview data
 //		int end = rX+rW;
 //		double xM = 0;
 //		double yM = 0;
 //		double suma = 0;
 //		double xSTD = 0;
 //		double ySTD = 0;
 //		double constX = rX != 0 ? roiSideViewX[0] : xMinMax[0];
 //		double constY = rY != 0 ? roiSideViewY[0] : yMinMax[0];
 //		for (i = rX; i < end; i++) {
 //			value = roiSideViewX[i]-constX;
 //			if (value < 0) value = 0;
 //			xM += i*value;
 //			xSTD += i*i*value;
 //			suma += value;
 //		}
 //		xM = xM/suma;
 //		xSTD = Math.sqrt(xSTD/suma-xM*xM);
 //		end = rY + rH;
 //		suma = 0;
 //		for (i = rY; i < end; i++) {
 //			value = roiSideViewY[i]-constY;
 //			if (value < 0) value = 0;
 //			yM += i*value;
 //			ySTD += i*i*value;
 //			suma += value;
 //		}
 //		yM = yM/suma;
 //		ySTD = Math.sqrt(ySTD/suma-yM*yM);
 //				
 //		
 //		double[] startValuesX = new double[]{xMinMax[1]-constX,xSTD,xM,constX,0};
 //		double[] startValuesY = new double[]{yMinMax[1]-constY,ySTD,yM,constY,0};
 //		try {
 //			if (performFit) {
 ////				logger.log(Level.FINE, "Analysis: Fitting gauss function to side views.");
 //        		int l = roiSideViewX.length;
 //        		double[] steps = new double[l];
 //        		double[] weights = new double[l];
 //        		for (i = 0; i < l; i++) {
 //        			steps[i] = i;
 //        			weights[i] = 1;
 //        		}
 //        		startValuesX = FittingUtilities.lm2(steps,roiSideViewX,weights,startValuesX);
 //        		//fallback: try again with different starting vector
 //        		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1)) {
 //        			i = 0;
 ////        			startValuesX = previousStartValuesX;
 //            		do {
 //            			startValuesX = FittingUtilities.lm2(steps,roiSideViewX,weights,startValuesX);
 //            			i++;
 //            		} while ((startValuesX[0] > 700000 || startValuesX[0] <= 1|| startValuesX[1] <= 1) && i < 5);
 //        		}
 //        		if ((startValuesX[0] > 7000000 || startValuesX[0] <= 1|| startValuesX[1] <= 1)) {
 //        			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //        		}
 //
 //        		l = roiSideViewY.length;
 //        		steps = new double[l];
 //        		weights = new double[l];
 //        		for (i = 0; i < l; i++) {
 //        			steps[i] = i;
 //        			weights[i] = 1;
 //        		}
 //        		
 //        		startValuesY = FittingUtilities.lm2(steps,roiSideViewY,weights,startValuesY);
 //        		//fallback: try again with different starting vector
 //        		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) ) {
 //            		i = 0;
 ////            		startValuesY = previousStartValuesY;
 //            		do {
 //            			startValuesY = FittingUtilities.lm2(steps,roiSideViewY,weights,startValuesY);
 //            			i++;
 //            		} while ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) && i < 5);
 //        		}
 //        		if ((startValuesY[0] > 7000000 || startValuesY[0] <= 1 || startValuesY[1] <= 1) ) {
 //        			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //        		}
 //        		
 ////        		previousStartValuesX = startValuesX;
 ////        		previousStartValuesY = startValuesY;
 //			} else {
 //				startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //				startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //			}
 //		} catch (Exception e) {
 //			startValuesX = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //			startValuesY = new double[]{Double.NaN,Double.NaN,Double.NaN,Double.NaN,Double.NaN};
 //		}
 //
 //		try {
 //			AImage newAImage = new AImage(
 //					newImage, rX, rY, rW, rH, r2X, r2Y, r2W, r2H, threshold,
 ////					sideViewX, X, Math.sqrt(XX), xMinMax[1]-xMinMax[0], xMinMax[0],
 //					sideViewX,xM,xSTD,xMinMax[1]-constX,constX,
 //					startValuesX[2], startValuesX[1], startValuesX[0], startValuesX[3], startValuesX[4],
 ////					sideViewY, Y, Math.sqrt(YY), yMinMax[1]-yMinMax[0], yMinMax[0],
 //					sideViewY,yM,ySTD,yMinMax[1]-constY,constY,
 //					startValuesY[2], startValuesY[1], startValuesY[0], startValuesY[3], startValuesY[4],
 //					Math.sqrt(A), Math.sqrt(B), phase, maxValue-threshold, minValue, 
 //					thresholdPointsCount,calculateThreshold,performFit
 //			);
 ////			logger.log(Level.FINE, "Analysis: Analysis completed.");
 //			setAImage(newAImage);
 //			
 //		} catch (Exception e) {
 //			e.printStackTrace();
 //		}
 //		
 //	}
 	
 	private double[] findMinMax(double[] values,int start, int length) {
 		double min = Double.MAX_VALUE;
 		double max = -Double.MAX_VALUE;
 		for (int i = start; i < start+length; i++) {
 			if (values[i] > max) max = values[i];
 			if (values[i] < min) min = values[i];
 		}
 		return new double[] {min, max};
 	}
 	
 	private void executeTask(Runnable r) {
 		if (executor == null) {
 			executor = Executors.newSingleThreadExecutor();
 		}
 		executor.execute(r);
 	}
 	
 	private PropertyChangeSupport getPcSupport() {
 		if (pcSupport == null) {
 			pcSupport = new PropertyChangeSupport(this);
 		}
 		return pcSupport;
 	}
 	
 	/**
 	 * Adds a </code>PropertyChangeListener</code> for the specified propertyName.
 	 * @param propertyName the name of the property
 	 * @param listener the </code>PropertyChangeListener</code> to add
 	 */
 	public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
 		getPcSupport().addPropertyChangeListener(propertyName, listener);
 	}
 	
 	/**
 	 * Removes a </code>PropertyChangeListener</code> for the specified propertyName.
 	 * @param propertyName the name of the property
 	 * @param listener the </code>PropertyChangeListener</code> to remove
 	 */
 	public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
 		getPcSupport().removePropertyChangeListener(propertyName, listener);
 	}
 	
 	/**
 	 * Adds a </code>PropertyChangeListener</code>.
 	 * @param listener the </code>PropertyChangeListener</code> to add
 	 */
 	public void addPropertyChangeListener(PropertyChangeListener listener) {
 		getPcSupport().addPropertyChangeListener(listener);
 	}
 	
 	/**
 	 * Removes a </code>PropertyChangeListener</code>.
 	 * @param listener the </code>PropertyChangeListener</code> to remove
 	 */
 	public void removePropertyChangeListener(PropertyChangeListener listener) {
 		getPcSupport().removePropertyChangeListener(listener);
 	}
 	
 	/**
 	 * Transforms the IMAGE to BufferedImage using the appropriate algorithm
 	 * for the given image.
 	 * 
 	 * @param image the image to transform
 	 * @return transformed image
 	 */
 	public static BufferedImage toBufferedImage(IMAGE image) {
 		if (TBufferedImage.isSupported(image.getFrameHeader().imageFormat)) {
 			return TBufferedImage.toBufferedImage(image,null,false,false);
 		} else {
 			return new TImageConverter().parseTineImage(image,false);
 		}
 	}
 }