Florence Colgate el rostro perfecto

La belleza es un concepto abstracto y evidentemente relativo. Su existencia está ligada a una percepción que a su vez está determinada, en buena medida, por preceptos culturales y asociaciones específicas. Sin embargo, como suele ocurrir con la mirada científica, también se han establecido parámetros que delinean la composición perfecta de la belleza en referencia al rostro humano.

[Dimask - Jugar]

Si es cierto que la belleza se puede medir en función de la simetría facial, Florence Colgate es probablemente una de las mujeres más bellas del mundo.

Concederle el primer puesto que le otorgan algunos titulares me resulta exagerado teniendo en cuenta que no se han valorado a todas las mujeres de la Tierra, pero matices a parte lo cierto es que esta estudiante británica de 18 años acaba de ganar el concurso Lorraine Naked del canal ITV al que optaron más de 8000 candidatas sin ningún retoque quirúrgico, que tampoco usaron maquillaje.

Y de acuerdo con las proporciones postuladas como idóneas por la ciencia, la británica Florence Colgate es la mujer más hermosa del planeta. La distancia entre sus orejas es exactamente el doble del trecho que separa a una de sus pupilas de la otra. Además, la distancia que hay de sus ojos a su boca equivale a una tercera parte de la que separa su barbilla de la línea donde comienza su cabello, arriba de la frente. Ambas proporciones coinciden con la belleza perfecta que los científicos obtuvieron tras correlacionar múltiples variables.

Pues bueno, bonita si es, a mi me gusta su mirada más que otra cosa pero de ahí a que sea perfecto pues depende de cada quien digo yo, si quieres averiguar que tan perfecto es tu rostro prueba Dimask, y compruébalo por ti mismo, No Apto Para Acomplejados :)

Ahora también existe una herramienta on-line para comprobar si tu rostro es simétrico

Visitar página Dimask

continue reading

Captura de pantalla Java/Robot

Este es un pequeño proyecto de un capturador de pantalla escrito en lenguaje java con la ayuda del IDE de Netbeans version 6.9, utilizando la clase Robot de java.

La clase que hace todo el trabajo (de la captura) es la clase capture.java, el código de esta clase es:

package jcapture;
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileNameExtensionFilter;
/**
 * @web http://www.jc-mouse.net
 * @author Mouse
 */
public class Capture {    
   
   private BufferedImage image;   
   private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg");
   private JFileChooser fileChooser = new JFileChooser();

   /* CAPTURA LA PANTALLA */
   public void captureScreen(Point p , Dimension screenSize)  {
        try {
            //crea el area de captura
            Rectangle screenRectangle = new Rectangle(p, screenSize);
            Robot robot = new Robot();
            image = robot.createScreenCapture(screenRectangle);            
            Guardar_Foto();
        } catch (Exception ex) {
        }
    }

    private void Guardar_Foto(){
       String file=null;
       fileChooser = new JFileChooser();
       fileChooser.setFileFilter(filter);
       //fileChooser.setCurrentDirectory(new java.io.File("e:/capturas/"));
       int result = fileChooser.showSaveDialog(null);
       if ( result == JFileChooser.APPROVE_OPTION ){
                file = fileChooser.getSelectedFile().toString();
                guardar_imagen(file + ".jpg");
        }
    }

  /* guarda la imagen en disco*/
    private void guardar_imagen(String f){
        try {            
            //se escribe en disco en formato JPG
            ImageIO.write(image, "jpg", new File(f));
            JOptionPane.showMessageDialog(null, "Captura guardada en disco");
 } catch (IOException e) {
            JOptionPane.showMessageDialog(null, "Error: no se pudo guardar la imagen");
 }
   }

}

Un poco de explicación sobre esta clase, cuenta con el método captureScreen el cual recibe dos parámetros de entrada, un Point (origen X,Y)  y Dimension (ancho, alto) que forman un rectangulo imaginario que sirve como parametro para tomar la captura de pantalla, a su vez este metodo hace uso del metodo privado Guardar_Foto(), este método te mostrara una ventana de diálogo "Guardar como..." para que indiques el lugar y el nombre del archivo a guardar y ya para terminar el método "guardar_imagen" que creo que no hace falta indicar para que sirve :)

Bueno, todo esto lo puedes ver en el siguiente video, así queda más claro:

Descargate el proyecto desde el siguiente enlace (jCapture)

continue reading

Colocar imagen a jFrame y JPanel facil

