Javier Murillo me manda una mejora para la clase ImageUtils que publiqué en la entrada procesado de imágenes en Java. Es una alegría saber que otros desarrolladores trabajen con el código que publico, y que, como en este caso, se interesan por mejorarlo y reenviarlo. Gracias Javier!

PLAIN TEXT
JAVA:
  1. package es.gaea.utils;
  2.  
  3. import java.awt.RenderingHints;
  4. import java.awt.geom.AffineTransform;
  5. import java.awt.image.AffineTransformOp;
  6. import java.awt.image.BufferedImage;
  7. import java.io.File;
  8. import java.io.IOException;
  9. import javax.imageio.ImageIO;
  10. import org.apache.log4j.Logger;
  11.  
  12. /** Clase que implementa un procesador para imagenes y juguetear con ellas */
  13. public class ProcesadorImagenes {
  14.  
  15.         /** Logger de la clase */
  16.         private static Logger logger = Logger.getLogger(ProcesadorImagenes.class);
  17.        
  18.         /** Opciones de renderizado para las imagenes */
  19.         private RenderingHints opciones = new RenderingHints(null);
  20.        
  21.         /** Constructor de la clase */
  22.         public ProcesadorImagenes() {
  23.                
  24.                 // Cargo las opciones de renderizado que me apetezcan   
  25.                 opciones.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  26.                 opciones.put(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
  27.                 opciones.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
  28.                 opciones.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
  29.                 opciones.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
  30.                 opciones.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
  31.                 opciones.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
  32.                 opciones.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
  33.         }
  34.        
  35.         /** Devuelve la lista de formatos disponibles a leer por ImageIO       
  36.          * @return un array de strings con los mismos. 
  37.          */
  38.         public String[] dameFormatosUsables(){
  39.        
  40.                 return ImageIO.getReaderFormatNames();
  41.         }
  42.  
  43.  
  44.         /** Calcula el factor de escala minimo y en base a eso
  45.          * escala la imagen segun dicho factor. 
  46.         * @param nMaxWidth maximo tamaño para el ancho
  47.         * @param nMaxHeight nmaximo tamaño para el alto       
  48.         * @param imagen Imagen que vamos a escalar
  49.         * @return Devuelve la imagen escalada para poderla trastocar o null si hay error
  50.         */
  51.         public BufferedImage escalarATamanyo(final BufferedImage imagen,
  52.                         final int maximoAncho, final int maximoAlto) {
  53.  
  54.                 // Comprobacion de parametros
  55.                 if (imagen == null || maximoAlto == 0 || maximoAncho == 0) {
  56.                         return null;
  57.                 }
  58.                
  59.                 // Capturo ancho y alto de la imagen
  60.                 int anchoImagen = imagen.getHeight();
  61.                 int altoImagen = imagen.getWidth();
  62.  
  63.                 // Calculo la relacion entre anchos y altos de la imagen
  64.                 double escalaX = (double)maximoAncho / (double)anchoImagen;
  65.                 double escalaY = (double)maximoAlto / (double)altoImagen;
  66.                
  67.                 // Tomo como referencia el minimo de las escalas
  68.                 double fEscala = Math.min(escalaX, escalaY);
  69.                
  70.                 // Devuelvo el resultado de aplicar esa escala a la imagen
  71.                 return escalar(fEscala, imagen);
  72.         }
  73.  
  74.  
  75.         /** Escala una imagen en porcentaje.
  76.         * @param factorEscala ejemplo: factorEscala=0.6 (escala la imagen al 60%)
  77.         * @param srcImg una imagen BufferedImage
  78.         * @return un BufferedImage escalado
  79.         */
  80.         public BufferedImage escalar(final double factorEscala, final BufferedImage srcImg) {
  81.  
  82.                 // Comprobacion de parametros
  83.                 if (srcImg == null) {
  84.                         return null;
  85.                 }
  86.                
  87.                 // Compruebo escala nula
  88.                 if (factorEscala == 1 ) {
  89.  
  90.                         return srcImg;
  91.                 }
  92.                
  93.                 // La creo con esas opciones
  94.                 AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(factorEscala, factorEscala), opciones);
  95.                
  96.                 // Devuelve el resultado de aplicar el filro sobre la imagen
  97.                 return op.filter(srcImg, null);
  98.         }
  99.  
  100.        
  101.         /** Metodo que guarda una imagen en disco
  102.          * @param imagen Imagen a almacenar en disco
  103.          * @param rutaFichero Ruta de la imagen donde vamos a salvar la imagen
  104.          * @param formato Formato de la imagen al almacenarla en disco
  105.          * @return Booleano indicando si se consiguio salvar con exito la imagen
  106.          */
  107.         public boolean salvarImagen(final BufferedImage imagen,
  108.                         final String rutaFichero, final String formato) {
  109.                
  110.                 // Comprobacion de parametros
  111.                 if (imagen != null && rutaFichero != null && formato != null) {
  112.        
  113.                         try {
  114.                                 ImageIO.write( imagen, formato, new File( rutaFichero ));
  115.                                 return true;
  116.                         } catch (Exception e){
  117.                                 // Fallo al guardar
  118.                                 if (logger.isDebugEnabled() == true) {
  119.                                         String CODIGO_MENSAJE_ERROR_GUARDADO_FICHERO =
  120.                                                 "No se pudo guardar correctamente la imagen en " +
  121.                                                 rutaFichero;
  122.                                         logger.debug(CODIGO_MENSAJE_ERROR_GUARDADO_FICHERO);
  123.                                 }
  124.                                 return false;
  125.                         }
  126.                 } else {
  127.                         // Fallo en los parametros
  128.                         return false;
  129.                 }
  130.         }
  131.  
  132.  
  133.         /** Metodo principal de la clase. Usado como prueba
  134.          * @param args Argumentos del metodo
  135.          */
  136.         public static void main(String args[]) {
  137.        
  138.                 // Variables locales
  139.                 BufferedImage imagen;
  140.                
  141.                 try {
  142.                         imagen = ImageIO.read( new File( "prueba.jpg" ) );
  143.                         ProcesadorImagenes pi = new ProcesadorImagenes();
  144.                        
  145.                         // Escalo algunas imagenes como pruebas
  146.                         BufferedImage imagen800_600 = pi.escalarATamanyo(imagen,800, 600);
  147.                         BufferedImage imagenSnap_Shot = pi.escalarATamanyo(imagen,96, 96);
  148.                         BufferedImage imagenMediana = pi.escalarATamanyo(imagen,500, 500);
  149.                        
  150.                         //      Las salvo en disco
  151.                         pi.salvarImagen(imagen800_600,"imagenG.jpg","jpg");
  152.                         pi.salvarImagen(imagenSnap_Shot,"imagenP.jpg","jpg");
  153.                         pi.salvarImagen(imagenSnap_Shot,"imagenE.png","PNG");
  154.                         pi.salvarImagen(imagenMediana,"imagenA.gif","gif");
  155.                        
  156.                         // Extraigo la lista de formatos capaces de leer
  157.                         String[] formatos = pi.dameFormatosUsables();
  158.                        
  159.                         // los voy mostrando
  160.                         for (int i=0; i <formatos.length; i++) {
  161.                                 System.out.println(formatos[i].toString());
  162.                         }
  163.                        
  164.                         // Final del metodo con exito
  165.                         System.exit(0);
  166.                 } catch (IOException e) {
  167.                         e.printStackTrace();
  168.                 }
  169.         }
  170. }