Convertir PDF a JPG en Java

Ahora presento un pequeño codigo para convertir documentos PDF a imagenes (*:JPG), para esta aplicacion, utilize las siguientes librerias:


- pdfbox-1.1.0 : Web: http://pdfbox.apache.org/download.html
- fontbox-1.1.0: La misma que la de arriba, solo hay que fijarse bien
- commons-logging-1.1.1 : Web: - http://commons.apache.org/logging/download_logging.cgi

Para continuar y ejecutar este proyecto, necesitas descargar esas librerias e instalarlas en Netbeans o en el IDe que utilices para programar, para instalar nuevas librerias a Netbeans, clic aqui.

Proyecto: Esta dividido en dos metodos y se ejecuta desde consola

Primer metodo: Este metodo convierte cada hoja del archivo PDF en imagenes con el formato JPG, recibe como parametro de entrada el "path" o sea la ruta de donde leera el archivo PDF, ejemplo: "e:/temppdf/", el segundo parametro es el "pdf", el nombre del archivo a convertir, ej: "Basilea.pdf".

/* Convierte el documento PDF a imagen con un tamaño grande*/
    public void Convertir_1(String path, String pdf){
    try {     
        PDDocument document = null;
        //se carga el documento
        document = PDDocument.load(new File(path + pdf));
        //se obtiene el numero de paginas del PDF
        int numero_paginas = document.getNumberOfPages();
        System.out.println("texto: " + document.getNumberOfPages());
        //Se capturan todas las paginas
        List pages = document.getDocumentCatalog().getAllPages();
        //un ciclo repetitivo para crear todas las imagenes
        for(int i=0; i<=numero_paginas-1;i++){
            System.out.println( "creando imagen - " + i);
            //se obtiene la pagina "i" de n paginas
            PDPage page = (PDPage)pages.get( i );
            //se convierte la hoja pdf a imagen y se coloca en memoria
            BufferedImage image = page.convertToImage();
            // se escribe a imagen en disco
            ImageIO.write(image, "jpg", new File( path + "tmp_" + i + ".jpg"));
            System.out.println( "imagen [" + i + "] creada");
        }
        document.close();//cerramos el pdf
    } catch (IOException ex) {
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }  
    }

Este metodo guarda las imagenes convertidas en la misma carpeta donde esta el PDF, lee la cantidad de paginas que tiene el archivo y utilizando un ciclo FOR, va convirtiendo y guardando pagina por pagina, este metodo crea las imagenes de un tamaño grande

Segundo metodo: Este metodo convierte cada hoja del archivo PDF en imagenes con el formato JPG, pero antes obtiene el tamaño de la hoja del archivo PDF y "escala" la imagen capturada por el API,  recibe como parametro de entrada el "path" o sea la ruta de donde leera el archivo PDF, ejemplo: "e:/temppdf/", el segundo parametro es el "pdf", el nombre del archivo a convertir, ej: "Basilea.pdf".

/* Convierte el documento PDF a Imagen, escalando el archivo al
      tamaño de las hojas del PDF*/
    public void Convertir_2(String path, String pdf){
    try {
        PDDocument document = null;
        //se carga el documento
        document = PDDocument.load(new File(path + pdf));
        //se obtiene el numero de paginas del PDF
        int numero_paginas = document.getNumberOfPages();
        System.out.println("texto: " + document.getNumberOfPages());  
        //Se capturan todas las paginas
        List pages = document.getDocumentCatalog().getAllPages();
        //un ciclo repetitivo para crear todas las imagenes
        for(int i=0; i<=numero_paginas-1;i++){
            System.out.println( "creando imagen - " + i);
            //se obtiene la pagina "i" de n paginas
            PDPage page = (PDPage)pages.get( i );
            //se convierte la hoja pdf a imagen y se coloca en memoria
            BufferedImage image = page.convertToImage();
            //ancho y alto de la pagina pdf
            int w = (int) document.getPageFormat(i).getWidth();
            int h = (int) document.getPageFormat(i).getHeight();
            //se crea una nueva imagen en memoria con el tamaño de la hoja pdf
            BufferedImage escala = new BufferedImage(w,h, BufferedImage.TYPE_INT_RGB);
            Graphics2D graphics2D = escala.createGraphics(); 
            graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
            //se añade la imagen
            graphics2D.drawImage(image, 0, 0, w, h, null);
            // se escribe a imagen en disco
            ImageIO.write(escala, "jpg", new File( path + "tmp_e" + i + ".jpg"));
            System.out.println( "imagen [" + i + "] creada");
        }
        document.close();//cerramos el pdf
    } catch (IOException ex) {
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }  
    }