jcMousePanel-1.6.9 nueva versión de mi componente swing para el trabajo con imagenes en jPanel de una manera facil sencilla sin escribir codigo fuente extra en las aplicaciones que desarrollemos en netbeans, viene con muchas mejoras y más opciones de personalización.

Puedes agregar una imagen de fondo y ademas otra imagen la cual podras mover  según tus necesidades

Con esta nueva actualización puedes personalizar el efecto de degradado

Transparencias en imagenes y degradado

Mosaico de imagenes

¿QUIERES SABER MÁS?

continue reading

El Laberinto del Miedo

Aquí tenéis el famoso juego de la niña del exorcista en su versión "El grito", también llamado juego del laberinto o The Maze, que pone a prueba vuestra habilidad y reflejos al tener que pasar el punto por los caminitos, ayudados sólo del ratón. Al final, hay una recompensa muy buena que seguramente disfrutaréis con gran agrado. y ole!!!

¡TE RETO A JUGARLO!

Bajatelo desde aqui: http://link.jc-mouse.net/?id=GAMLAB2TWS, es GRATIS!

Si eres programador y te intereza el codigo fuente, sigue el siguiente enlace: El Laberinto proyecto completo

continue reading

Recortar imagen con java-netbeans

En esta oportunidad les dejo el codigo para recortar pedazos de imagenes desde java/netbeans, como siempre todo de forma visual y con codigo recontra comentado

El siguiente video creo que dice todo y  muestra claramente cual es nuestro objetivo, espero les sirva

La imagen utilizada es la de una linda señorita cosplay :)

Y nuestro resultado

 

¿Quieres saber más?

continue reading

Imagen en Blanco y Negro en Java

 (Imagen A: Color, B: Escala de Grises, C: Blanco y Negro)

Una imagen en Blanco y Negro (Black and White) a diferencia de las imagenes en escala de grises donde cada color RGB tiene su tonalidad equivalente en gris, la imagen en blanco/negro es monocromo, es decir solo acepta el blanco y el negro sin ninguna escala intermedia.

Java nos permite trabajar con imagenes en blanco y negro y realizar la conversion facilmente utilizando la clase BufferedImage.TYPE_BYTE_BINARY. En este tutorial, veremos dos maneras de realizar la conversion a Blanco/Negro.

Primer metodo: 

Para convertir una imagen en color a su equivalente en Blanco/Negro, basta con crear una imagen en memoria del tipo BufferedImage utilizando BufferedImage.TYPE_BYTE_BINARY, despues se debe pasar pixel a pixel los valores de la imagen a colores a la nueva imagen blanco/negro, la clase BufferedImage.TYPE_BYTE_BINARY hara el resto.

Este metodo tiene un inconveniente, dependiendo de la luminosidad de la imagen, la calidad u otros factores, el resultado puede variar.

Segundo metodo

Este segundo metodo es una extension del primer metodo, ya que igualmente se utiliza la clase BufferedImage.TYPE_BYTE_BINARY para crear una imagen monocroma, pero tambien para poder controlar la cantidad de negro o blanco que deseemos en la imagen, se hace uso de una variable de tipo entero que llamaremos "umbral", esta variable puede tomar valores entre 0 y 255 y su valor por defecto sera 127.

Seudocodigo:

umbral = 127
color = imagen_color.getColorRGB(i,j);

R = color.leer_Rojo
G = color.leer_Verde
B = color.leer_Azul

si R > umbral entonces
   R = 255
sino
   R = 0
fin si

si G > umbral entonces
   G = 255
sino
   G = 0
fin si

si B > umbral entonces
   B = 255
sino
   B = 0
fin si

imagen_blanco_negro.setColor(i,j, color(R,G,B) )

Cuando se utliza la clase BufferedImage.TYPE_BYTE_BINARY para obtener una imagen monocroma, en realidad los pixeles aun contienen valores RGB diferentes de 0 y 255, aunque en pantalla vemos solo el blanco y negro, aprovechando esto, leeremos los valores RGB de cada pixel de la imagen y dependiendo de sus valores se los colocara en 0 o en 255, (ver seudocodigo). Asi podremos obtener varias imagenes con diferentes resultados, dependiendo del valor que tome "umbral".

El Codigo de la clase WB.java con ambos metodos

