import java.awt.*;
import java.awt.color.*;
import java.awt.image.*;
import java.awt.geom.*;

/**
 * Image relevee par le CCD
 * @author Delphine Dard
 */
public class CCDImage extends Canvas {
    /** Image dessinée */
    public Image image;
    /** largeur de l'image */
    public int width = 41;
    /** hauteur de l'image */
    public int height = 41;
    /** Tableau des pixels de l'image */
    public int pixels[];

    /** Intensite minimum */
    public double minimum;
    /** Intensite maximum */
    public double maximum;

    /**Distance du bord en X */
    public int bordX = 60; //a la bonne echelle
    /**Distance du bord en Y */
    public int bordY = 20; // a la bonne echelle

    /** modele de couleur pour le noir et blanc */
    public ColorModel colorModel;

    /** Image pour le double buffer */
    public Image buffer;

    /** */
    public int echelleCouleurs[];
    /** Image de l'echelle degradee des couleurs */
    public Image echelle;

    
    /**
     * Constructeur
     */
    public CCDImage(){
	super();
	// Create a grayscale color model.
	ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_GRAY);
	int bits[] = new int[] {8};
	colorModel = new ComponentColorModel(colorSpace, 
					     bits, 
					     false, 
					     false,
					     Transparency.OPAQUE,
					     DataBuffer.TYPE_BYTE);
	this.pixels = null;
	setNewImage(new int[0]);
	Dimension d = getSize();
	buffer = createImage(d.width,d.height);
	
	echelleCouleurs = new int[41];
	for (int i=0; i<echelleCouleurs.length; i++){
	    echelleCouleurs[i] = i*7;
	}
	echelle = createImage(new MemoryImageSource(41, 
						  1,
						  colorModel,
						  echelleCouleurs, 
						  0, 
						  41));
    }


    /** 
     * Concstructeur
     * @param pix tableau des pixels
     */
    public CCDImage(int [] pix){
	this();
	this.pixels = new int[41*41];
	setNewImage(pixels);
    }

    /**
     * Donne une nouvelle image
     * @param pix le tableau des pixels
     */
    public void setNewImage(int[] pix){
	if (pix.length != 0) {
	    maximum = pix[0];
	    minimum = pix[0];
	    for (int i=0; i < pix.length; i++){
		if (pix[i] > maximum)
		    maximum = pix[i];
		if (pix[i] < minimum)
		    minimum = pix[i];
	    }
	    double difference = maximum-minimum;
	    double echelle;
	    if (difference != 0)
		echelle = 256/difference;
	    else
		echelle = 0;
	    for (int i=0; i < pix.length; i++){
		if (pixels == null)
		    pixels = new int[41*41];
		this.pixels[i] = new Double((pix[i]-minimum)*echelle).intValue();  
	    }
	    image = createImage(new MemoryImageSource(width, 
						      height,
						      colorModel,
						      pixels, 
						      0, 
						      width));
	}
    }


    /**
     * Réécrit update pour le double buffer
     * @param g le graphique a dessiner
     */
    public void update(Graphics g){
	paint(g);
    }

    /**
     * Dessine l'image
     * @param g le graphe a dessiner
     */
    public void paint(Graphics g){
	Dimension d = getSize();
	if (buffer == null)
	    buffer = createImage(d.width, d.height);
	Graphics2D bufferGraphic = (Graphics2D)buffer.getGraphics();

	bufferGraphic.setColor(Color.white);
	bufferGraphic.clearRect(0, 0, d.width, d.height);

	bufferGraphic.setColor(Color.black);

	AffineTransform affineTransform = bufferGraphic.getTransform();
	bufferGraphic.transform(AffineTransform.getScaleInstance(4,4));
	bufferGraphic.drawImage(image, bordX/4, bordY/4, this);

	bufferGraphic.drawImage(echelle, bordX/4, bordY/4+41+2, this);

	bufferGraphic.setTransform(affineTransform);

	bufferGraphic.setColor(Color.blue);
	float[] dash = {5,5};
	bufferGraphic.setStroke(new BasicStroke(2, 
						BasicStroke.CAP_ROUND, 
						BasicStroke.JOIN_ROUND, 
						1, 
						dash,
						1));
	//c'est pour la ligne 21 
	//mais comme on part du haut, c'est 20
	bufferGraphic.drawLine(bordX, bordY+(20*4), bordX+(41*4), bordY+(20*4));
	bufferGraphic.setStroke(new BasicStroke());

	bufferGraphic.drawString("21", bordX-(5*4), bordY+(21*4));
	bufferGraphic.setColor(Color.black);
	bufferGraphic.drawString("  1", bordX-(5*4), bordY+(41*4));
	bufferGraphic.drawString("41", bordX-(5*4), bordY);
	bufferGraphic.drawRect(bordX,bordY,41*4,41*4);

	bufferGraphic.drawRect(bordX, bordY+41*4+8, 41*4, 4);
	String min = String.valueOf(new Double(minimum).intValue());
	String max = String.valueOf(new Double(maximum).intValue());
	bufferGraphic.drawString(min, bordX, bordY+41*4+25);
	bufferGraphic.drawString(max, bordX+41*4, bordY+41*4+25);
	
	g.drawImage(buffer,0,0,this);
    }
}