package es.gaea.utils;
 
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import org.apache.log4j.Logger;
 
/** Clase que implementa un procesador para imagenes y juguetear con ellas */
public class ProcesadorImagenes {
 
	/** Logger de la clase */
	private static Logger logger = Logger.getLogger(ProcesadorImagenes.class);
 
	/** Opciones de renderizado para las imagenes */ 
	private RenderingHints opciones = new RenderingHints(null);
 
	/** Constructor de la clase */
	public ProcesadorImagenes() {
 
		// Cargo las opciones de renderizado que me apetezcan	
		opciones.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		opciones.put(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
		opciones.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
		opciones.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
		opciones.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
		opciones.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
		opciones.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
		opciones.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
	}
 
	/** Devuelve la lista de formatos disponibles a leer por ImageIO	
	 * @return un array de strings con los mismos.	
	 */
	public String[] dameFormatosUsables(){
 
		return ImageIO.getReaderFormatNames();
	}
 
 
	/** Calcula el factor de escala minimo y en base a eso 
	 * escala la imagen segun dicho factor.	
	* @param nMaxWidth maximo tamaño para el ancho
	* @param nMaxHeight nmaximo tamaño para el alto	
	* @param imagen Imagen que vamos a escalar
	* @return Devuelve la imagen escalada para poderla trastocar o null si hay error
	*/
	public BufferedImage escalarATamanyo(final BufferedImage imagen,
			final int maximoAncho, final int maximoAlto) {
 
		// Comprobacion de parametros
		if (imagen == null || maximoAlto == 0 || maximoAncho == 0) {
			return null;
		}
 
		// Capturo ancho y alto de la imagen 
		int anchoImagen = imagen.getHeight();
		int altoImagen = imagen.getWidth();
 
		// Calculo la relacion entre anchos y altos de la imagen
		double escalaX = (double)maximoAncho / (double)anchoImagen;
		double escalaY = (double)maximoAlto / (double)altoImagen;
 
		// Tomo como referencia el minimo de las escalas
		double fEscala = Math.min(escalaX, escalaY);
 
		// Devuelvo el resultado de aplicar esa escala a la imagen
		return escalar(fEscala, imagen);
	}
 
 
	/** Escala una imagen en porcentaje.
	* @param factorEscala ejemplo: factorEscala=0.6 (escala la imagen al 60%)
	* @param srcImg una imagen BufferedImage
	* @return un BufferedImage escalado
	*/
	public BufferedImage escalar(final double factorEscala, final BufferedImage srcImg) {
 
		// Comprobacion de parametros
		if (srcImg == null) {
			return null;
		}
 
		// Compruebo escala nula
		if (factorEscala == 1 ) {
 
			return srcImg;
		}
 
		// La creo con esas opciones
		AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(factorEscala, factorEscala), opciones);
 
		// Devuelve el resultado de aplicar el filro sobre la imagen
		return op.filter(srcImg, null);
	}
 
 
	/** Metodo que guarda una imagen en disco 
	 * @param imagen Imagen a almacenar en disco
	 * @param rutaFichero Ruta de la imagen donde vamos a salvar la imagen
	 * @param formato Formato de la imagen al almacenarla en disco
	 * @return Booleano indicando si se consiguio salvar con exito la imagen
	 */
	public boolean salvarImagen(final BufferedImage imagen, 
			final String rutaFichero, final String formato) {
 
		// Comprobacion de parametros
		if (imagen != null && rutaFichero != null && formato != null) {
 
			try {
				ImageIO.write( imagen, formato, new File( rutaFichero ));
				return true;
			} catch (Exception e){
				// Fallo al guardar
				if (logger.isDebugEnabled() == true) {
					String CODIGO_MENSAJE_ERROR_GUARDADO_FICHERO = 
						"No se pudo guardar correctamente la imagen en " + 
						rutaFichero;
					logger.debug(CODIGO_MENSAJE_ERROR_GUARDADO_FICHERO);
				}
				return false;
			}
		} else {
			// Fallo en los parametros 
			return false;
		}
	}
 
 
	/** Metodo principal de la clase. Usado como prueba
	 * @param args Argumentos del metodo
	 */
	public static void main(String args[]) {
 
		// Variables locales
		BufferedImage imagen;
 
		try {
			imagen = ImageIO.read( new File( "prueba.jpg" ) );
			ProcesadorImagenes pi = new ProcesadorImagenes();
 
			// Escalo algunas imagenes como pruebas
			BufferedImage imagen800_600 = pi.escalarATamanyo(imagen,800, 600);
			BufferedImage imagenSnap_Shot = pi.escalarATamanyo(imagen,96, 96);
			BufferedImage imagenMediana = pi.escalarATamanyo(imagen,500, 500);
 
			//	Las salvo en disco
			pi.salvarImagen(imagen800_600,"imagenG.jpg","jpg");
			pi.salvarImagen(imagenSnap_Shot,"imagenP.jpg","jpg");
			pi.salvarImagen(imagenSnap_Shot,"imagenE.png","PNG");
			pi.salvarImagen(imagenMediana,"imagenA.gif","gif");
 
			// Extraigo la lista de formatos capaces de leer
			String[] formatos = pi.dameFormatosUsables();
 
			// los voy mostrando
			for (int i=0; i < formatos.length; i++) {
				System.out.println(formatos[i].toString());
			}
 
			// Final del metodo con exito
			System.exit(0);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

/*
 * ImageUtils.java
 *
 * Created on 20 de julio de 2005, 11:47
 * Resizes jpeg image files on your file system.
 * Uses the com.sun.image.codec.jpeg package shipped
 * by Sun with Java 2 Standard Edition.
 *
 * @author Randy Belknap
 * @revision Alejandro Sánchez Marcos
 * se aprovecha la nueva clase ImageIO de 1.4
 * y se añaden algunos métodos nuevos 
 */
 
package com.electroduendes.util.image;
 
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import org.apache.log4j.Logger;
 
/**
 
 */
public class ImageUtils {
    static Logger logger = Logger.getLogger(ImageUtils.class);
    /*
     * devuelve la lista de formatos disponibles a leer por ImageIO
     * @return un array de strings con los mismos.
     */
    public static String[] getAvailableFormats(){
        return ImageIO.getReaderFormatNames();
    }
 
    /*
     * devuelve una imagen (buffer) en función de la ruta de un archivo
     * mejoras
     * @param la ruta del archivo con su nombre
     * @return BufferedImage la imagen en el buffer
     */
    public static BufferedImage loadBufferedImage(String fileName) {
        BufferedImage image = null;
        try {
            /*FileInputStream fis = new FileInputStream(fileName);JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(fis);bi = decoder.decodeAsBufferedImage();fis.close();*/
            // MAS RAPIDO a partir de 1.4
            image = ImageIO.read( new File( fileName ) );
        }
        catch (Exception e) {
            logger.debug("error al intentar leer la imágen");
            return null;
        }
        return image;
 
    }
    /**
     * comprueba que la imágen tiene un mínimo en pixels
     * width y height tienen que tener un tamaño igual o mayor que el pasado
     * como argumento
     *
     * @param w ancho mínimo
     * @param h alto mínimo
     * @return true o false
     *
     */
    public static boolean isGreaterThanMinSize(int w, int h, BufferedImage imgSrc){
        int nHeight = imgSrc.getHeight();
        int nWidth = imgSrc.getWidth();
        if ((nHeight<h ) || (nWidth<w)){
            return false;
        } else {
            return true;
        }
    }
 
    /*
     * calcula el factor de escala mínimo y en base a eso escala la imagen 
     * según el dicho factor. 
     * @param nMaxWidth minimo tamaño para el ancho
     * @param nMaxHeight minimo tamaño para el alto
     * @param imgSrc la imágen 
     */
    public static BufferedImage scaleToSize(int nMaxWidth, int nMaxHeight, BufferedImage imgSrc) {
        int nHeight = imgSrc.getHeight();
        int nWidth = imgSrc.getWidth();
        double scaleX = (double)nMaxWidth / (double)nWidth;
        double scaleY = (double)nMaxHeight / (double)nHeight;
        double fScale = Math.min(scaleX, scaleY);
        return scale(fScale, imgSrc);
    }
 
    /*
     * escala una imagen en porcentaje.
     * @param scale ejemplo: scale=0.6 (escala la imágen al 60%)
     * @param srcImg una imagen BufferedImage
     * @return un BufferedImage escalado
     */
    public static BufferedImage scale(double scale, BufferedImage srcImg) {
        if (scale == 1 ) {
            return srcImg;
        }
        AffineTransformOp op = new AffineTransformOp
        (AffineTransform.getScaleInstance(scale, scale), null);
 
        return op.filter(srcImg, null);
 
    }
 
    public static void saveImageToDisk(BufferedImage bi, String str, String format) {
        if (bi != null && str != null) {
 
            // más rápido con ImageIO
            try {
                ImageIO.write( bi, format /* formato */, new File( str ) /* destino */ );
            } catch (Exception e){}
        }
    }
 
 
    public static void main(String args[]) {
        if(args.length != 3){usage();}
        System.out.println(args[0]);
        BufferedImage bImg = loadBufferedImage(args[0]);
        System.out.println(bImg);
        BufferedImage bImgEscaladaG = scaleToSize(800, 600, bImg);
        BufferedImage bImgEscaladaP = scaleToSize(320, 200, bImg);
 
        saveImageToDisk(bImgEscaladaG, args[1],"JPEG");
        saveImageToDisk(bImgEscaladaP, args[2],"JPEG");
        System.exit(0);
    }
 
    public static void usage(){
        System.out.println("usage: java ImageUtils archivo_original imagen_grande imagen_pequeña ");
        System.exit(1);
    }
 
}