import java.awt.Color;
import java.awt.image.BufferedImage;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class WB {    
    private int r,g,b;
    private Color color;
    int umbral = 127;// 

    public WB(){}

   public BufferedImage set_Blanco_y_Negro(BufferedImage f){
        BufferedImage bn = new BufferedImage(f.getWidth(),f.getHeight(), BufferedImage.TYPE_BYTE_BINARY);
        //se traspasan los colores Pixel a Pixel
        for(int i=0;i<f.getWidth();i++)
          for(int j=0;j<f.getHeight();j++)
               bn.setRGB(i, j, f.getRGB(i, j));
        return bn;
   }

   public BufferedImage set_Blanco_y_Negro_con_Umbral(BufferedImage f){
        BufferedImage bn = new BufferedImage(f.getWidth(),f.getHeight(), BufferedImage.TYPE_BYTE_BINARY);        
        //se traspasan los colores Pixel a Pixel
        for(int i=0;i<f.getWidth();i++){
          for(int j=0;j<f.getHeight();j++){
               color = new Color(f.getRGB(i, j));
               //se extraen los valores RGB
                r = color.getRed();
                g = color.getGreen();
                b = color.getBlue();
                //dependiendo del valor del umbral, se van separando los
                // valores RGB a 0 y 255  
                r =(r>umbral)? 255: 0;
                g =(g>umbral)? 255: 0;
                b =(b>umbral)? 255: 0;
                bn.setRGB(i, j, new Color(r,g,b).getRGB());            
          }
        }        
        return bn;
    }
 
}

continue reading

Imagen a Escala de Grises

Para cambiar una imagen a Escala de Grises en Java se utiliza la clase ColorConvertOp al cual se le pasa como parametro ColorSpace.CS_GRAY


Codigo Fuente:

import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class Gris {
    private BufferedImage foto=null;

    public Gris(){}

     public void set_Escala_de_Grises(BufferedImage f){
       ColorConvertOp ccop = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
       foto = ccop.filter((BufferedImage)f,null);
    }

    public BufferedImage getFotoGris(){
        return this.foto;
    }

}

Implementado la clase "Gris.java" tenemos:

Eso es todo, que tal la ponja :), asi si da ganas enfermarse ;)

continue reading

Posterizar imagenes en Java2d (Filtro Posterize)

Posterizar una imagen es reducir el tono de sus colores a una gama mas uniforme tipo "Poster"



Teniendo una gama de colores :

RGB: 66,66,91
RGB: 131,138,211
RGB: 73,80,214

Se reducira la diferencia entre estos mediante la formula:

NuevoColorRGB = Color_RGB - (Color_RGB MOD NIVEL)

Donde Nivel podra tomar valores entre 1 y 255

Ej:
Nivel: 100

RGB: 66,66,91

R: 66 - (66 mod 100) = 0
G: 66 - (66 mod 100) = 0
B: 91 - (91 mod 100) = 0

RGB: 131,138,211

R: 131 - (131 mod 100) = 100
G: 138 - (138 mod 100) = 100
B: 211 - (211 mod 100) = 200

RGB: 73,80,214
    
R: 73 - (73 mod 100) = 0
G: 80 - (80 mod 100) = 0
B: 214 - (214 mod 100) = 200

Gama de Colores Original

Despues del Posterizado

Clase: posterize.java
Codigo Fuente:

import java.awt.Color;
import java.awt.image.BufferedImage;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class posterize {
    private BufferedImage foto;    
    private int r,g,b;
    private Color c;
    
    public posterize(){}

    public void SetPosterize(BufferedImage f, int nivel){
        this.foto = f;        
        for(int i=0;i<foto.getWidth();i++){
          for(int j=0;j<foto.getHeight();j++){  
                //Se obtiene el color RGB de cada pixel
                c = new Color(foto.getRGB(i, j));              
                r = c.getRed();
                g = c.getGreen();
                b = c.getBlue();
                //Se calcula el valor para la Posterización
                r = (r - (r % nivel));
                g = (g - (g % nivel));
                b = (b - (b % nivel));
                //se añade los nuevos valores
                foto.setRGB(i, j, new Color(r,g,b).getRGB());                                                                    
          }
        }        
    }
    
    public BufferedImage getFoto(){
        return this.foto;
    }
    
}

Implementando esta clase, tenemos a diferentes valores del parametro de calculo "Nivel":

Nivel : 50

Nivel: 100

Nivel: 150

A mayor valor de "Nivel", la imagen se ira haciendo más uniforme

continue reading

Invertir imagen en Java (Filtro Negativo)

Java nos permite mediante la clase BufferedImage manipular archivos de imagen byte por byte, por ejemplo para conseguir el efecto de "negativo" para una foto como hace el filtro de photoshop, corel o gimp.

