/**
    * 
    */
   package de.desy.acop.video;
   
   import java.awt.Dimension;
   import java.awt.Rectangle;
   import java.awt.geom.Rectangle2D;
   import java.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  
  import de.desy.acop.video.displayer.ImageZoom;
  
  /**
   * </code>ScaleHelper</code> provides methods for converting rectangles from image 
   * coordinates to component (display) coordinates. It also keeps track of the image
   * rectangle inside the component (which can be different than the component's
   * rectangle if aspect ratio should be kept). 
   * 
   * @author Tilen Kusterle, Cosylab
   *
   */
  public class ScaleHelper {
  	
  	public static final String PROPERTY_IMAGE_AOI = "imageAoi";
  	public static final String PROPERTY_IMAGE_DIMENSION = "imageDimension";
  	public static final String PROPERTY_COMPONENT_DIMENSION = "componentDimension";
  	public static final String PROPERTY_ACTIVE_RECTANGLE = "activeRectangle";
  	public static final String PROPERTY_KEEP_ASPECT_RATIO = "keepAspectRatio";
  	public static final String PROPERTY_AOI_ZOOM = "aoiZoom";
  	public static final String PROPERTY_IMAGE_ZOOM = "imageZoom";
  	
  	private PropertyChangeSupport pcSupport;
  	
  	private Rectangle imageAoi = null;
  	private Dimension imageDimension = null;
  	private Dimension componentDimension = null;
  	private Rectangle2D activeRectangle = null;
  	private boolean keepAspectRatio;
  	private boolean aoiZoom;
  	private ImageZoom imageZoom;
  
  	/**
  	 * Constructs this </code>ScaleHelper</code>.
  	 * @param keepAspectRatio is aspect ratio kept or not
  	 */
  	public ScaleHelper(boolean keepAspectRatio, boolean aoiZoom, ImageZoom imageZoom) {
  		this.keepAspectRatio = keepAspectRatio;
  		this.aoiZoom = aoiZoom;
  		this.imageZoom = imageZoom;
  	}
  	
  	/**
  	 * Transforms a rectangle contained within the component from display coordinates
  	 * to image coordinates.
  	 * @param componentRect the rectangle in display coordinates to transform
  	 * @return the transformed rectangle in image coordinates
  	 */
  	public synchronized Rectangle componentToImage(Rectangle2D componentRect) {
  		if (imageAoi == null || activeRectangle == null) return null;
  		int roiX = (int) Math.round((componentRect.getX()-activeRectangle.getX())/activeRectangle.getWidth()*imageAoi.width);
  		int roiY = (int) Math.round((componentRect.getY()-activeRectangle.getY())/activeRectangle.getHeight()*imageAoi.height);
  		int roiW = (int) Math.round(componentRect.getWidth()/activeRectangle.getWidth()*imageAoi.width);
  		int roiH = (int) Math.round(componentRect.getHeight()/activeRectangle.getHeight()*imageAoi.height);
  		return new Rectangle(roiX, roiY, roiW, roiH);
  	}
  	
  	/**
  	 * Transforms a rectangle contained within the image from image coordinates to
  	 * display coordinates within the component.
  	 * @param rectangle the rectangle in image coordinates to transform
  	 * @return the transformed rectangle in display coordinates
  	 */
  	public synchronized Rectangle2D imageToComponent(Rectangle2D rectangle) {
  		return internalImageToComponent(rectangle);
  	}
  	
  	private Rectangle2D internalImageToComponent(Rectangle2D rectangle) {
  		if (imageAoi == null || componentDimension == null) return null;
  		
  		boolean isAspectKeeped = imageZoom == ImageZoom.AUTO && keepAspectRatio;
  		Dimension size = isAspectKeeped ? getKeepedRatioSize(new Dimension(imageDimension.width, imageDimension.height)) : getZoomedSize();
  
  		Rectangle rectDst = new Rectangle((componentDimension.width-size.width)/2, (componentDimension.height-size.height)/2, size.width, size.height);
  
  		if (aoiZoom) {
  			if (imageZoom == ImageZoom.AUTO && keepAspectRatio) {
  				size = getKeepedRatioSize(imageAoi.getSize());
  				rectDst = new Rectangle((componentDimension.width-size.width)/2, (componentDimension.height-size.height)/2, size.width, size.height);
  			}
  
  		} else {
  			double wscale_full = (double) rectDst.width / (double) imageDimension.width;
  			double hscale_full = (double) rectDst.height / (double) imageDimension.height;
  			rectDst.width = (int) Math.round(imageAoi.width * wscale_full);
  			rectDst.height = (int) Math.round(imageAoi.height * hscale_full);
  			rectDst.x += ((int) (imageAoi.x * wscale_full));
  			rectDst.y += ((int) (imageAoi.y * hscale_full));
  		}
 		
 		double rh = (double)rectDst.width/(double)imageAoi.width;
 		double rv = (double)rectDst.height/(double)imageAoi.height;
 		
 		double x = rectangle.getX()*rh+rectDst.x;
 		double y = rectangle.getY()*rv+rectDst.y;
 		double w = rectangle.getWidth()*rh;
 		double h = rectangle.getHeight()*rv;
 		
 		return new Rectangle2D.Double(x, y, w, h);
 		
 		// ORIGINAL!
 //		if (imageAoi == null || componentDimension == null) return null;
 //		
 //		double horizontal = imageAoi.width;
 //		double vertical = imageAoi.height;
 //		double width = componentDimension.width;
 //		double height = componentDimension.height;
 //		double x, y, w, h;
 //		
 //		double rw = horizontal/width;
 //		double rh = vertical/height;
 //		if (keepAspectRatio) {
 //			if (rw > rh) {
 //				x = rectangle.getX()/rw;
 //				y = rectangle.getY()/rw+(height-vertical/rw)/2;
 //				w = rectangle.getWidth()/rw;
 //				h = rectangle.getHeight()/rw;
 //			} else {
 //				x = rectangle.getX()/rh+(width-horizontal/rh)/2;
 //				y = rectangle.getY()/rh;
 //				w = rectangle.getWidth()/rh;
 //				h = rectangle.getHeight()/rh;
 //			}
 //		} else {
 //			x = rectangle.getX()/rw;
 //			y = rectangle.getY()/rh;
 //			w = rectangle.getWidth()/rw;
 //			h = rectangle.getHeight()/rh;
 //		}
 //		
 //		return new Rectangle2D.Double(x, y, w, h);
 		
 	}
 	
 	/*
 	 * Copied from ImageDisplayer.
 	 */
 	private Dimension getZoomedSize() {
 		switch (imageZoom) {
 		case AUTO:
 			return new Dimension(componentDimension);
 
 		case HALF:
 			return new Dimension(
 					Math.round((float)imageDimension.width/2),
 					Math.round((float)imageDimension.height/2));
 
 		case NORMAL:
 			return new Dimension(imageDimension);
 
 		case DOUBLE:
 			return new Dimension(imageDimension.width*2, imageDimension.height*2);
 
 		default:
 			throw new IllegalStateException("unsupported image zoom: " + imageZoom);
 		}
 	}
 	
 	/*
 	 * Copied from ImageDisplayer.
 	 */
 	private Dimension getKeepedRatioSize(Dimension src) {
 		float ratio = (float) src.width / (float) src.height;
 		int width = componentDimension.width;
 		int height = componentDimension.height;
 		if (width > height) {
 			int tmp = Math.round(ratio * height);
 			if (tmp > width)
 				return new Dimension(width, Math.round(width / ratio));
 			else
 				return new Dimension(tmp, height);
 		} else
 			return new Dimension(width, Math.round(width / ratio));
 	}
 	
 	/**
 	 * Gets the dimension of the image.
 	 * @return the imageDimension
 	 */
 	public Dimension getImageDimension() {
 		return imageDimension;
 	}
 	
 	/**
 	 * Gets the image AOI rectangle.
 	 * @return the imageAoi
 	 */
 	public Rectangle getImageAoi() {
 		return imageAoi;
 	}
 
 	/**
 	 * Sets the image image data (dimension and AOI).
 	 * @param imageDimension the imageDimension to set
 	 * @param imageAoi the imageAoi to set
 	 */
 	public synchronized void setImageData(Dimension imageDimension, Rectangle imageAoi) {
 		Dimension oldDim = this.imageDimension;
 		Rectangle oldAoi = this.imageAoi;
 		if (imageDimension == null || imageAoi == null) {
 			imageDimension = null;
 			imageAoi = null;
 		}
 		this.imageDimension = imageDimension;
 		this.imageAoi = imageAoi;
 		getPcSupport().firePropertyChange(PROPERTY_IMAGE_AOI, oldAoi, imageAoi);
 		getPcSupport().firePropertyChange(PROPERTY_IMAGE_DIMENSION, oldDim, imageDimension);
 		if (imageAoi == null) {
 			setActiveRectangle(null);
 			return;
 		}
 		setActiveRectangle(internalImageToComponent(imageAoi));
 	}
 
 
 	/**
 	 * Gets the dimension of the component.
 	 * @return the componentDimension
 	 */
 	public synchronized Dimension getComponentDimension() {
 		return componentDimension;
 	}
 
 
 	/**
 	 * Sets the dimension of the component.
 	 * @param componentDimension the componentDimension to set
 	 */
 	public synchronized void setComponentDimesnion(Dimension componentDimension) {
 		if (
 				this.componentDimension != null && componentDimension != null &&
 				this.componentDimension.width == componentDimension.width &&
 				this.componentDimension.height == componentDimension.height) return;
 		Dimension old = this.componentDimension;
 		this.componentDimension = componentDimension;
 		getPcSupport().firePropertyChange(PROPERTY_COMPONENT_DIMENSION, old, componentDimension);
 		if (imageAoi == null) return;
 		setActiveRectangle(internalImageToComponent(imageAoi));
 	}
 
 
 	/**
 	 * Gets the active rectangle (the part of the component occupied by the 
 	 * displayed image).
 	 * @return the activeRectangle
 	 */
 	public synchronized Rectangle2D getActiveRectangle() {
 		return activeRectangle;
 	}
 	
 	private void setActiveRectangle(Rectangle2D activeRectangle) {
 		Rectangle2D old = this.activeRectangle;
 		this.activeRectangle = activeRectangle;
 		getPcSupport().firePropertyChange(PROPERTY_ACTIVE_RECTANGLE, old, activeRectangle);
 	}
 
 
 	/**
 	 * Gets the keep aspect ratio property.
 	 * @return the keepAspectRatio
 	 */
 	public synchronized boolean isKeepAspectRatio() {
 		return keepAspectRatio;
 	}
 
 
 	/**
 	 * Sets the keep aspect ratio property.
 	 * @param keepAspectRatio the keepAspectRatio to set
 	 */
 	public synchronized void setKeepAspectRatio(boolean keepAspectRatio) {
 		boolean old = this.keepAspectRatio;
 		this.keepAspectRatio = keepAspectRatio;
 		getPcSupport().firePropertyChange(PROPERTY_KEEP_ASPECT_RATIO, old, keepAspectRatio);
 		if (imageAoi == null) return;
 		setActiveRectangle(internalImageToComponent(imageAoi));
 	}
 	
 	/**
 	 * Gets the AOI zoom property.
 	 * @return the aoiZoom
 	 */
 	public synchronized boolean isAoiZoom() {
 		return aoiZoom;
 	}
 
 	/**
 	 * Sets the AOI zoom property.
 	 * @param aoiZoom the aoiZoom to set
 	 */
 	public synchronized void setAoiZoom(boolean aoiZoom) {
 		boolean old = this.aoiZoom;
 		this.aoiZoom = aoiZoom;
 		getPcSupport().firePropertyChange(PROPERTY_AOI_ZOOM, old, aoiZoom);
 		if (imageAoi == null) return;
 		setActiveRectangle(internalImageToComponent(imageAoi));
 	}
 
 	/**
 	 * Gets the </code>ImageZoom</code> property.
 	 * @return the imageZoom
 	 */
 	public synchronized ImageZoom getImageZoom() {
 		return imageZoom;
 	}
 
 	/**
 	 * Sets the </code>ImageZoom</code> property.
 	 * @param imageZoom the imageZoom to set
 	 */
 	public synchronized void setImageZoom(ImageZoom imageZoom) {
 		ImageZoom old = this.imageZoom;
 		this.imageZoom = imageZoom;
 		getPcSupport().firePropertyChange(PROPERTY_IMAGE_ZOOM, old, imageZoom);
 		if (imageAoi == null) return;
 		setActiveRectangle(internalImageToComponent(imageAoi));
 	}
 	
 	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);
 	}
 	
 }