Capturar webcam con VB.NET

¿Que haremos? Crearemos una aplicación en Visual Studio, la cual hará uso de una webcam para capturar el video en frames independientes y depositarlos en memoria para despues mostralos al usuario a través de un picturebox y un Timer para crear la ilusión de movimiento. ¿Porque lo haremos? Porque es justo y necesario ¿Que necesitamos? [...]

Envío de correo con JavaMail/Netbeans

JavaMail es una expansión de Java que facilita el envío y recepción de e-mail desde código java. JavaMail implementa el protocolo SMTP (Simple Mail Transfer Protocol) así como los distintos tipos de conexión con servidores de correo -TLS, SSL, autentificación con usuario y password, etc [Según SantaWikipedia] ¿Qué necesitamos? JavaMail 1.4.5 Java y Netbeans 6.9 [...]

Proyecto de base de datos Firebird VB

En este proyecto realizaremos una aplicación de base de datos Firebird con el lenguaje de programación de Visual Basic de Microsoft, este proyecto tendrá las funciones básicas de gestión INSERT, DELETE, UPDATE y una interfaz de usuario para utilizarlas. ¿Que necesitamos? Visual Studio 2008 o superior Firebird última versión Firebird ADO.NET Data Provider. Conocimientos básicos [...]

Imprimir imagen con Print

La siguiente clase hace uso de PRINT para imprimir una imagen que se encuentra en un variable de tipo FileInputStream, esta clase a su vez es implementada desde una interfaz que hace fácil su uso, la clase así como todo el proyecto esta comentado. import java.io.File; import javax.print.Doc; import java.io.IOException; import javax.print.DocFlavor; import javax.print.SimpleDoc; import java.io.FileInputStream; [...]

11/4/10

Manipulacion de imagenes en java

JAN29

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 

12 comentarios:

Jhordan Leon dijo...

Hola, esta muy bueno tu blog, pero hasta ahora no he visto un programa q me permita visualizar desde un jFrame la imagen que esta guardada en mi base de datos, he visto un ejemplo de almacenarla, pero si kiero visualizarla desde mi sistema como lo haria, espero contar con tu ayuda y muchas gracias de antemano , todo esta muy bueno te felicito

Anónimo dijo...

Me da un error de Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException, al compilarlo no tengo que declara la clase mipanel.java en el main principal ayuda por favor

Freelancer.net dijo...
Este comentario ha sido eliminado por el autor.
Anónimo dijo...

Podrias publicar el proyecto me parece interesante para realizar un visor de imagenes.

Saludos

Cat dijo...

Muchas gracias Mouse por este tuto, lo probé y me funcionó ;)

vleix_010707 dijo...

sos groso man, GRACIAS

Diego andres de la cruz dijo...

Definitivamente a esto yo lo llamo compartir conocimiento.. que rico poder navegar en la Internet y encontrar material de tan buena calidad. Muchas Gracias. Sigue así.

Vianey vargas morales dijo...

este man definitivamente si comparte que bien poder encontrar proyectos que se puedan descargar y estudiarlos

Esme dijo...

Hola. Una duda. Quiero "pegar" imagenes en netbeans, ya las he cargado ya sea en etiqueta o panel, pero estas imagenes son parte de una imagen general (como un rompecabezas), el problema es que al cargarlas se genera automaticamente un espacio entre ellas, en ambos casos (etiqueta o panel). ¿Que puedo hacer para eliminar el espacio entre las etiquetas o paneles para dar secuencia a la imagen principal.

mouse dijo...

debes cambiar las prpopiedades dekl contenedor que estes utilizando, borde, margin, etc :)

Jeffer tuty dijo...

muy buenos ls tutorials .. me han ayudado mucho.. .. mi bro.. tengo problemas con el metodo reflejo de una imagen en java netbeans .. utilizand matrcez... me ayudarias con un tuto .. xf

chip dijo...

muy buena guia,me funciono de marabilla. es de gran ayuda para lo que estamos iniciando en este lenguaje, sigue asi bro.

saludos.

Post recomendado