Para este ejemplo, utilizaremos una foto de "rikku", un personaje de Final Fantasy, con un lindo par de ojos ;) para invertir la imagen, obtendremos todos los pixeles de la foto, de cada pixel se extraeran sus valores RGB (rojo, verde, azul) y se les restara 255,este nuevo  valor, se insertara en una nueva imagen de tipo BufferedImag, esto se realizara para cada pixel de la image. Osea:

255 - Valor_R = Valor_R_invertido

255 - Valor_G = Valor_G_invertido

255 - Valor_B = Valor_B_invertido

La clase que hace todo esto es:

import java.awt.Color;
import java.awt.image.BufferedImage;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class invertir {
    private BufferedImage foto;
    private int r,g,b;
    private Color color;
    public invertir(){}
     
 /* Invierte los bytes de una imagen */
  public void SetInvertir(BufferedImage f){
        this.foto = f;
        for(int i=0;i<foto.getWidth();i++){
          for(int j=0;j<foto.getHeight();j++){
                //se obtiene el color del pixel
                color = new Color(foto.getRGB(i, j));
                //se extraen los valores RGB
                r = color.getRed();
                g = color.getGreen();
                b = color.getBlue();
                //se coloca en la nueva imagen con los valores invertidos
                foto.setRGB(i, j, new Color(255-r,255-g,255-b).getRGB());                                                                    
          }
        }        
    }
    
    public BufferedImage getFoto(){
        return this.foto;
    }  
    
}

Esta simple clase, recibe un objeto de tipo BufferedImage y procesa byte por byte los colores de la imagen y las invierte, esta clase tambien retorna una imagen del tipo BufferedImage invertida.

Implementando esta clase y pasando como parametro la imagen anterior, obtenemos como resultado la imagen invertida.

continue reading

Procesamiento de Imágenes en Java2d (Los Colores)

Un archivo de imagen está compuesto dependiendo de las dimensiones de este archivo, en cientos y miles de pixeles, un pixel es un punto de color que varían en su tonalidad de un pixel a otro, creando así la imagen digital.

Si se realiza un zoom a una imagen cualquiera, puede verse como este esta pixelado

Un pixel está compuesto por los colores básicos RGB en sus siglas en ingles (Red, Green, Blue) en español, ROJO, VERDE, AZUL, estos tres colores básicos combinados en diferentes valores (0 a 255) forman una amplia gama de tonalidades los cuales combinados forman la imagen. Entonces una imagen no es más que una matriz de dos dimensiones de tamaño mXn donde cada elemento de la matriz M(i,j) es un pixel.

JAVA2D

Como cada pixel contiene valores RGB, Java2d nos permite manipular estos valores cargando una imagen en memoria, utilizando la clase BufferedImage,  para poder manipular  los archivos de imagen, esta clase cuenta con varios métodos. Entre ellos tenemos:

• imagen.getRGB(x,y);
• imagen.setRGB(x,y,Color_RGB);

El primero no permite obtener el valor RGB de un pixel, dadas sus coordenadas (X,Y) dentro de la matriz.

El segundo método, nos permite asignar un nuevo valor RGB a un pixel, dados sus coordenadas RGB dentro de la mtriz.

Entonces, para poder cambiar los colores de una imagen, solamente debemos obtener sus valores RGB y reemplazarlos por unos nuevos, esto se logra recorriendo toda la matriz pixel por pixel y cambiando sus valores RGB.

Este proceso no es complicado, además no es muy interesante, en cambio si es más interesante, seleccionar un solo color y con este color como referencia, reemplazar todos los pixeles que se encuentren con valores iguales o similares por otro color. Más o menos lo que se realiza con el programa Photoshop, utilizando la varita mágica se selecciona un rango de pixeles y con la herramienta bote de pintura, se reemplaza por otro color.

En la imagen podemos ver todo ese proceso, además, photoshop dado un parámetro de “Tolerancia” (0-255) selecciona no solo el pixel del color donde se hizo un clic, sino todas las tonalidades de ese color, osea, según el parámetro de tolerancia, a mayor tolerancia mayor será el área seleccionada.

¿Cómo logramos esto en Java2d?
Se cargara una imagen en memoria utilizando la clase BufferedImage.

De esta imagen se extrae un pixel al azar con valores RGB (187,13, 14) en una posición (x,y)

Esta imagen forma una matriz mxn donde cada celda es un pixel