Al  igual que el primer metodo, utiliza un ciclo FOR para recorrer todo el documento.

Con unos cuantos cambios al codigo, puede convertirse el archivo PDF a cualquier tamaño, por ejemplo:

El codigo mas ejemplos en el siguiente enlace

continue reading

Graficas con java y JFreeChart

En esta ocasion les presento un codigo para crear graficas en java con la libreria OpenSource jFreeChart, esta libreria nos permite crear todo tipo de graficas como se puede ver en la imagen de abajo

Puedes descargarte la libreria desde la pagina del proyecto http://www.jfree.org/jfreechart/,

INSTALACION
1. Una vez que descargaste el archivo ZIP, debes descomprimirlo en algun lugar del disco duro, por ejemplo en c:/java/librerias/jfreechart-1.0.13
2. Con netbeans abierto, dirigete a TOOLS - LIBRARIES o a HERRAMIENTAS - LIBRERIAS.
3. En la ventana que aparece le das a "new library.." y te mostrara una pequeña ventana, en esa ventana le das un nombre a la libreria para poder reconocerla despues, yo le puse "graficos", tu puedes colocar el nombre que desees.

4. Presionas el boton AÑADIR JAR y buscas los siguientes archivos jfreechart-1.0.13 y jcommon-1.0.16 y los añades uno por uno, despues presionas OK y listo

EL PROYECTO EN NETBEANS
1. Crea un nuevo proyecto en netbeans llamalo "graficas", luego debes añadir las librerias al proyecto, clic derecho sobre la carpeta "libraries" como se ve en la imagen y escoges Add Library, en la ventana que aparece, busca la libreria, en mi caso la llame GRAFICAS, asi que busco ese nombre y le digo Add Library

Si seguiste todos los pasos, debes tener algo como la imagen de abajo:

2. Ahora crea un nuevo JFrame en el proyecto, añade un JPanel: CONTENEDOR, dos JButton CREAR Y GUARDAR y situalos como se ve en la imagen:

3. Crea una nueva clase, "Grafico.java" y añade el siguiente codigo:

