Manipulacion de imagenes en java

En esta oportunidad les traigo una pequeña clase que permite realizar manipulaciones básicas con archivos de imagen, las acciones son:

• Abrir un archivo de imagen (*.jpg.*.png) y colocarla en memoria, para después pintarla en un jpanel
• Crear un archivo de imagen y colocarla en memoria
• Guardar un archivo de imagen que se tenga en memoria en el el disco duro

La aplicación funciona de la siguiente form, todos los métodos necesarios se encuentran en la clase "metodos.java"el cual hace uso de la clase "mipanel.java" para pintar la imagen que se encuentra en memoria , todos estos métodos son invocados desde la clase interfaz

Para realizar esta aplicación, necesitamos crear un nuevo proyecto en netbeans y añadir los siguientes objetos

2.- Se crea una nueva clase "metodos.java"

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class metodos {
    private BufferedImage _image = null;    
    private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
    
    /**
     * Constructor de clase
     */
    public metodos(){}      
    
    /**
     * dada una direccion fisica de un archivo de imagen,
     * coloca esta en el objeto BufferedImage, o sea en memoria 
     * @param  url
     */
    public void cargar_imagen_en_buffer(URL _url){         
        //se llena el buffer con la imagen        
            try {                
                _image = ImageIO.read(_url);
            } catch (IOException ex) {
                System.err.println( ex.getMessage() );
            }               
    }
    
    /* retorna el objeto almacenado en memoria */
   public BufferedImage Obtener_imagen_de_Buffer(){       
        return _image;
   }
    
   /* crea una imagen en el BufferedImage y la pinta en el JPanel */
   public void crear_imagen(JPanel p){
    //crea una imagen 400x300 con pixels de 8 bits en RGB. 
    this._image = new BufferedImage(400, 300, BufferedImage.TYPE_INT_RGB);
    this._image.createGraphics();
    Graphics2D g = (Graphics2D)this._image.getGraphics();
    // pintamos una imagen
    g.setColor(Color.RED);
    g.fillRect(0, 0, 400, 100);
    g.setColor(Color.YELLOW);
    g.fillRect(0, 100, 400, 100);
    g.setColor(Color.GREEN);
    g.fillRect(0, 200, 400, 100);
    
    //añadimos al JPanel, con las dimensiones del contenedor, no de la imagen
    p.add(new mipanel(this._image, p.getSize()));
    p.setVisible(true);                
    p.repaint();     
   }
   
   /**
    * crea un archivo de imagen desde el BufferedImage dada la direccion fisica 
    * @param  String f
    */
   public void guardar_imagen(String f){
        try {
            //se extrae el fomato de la cadena "f" que contiene la direccion
            String formato = (f.endsWith(".jpg")) ? "jpg" : "png";   
            //ImageIO.write(_image, "jpg", new File("e:/carpeta/imagen2.jpg"));
            ImageIO.write(_image, formato, new File(f));
 } catch (IOException e) {            
            System.out.println("Error al crear el archivo");
 }
   }
   
   public void Guardar_Dialogo(){
       JFileChooser fileChooser = new JFileChooser();       
       fileChooser.setFileFilter(filter);
       int result = fileChooser.showSaveDialog(null);       
       if ( result == JFileChooser.APPROVE_OPTION ){ 
                //se obtiene la direccion donde se guardara la imagen
                String url = fileChooser.getSelectedFile().toString();
                //String namefile = fileChooser.getSelectedFile().getName();                                            
                System.out.println("url: " + url);                                        
                //Se guarda la imagen
                guardar_imagen(url);            
        }
   }
   
    /**
     * Metodo que muestra una ventana de dialgo para añadir "archivo de imagen" en memoria     
     * @param JPanel
     */
    public void Abrir_Dialogo(JPanel p){
       JFileChooser fileChooser = new JFileChooser();       
       fileChooser.setFileFilter(filter);
       int result = fileChooser.showOpenDialog(null);  
       if ( result == JFileChooser.APPROVE_OPTION ){
            try {           
                //se asigna a "url" el archivo de imagen seleccionado
                URL url = fileChooser.getSelectedFile().toURL();                 
                //se lo coloca en memoria
                cargar_imagen_en_buffer(url);                            
                //se añade al contenedor
                p.add(new mipanel(Obtener_imagen_de_Buffer(), p.getSize()));
                p.setVisible(true);
                p.repaint();                           
            } 
            catch (IOException ex) {                
                System.err.println( ex.getMessage() );
            } 
        }
    }   
    
}

Esta clase consta de los metodos cargar_imagen_en_buffer(URL _url), el cual recibe la direccion fisica del archivo de imagen que se encuentra en el disco duro, luego utilizando el metodo read de la clase ImageIO, se coloca la imagen en memoria asignando a la variable _image de tipo BufferedImage.

El método Obtener_imagen_de_Buffer(). retorna de memoria la imagen almacenada en la variable _image.

El método crear_imagen(JPanel p), haciendo uso de la clase BufferedImage, crea una imagen vacía que nos servirá de superficie para luego pintarla con Graphics2D , en el ejemplo se añade unos rectángulos de colores. Después de creada la imagen en memoria, se pinta esta utilizando la clase "mipanel.java" y luego se añade al contenedor JPanel para mostrala en pantalla

Este método guardar_imagen(String f), dada la dirección física donde se desea guardar la imagen, ademas como su nombre y extensión, escribe en el disco duro haciendo uso de la clase ImageIO y el metod owrite

Los métodos Guardar_Dialogo() y Abrir_Dialogo(JPanel p),  nos permiten abrir una ventana de dialogo para Abrir/Guardar los archivos de imagen

3.- La clase que se utiliza para pintar las imágenes es la clase "mipanel.java", esta clase dada un objeto del tipo BufferedImage, sobreescribe el metod paint() para dibujar la imagen en el JPanel.

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class mipanel extends JPanel{
    BufferedImage _image;
    
    public mipanel(){}
    /** coloca la imagen que se encuentra en el Buffer en el objeto JPanel
     * redimensiona la imagen para que encaje en las dimensiones del Jpanel
     * pero la imagen que se encuentra en el Buffer, preserva el tamaño original
     * @param imagen BufferedImage
     * @param d Dimension
     */
    public mipanel( BufferedImage imagen, Dimension d ){    
        this._image = imagen;
        this.setSize(d);
    }    
  
    @Override    
    public void paint(Graphics g){            
        ImageIcon imagenFondo = new ImageIcon(_image);                     
        g.drawImage(imagenFondo.getImage(),0,0,getWidth(),getHeight(), null);        
        setOpaque(false);
        super.paintComponent(g);
    }    
}

4.- el uso en la interfaz se realiza de la siguiente forma:

Aquí el vídeo para comprender mejor:

estas operaciones son basicas para manipular imagenes en java, pero claro java permite manipular mucho mas los archivos de imagen, pero eso sera en otra ocasión.

Enlace actualizado 20-05-2013
Proyecto netbeans 6.9