[rgb] [rgb] [rgb] [rgb] [rgb] [rgb]
[rgb] [rgb] [rgb] [rgb] [rgb] [rgb]
[rgb] [rgb] [rgb] [rgb] [rgb] [rgb]
[rgb] [rgb] [rgb] [rgb] [rgb] [rgb]

Para cambiar un color de toda la matriz (imagen), se debe recorrer esta mediante ciclos buscando los pixeles que sean iguales al color buscado, y reemplazarlo por otro color. El seudocódigo que hace esto es:

Este seudocódigo, tiene un problema, y es que aunque el ojo humano no pueda percibirlo, un color que para nosotros  puede ser igual, este está compuesto por varias tonalidades, asi es que cuando seleccionamos un color RGB (187,13, 14), la comparación se realiza solo para este color.

Esto hace que el área afectada por el cambio de color sea relativamente pequeña y dependa de la uniformidad de colores de la imagen.

Para solucionar este problema, se introduce un nuevo término, “Tolerancia” y su valor va de 0 a 255, este valor nos ayuda a determinar un rango de matices que se aproximen a nuestro color RGB

Para determinar qué valores ingresan en el rango de “tolerancia”, se utiliza la “distancia euclidiana” cuya fórmula es:

Este valor (d) es la distancia que existe entre dos puntos en el espacio, mientras más corta sea el valor de (d), más pequeña es la distancia entre dos puntos, esto también se aplica a los colores.

Mientras más pequeña sea el valor de (d) los colores son más similares entre si, modificamos el seudocódigo y queda de la siguiente forma:

Abrimos photoshop y utilizamos la herramienta “varita mágica” para seleccionar un color, podemos ver como con distintos valores de tolerancia, seleccionamos más y más aéreas de la imagen.

Aplicando nuestro seudocódigo en java y ya con la aplicación lista, procedemos a seleccionar un color de la imagen y la reemplazamos por otra, los resultados son similares.

 Es lógico que Photoshop utiliza algoritmos mucho más complejos e inteligentes para aplicar sus filtros, por ejemplo, photoshop selecciona solos los colores similares que estén cerca del punto donde se hizo un clic, en cambio, el código que nosotros aplicamos es simple y selecciona todos las tonalidades del color elegido estén donde estén, esto se aprecia mejor en la tercera imagen de ayanami donde aplicamos tolerancia 100, se puede ver como se selecciono el fondo de la imagen, pero también parte del ojo y del cuello que también son de color rojo, se seleccionaron también.

Enlace de descarga del Proyecto
[actualizado]

continue reading

Java2D: Marca de Agua con Java

Java2d nos permite tambien trabajar con archivos de imagen en diferentes formatos, Java2D tambien cuenta con varios metodos para poder manipular estas imagenes. Aqui un pequeño ejemplo de lo que se puede hacer, el siguiente proyecto hecho en netbeans 6.0, sirve para colocar una "marca de agua" sobre una imagen.

Proyecto:
1. Crea un nuevo proyecto en Netbeans, llamalo como quieras, añade un JFrame y llamalo "interfaz.java", despues añade una clase y llamalo "H2O.java", debes tener algo como esto:

2. Trabajaremos con la interfaz de la siguiente manera:

3. El codigo para la clase "H2O.java", es el siguiente:

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class H2O extends JPanel implements MouseMotionListener {
    private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
    //tamaño del contenedor
    private int ancho=0;
    private int alto=0;
    //foto y marca de agua
    private Image Fotografia;
    private Image Marca_de_Agua;
    //imagen que se crea en memoria con ambas imagenes
    private BufferedImage Imagen_en_memoria;
    //coordenadas de la marca de agua
     private int Pos_Marca_X=0, Pos_Marca_Y=0;
     
    public H2O(){     
        this.setPreferredSize(new Dimension(ancho,alto));
        this.setSize(new Dimension(ancho,alto));
        this.setVisible(true);
        this.repaint();        
        addMouseMotionListener(this);
    }
    
    //se sobreescribe el metodo paint
    @Override        
    @SuppressWarnings("empty-statement")
    protected void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D)g;
        //se crea una imagen en memoria
        Imagen_en_memoria = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_RGB); ;                       
        Graphics2D gOculta = Imagen_en_memoria.createGraphics();
        gOculta.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);        
        //se dibuja las imagenes en el contenedor
        gOculta.drawImage(Fotografia,0,0,this);
        gOculta.drawImage(Marca_de_Agua,this.Pos_Marca_X,this.Pos_Marca_Y,this);
        g2.drawImage(Imagen_en_memoria, 0, 0, this);        
    }

    //muestra una ventana de dialgo para abrir un archivo de imagen
    public String Open(String opcion){
       String file=null; 
       JFileChooser fileChooser = new JFileChooser();       
       fileChooser.setFileFilter(filter);
       int result = fileChooser.showOpenDialog(null);  
       if ( result == JFileChooser.APPROVE_OPTION ){                                 
                //se obtiene la direccion del archivo
                file = fileChooser.getSelectedFile().toString();
                if(opcion.equals("foto")){
                    Fotografia = new ImageIcon(file).getImage();                               
                    ancho = Fotografia.getWidth(this);
                    alto = Fotografia.getHeight(this);                    
                    this.setPreferredSize(new Dimension(ancho,alto));
                    this.setSize(new Dimension(ancho,alto));                          
                }else if(opcion.equals("marca")){
                    Marca_de_Agua = new ImageIcon(file).getImage();                            
                }
                this.repaint();
        }
       return file;
    }   
    
 //abre una ventana de dialogo para escoger la direccion y el nombre del archivo a guardar   
 public void Save(){
       String file=null; 
       JFileChooser fileChooser = new JFileChooser();       
       fileChooser.setFileFilter(filter);
       int result = fileChooser.showSaveDialog(null);
       if ( result == JFileChooser.APPROVE_OPTION ){                                 
                file = fileChooser.getSelectedFile().toString();                
                guardar_imagen(file + ".jpg");           
        }       
    }   

    //metodo que guarda la imagen en disco
    private 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";   
            //se escribe en disco
            ImageIO.write(Imagen_en_memoria, formato, new File(f));
            JOptionPane.showMessageDialog(null, "La imagen se guardo correctamente...");
 } catch (IOException e) {            
            JOptionPane.showMessageDialog(null, "Error: no se pudo crear la imagen");
            System.out.println("Error: no se pudo crear la imagen");
 }
   }  
    
    //movimientos del raton
    public void mouseDragged(MouseEvent e) {
            Pos_Marca_X = (int)e.getPoint().getX();
            Pos_Marca_Y = (int)e.getPoint().getY();            
            repaint();
    }

    public void mouseMoved(MouseEvent e) {}   
   
}

Esta clase, "H2O.java" se extiende de un objeto JPanel, y sobreescribe el metodo paintComponent para dibujar una imagen sobre este, la imagen es el resultado de la combinacion de dos imagenes, una grande la imagen de fondo y una mas pequeña que es la marca de agua, esta imagen puede cambiar de posicion, realizando un clic sostendido sobre este y moviendo el mouse.

Asi tambien, esta clase cuenta con con otros metodos para cargar la imagenes mostrando una ventana de dialogo. y claro esta, un metodo para guardar la imagen en disco. Todo el codigo esta extra comentado.

4. Para implementar esta clase "H2O.java" en la interfaz, debemos hacer lo siguiente:

public class interfaz extends javax.swing.JFrame {
    //se crea el objeto jpanel H2O
    H2O j2d = new H2O();      
    
    /** Creates new form interfaz */
    public interfaz() {
        initComponents();   
        this.setTitle("Marca de Agua - by Mouse");
        //se añade el jpanel al Scroll
        jScrollPane1.setViewportView(j2d);         
        this.repaint();     
    }
   
   private void cmdLoad2ActionPerformed(java.awt.event.ActionEvent evt) {
        Imagen2.setText(j2d.Open("marca"));        
        
   }

    private void cmdLoad1ActionPerformed(java.awt.event.ActionEvent evt) {
        Imagen1.setText(j2d.Open("foto"));         
   }

    private void cmdSaveActionPerformed(java.awt.event.ActionEvent evt) {
        if(!Imagen1.getText().isEmpty() && !Imagen2.getText().isEmpty())
            j2d.Save();
   }

 /* resto de codigo en netbeans */    

}

Nota: no copies y pegues, analiza el codigo ;)

Si llegaste hasta aqui, solo nos falta compilar el proyecto y si existe ningun error, vamos a probarlo:

La imagen a la cual le colocaremos la marca de agua es esta:

Si, lo se ;)

Y la marca de agua es

Es un archivo PNG con transparencia, tambien puede ser un archivo JPG

Cargamos las imagenes en la aplicacion:

Podemos dar la hubicacion que queramos a la marca de agua, y despues ya podemos guardar.

Espero que les haya gustado este proyecto, a mi si :)

continue reading