import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.*;
import java.io.*;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import org.jfree.chart.ChartUtilities;
import org.jfree.data.category.DefaultCategoryDataset;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class grafico {
    
    private BufferedImage _image ;//para la imagen en memoria
    private JFreeChart grafico ;// el grafico
    private Dimension d;//dimension del grafico
    
    public grafico(){
    }
    /* Crea el grafico */
    public void crear_grafico_de_barras(Dimension d, int[] v, String[] arg1, String arg2[],String[] data){
        this.d= d;          
        DefaultCategoryDataset dataset = new DefaultCategoryDataset();
        //se llenan los datos
        for(int i=0; i<=v.length-1;i++){
            dataset.setValue(v[i], arg1[i], arg2[i]);
        }      
        //se crea el grafico
        grafico = ChartFactory.createBarChart3D(data[0], data[1], data[2], dataset, PlotOrientation.HORIZONTAL , true, false, true);
        //se coloca el grafico en memoria
        _image = grafico.createBufferedImage(this.d.width,this.d.height);
        System.err.println("grafico creado");     
    }
    
    /* carga la imagen que esta en memoria en el objeto jLabel */
    public void cargar_grafico(JLabel lb){
        ImageIcon imagenFondo = new ImageIcon(_image);  
        lb.setIcon(imagenFondo);
        lb.repaint();
    }  
    /* presenta la ventana de dialogo "guardar" y salva el grafico generado en JPG */
     public void Guardar(){
       JFileChooser fileChooser = new JFileChooser();
       int result = fileChooser.showSaveDialog(null);
       if ( result == JFileChooser.APPROVE_OPTION ){ 
            try {
                //se obtiene la direccion donde se guardara la imagen
                String url = fileChooser.getSelectedFile().toString();
                //Se guarda la imagen
                ChartUtilities.saveChartAsJPEG(new File(url + ".jpg"), grafico, d.width, d.height);
            } catch (IOException ex) {
                Logger.getLogger(grafico.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
   }   
}

4. Como siguiente paso, debes implementar esta clase en el JFrame, el codigo para los JButton es el siguiente

private void CREARActionPerformed(java.awt.event.ActionEvent evt) {
        //tamaño del grafico
        Dimension d = CONTENEDOR.getSize();//toma el tamaño del contenedor
        //se crean los datos
        int[] valores = {1000,2011,3030,1569,2688,4587}; 
        String[] arg1 = {"Enero","Febrero","Marzo","Enero","Febrero","Marzo"};
        String[] arg2 = {"Visitas","Visitas","Visitas","Hits","Hits","Hits"};
        //titulo, lateral 1, lateral 2
        String[] data = {"Blog de Mouse","Primer Trimestre","Visitas"};
        //se crea el grafico
        migrafico.crear_grafico_de_barras(d, valores, arg2, arg1, data);
        //se crea un jlabel para colocar el grafico
        JLabel j = new JLabel();
        j.setBounds(0, 0, d.width, d.height);
        //se carga el grafico de memoria
        migrafico.cargar_grafico(j);
        //se añade al contenedor
        CONTENEDOR.add(j);
        this.repaint();
}

private void GUARDARActionPerformed(java.awt.event.ActionEvent evt) {
       migrafico.Guardar();
}

/**
 * @param args the command line arguments
*/
grafico migrafico = new grafico();

La forma en que se pasa los parametros a la clase "graficos.java", es mediante el uso de Array, se utilizan 4 array, un array de enteros para pasar los valores numericos, otros dos array de tipo String arg1 y arg2, donde se coloca los valores sobre los cuales se llevara a cabo la comparacion y agrupacion de datos, estos tres primeros array, deben tener la misma longitud, por ultimo un array de tipo String de  3 elementos en el cual se coloca, primero el titulo, seguidos del texto que se coloca en los lateras del grafico; por ejemplo, 

int[] valores = {1000,2011,3030,1569,2688,4587};, se le esta pasando un array con 6 elementos, entonces los arrays arg1 y arg2 , deben tener tambien seis elementos.

En el ejemplo de abajo, tenemos el mismo grafico, con los mismos datos, pero con diferente agrupacion, el primero agrupado entre "visitas y hits"  y el segundo entre "meses", esto solamente se hizo, inviertiendo "arg1"  y "arg2" en la llamada al metodo crear_grafico_de_barras();

continue reading

Crear PDF desde java

En esta ocasion crearemos un archivo PDF desde java utilizando el IDE netbeans 6.0, y la libreria ITEXT. pero y ¿que es Itext?

Segun SantaWikipedia:

iText es una biblioteca Open Source para crear y manipular archivos PDF, RTF, y HTML en Java. Fue escrita por Bruno Lowagie, Paulo Soares, y otros; está distribuida bajo la Mozilla Public License con la LGPL como licencia alternativa.

El mismo documento puede ser exportado en múltiples formatos, o múltiples instancias del mismo formato. Los datos pueden ser escritos a un fichero o, por ejemplo, desde un servlet a un navegador web.

Más recientemente, ha sido extendida a una biblioteca PDF de propósito general, capaz de rellenar formularios, mover páginas de un PDF a otro, y otras cosas. Estas extensiones son a menudo mutuamente excluyentes. Una clase te permite rellenar en formularios, mientras una clase diferente e incompatible hace posible copiar páginas de un PDF a otro.

Basta de teoria, vamos a lo que interesa que es el codigo, lo que debes hacer primero claro esta, es bajarte esa biblioteca desde este enlace, la ultima version es la itext 5.0.2, baja el *.jar o si lo deseas puedes bajarte todo las fuentes mas documentacion incluida, obvio que en ingles. Una vez que bajaste la libreria, debes instalar esta en Netbeans, si no sabes como, te recomiendo te des una vuelta por aqui "instalar nuevas librerias a netbeans".

El proyecto:

1.- Crea un nuevo proyecto en netbeans, dale un nombre, para este ejemplo "javapdf", añade un JFrame:editor, y coloca los objetos y sus respectivos nombres como se ve en la captura de pantalla:

2. Crea una nueva clase "javapdf.java" y añade el siguiente codigo:

package javapdf;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;
//archivos
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
//librerias ajenas a itext
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class javapdf {
   
    private File ruta_destino=null;
    
    public javapdf(){    
    }
    
    /* metodo que hace uso de la clase itext para manipular archivos PDF*/
    public void crear_PDF(String t, String a, String s, String k, String c){
        //abre ventana de dialogo "guardar"
        Colocar_Destino();
        //si destino es diferente de null
        if(this.ruta_destino!=null){
            try {
                // se crea instancia del documento
                Document mipdf = new Document();
                // se establece una instancia a un documento pdf
                PdfWriter.getInstance(mipdf, new FileOutputStream(this.ruta_destino + ".pdf"));
                mipdf.open();// se abre el documento
                mipdf.addTitle(t); // se añade el titulo
                mipdf.addAuthor(a); // se añade el autor del documento
                mipdf.addSubject(s); //se añade el asunto del documento
                mipdf.addKeywords(k); //Se agregan palabras claves  
                mipdf.add(new Paragraph(c)); // se añade el contendio del PDF
                mipdf.close(); //se cierra el PDF&
                JOptionPane.showMessageDialog(null,"Documento PDF creado");
            } catch (DocumentException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (FileNotFoundException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }            
        }        
    }
    /* abre la ventana de dialogo GUARDAR*/
    public void Colocar_Destino(){
       FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo PDF","pdf","PDF");
       JFileChooser fileChooser = new JFileChooser();       
       fileChooser.setFileFilter(filter);
       int result = fileChooser.showSaveDialog(null);
       if ( result == JFileChooser.APPROVE_OPTION ){   
           this.ruta_destino = fileChooser.getSelectedFile().getAbsoluteFile();
        }
    }    
}

El codigo de la clase ya esta comentado y creo que es bastante obvio. para un usuario intermedio de java sera de facil comprension.

3. Para terminar, debes implementar esta clase en el JFrame, asi:

y eso es todo, te crea el PDF como se ve en la captura de pantalla

continue reading

[Respuesta] Cerrar JOptionPane automaticamente

Bueno tratando de dar una respuesta "aceptable" a la pregunta de visitante a mi blog, que tenia o tiene la duda de "como cerrar automaticamente un JOptionPane transcurrido un cierto tiempo",  problema que me parecio sencillo al principio, controlar el tiempo no habia problema, con un Timer basta y sobra, pero despues de investigar un poco no encontre un comando en java para cerrar el JOptionPabe, el hide() no me funciono, el dispose() no existe para esta clase, el setvisible() no jala, asi que quedandome sin opciones, recorde un consejo de un viejo amigo, "cuando tengas un problema que al parecer no tiene solucion, da un paso atras para ampliar tu vision y asi encontraras la solucion mas facilmente",asi que ampliando mi mundo y  mirando mejor mi problema, busque una solucion alternativa, hice uso de la clase Robot, esta clase simula acciones que puede realizar el usuario como pulsaciones de taclas o movimientos del raton e incluso clics del mismo raton, puede no ser la mejor solucion, pero funciona.

El ejemplo que realice para esta demostracion, es una aplicacion trivial, que muestra una pregunta en un JOptionPane y desaparece despues de un tiempo.

La clase en cuestion, la llame "tictac.java", si lo se, soy un asco para colocar nombres  mis clases, pero bueno, esta clase tiene el metodo mostrar_pregunta(String p, int d).  recibe como parametros la pregunta en cuestion y el tiempo en segundos que se desea mostrar el JOptionPane en pantalla, pasado este tiempo, que es controlado por el metodo Comenzar_a_contar(), el JOptionPase se cerrara automaticamente haciendo uso de la clase Robot, que simula la presion de la tecla escape KeyEvent.VK_ESCAPE, la respuesta se almacena en una variable de tipo String "respuesta", para su uso posteriormente.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class tictac {
//para la animacion    
private Timer tiempo ;
private TimerTask task;
//para almacenar la respuesta
private String respuesta=null;
private int duracion = 3;//tiempo
private JFrame padre;
private boolean isrun=false;

    public tictac(){
    }
    
    public void mostrar_pregunta(String p, int d){
        this.duracion = d;
        //comienza a contar el tiempo
        Comenzar_a_contar();
        //se muestra el JOptionPane
        this.respuesta = JOptionPane.showInputDialog(this.padre, p , JOptionPane.QUESTION_MESSAGE);
        //si contesto antes de que acabe el tiempo
        if(isrun){
            detener();
            actualizar();
        }       
        //System.out.println("Respuesta " + this.respuesta);
    }
    
    /* se ejecuta cuando acaba el tiempo */
    public void time_is_over(){    
        try {    
            Robot robot = new Robot();
            //se asigna una respuesta vacia
            this.respuesta = "No tengo idea";
            // se actualiza
            actualizar();
            //se presiona la tecla escape
            robot.keyPress(KeyEvent.VK_ESCAPE);
        } catch (AWTException ex) {
            Logger.getLogger(tictac.class.getName()).log(Level.SEVERE, null, ex);
        }         
    } 
    
    /* actualiza los objetos del frame padre */
    public void actualizar(){
     //se añade la respuesta al objeto label de miframe
      miframe.lbRes.setText("Respuesta: " + this.respuesta);
      miframe.lbtiempo.setText("0");
      miframe.lbRes.repaint();   
    }
    
    /* metodo que lleva el tiempo disponible para contestar*/
    public void Comenzar_a_contar() {   
           isrun=true;
           tiempo = new Timer();
           task = new TimerTask() {
               int contador=0;
               public void run() {
                   contador++;
                   miframe.lbtiempo.setText(String.valueOf(contador));
                   System.out.println("tiempo transcurrido: " + contador);
                   if(contador == duracion){
                        System.out.println("Se acabo el tiempo, mala suerte");
                        time_is_over();
                        detener();
                   }
               }    
           };        
           tiempo.schedule(task,0,1000);    
    }
    
    /* detiene la animacion */
     public void detener() {   
            isrun=false;
            tiempo.cancel();
            task.cancel();
    }        
}

Este metodo tiene un contra, la aplicacion tiene que estar siempre visible, caso contrario no funciona, la clase robot realiza la pulsacion de la tecla escape, pero con la aplicacion que se encuentre en primer plano, al perder el foco la aplicacion en java, pierde el evento de pulsacion y el JOptionPane continuara visible.

Asi que como respuesta alternativa, puede utilizarse un JFrame que tenga la apariencia de un JOptionPane, si no es estrictamente necesario utilizar la clase JOptionPane, el funcionamiento es el mismo, con la diferencia de que ya no es necesario el uso de la clase Robot para cerrar el objeto, ya que un Jframe cuenta con el metodo dispose() para cerrar la ventana.

El video para mas detalles

y no puede faltar el codigo fuente, en Netbeans 6.0

continue reading

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 

continue reading