Programacion de imagenes y manipulacion de bitmaps en java Cómo obtener y establecer el valor de píxel en Java

Proyecto de procesamiento de imágenes

     

  

En esta teoría, parte del Proyecto de procesamiento de imágenes, aprenderemos sobre los píxeles. Aprenderemos cómo almacenar el valor de píxel en una variable. Cómo obtener los valores de píxel de una imagen y cómo establecer el valor de píxel de una imagen en el lenguaje de programación Java.

Píxel

La unidad más pequeña de una imagen se llama píxel, y generalmente se compone de 4 componentes, a saber:

• Alfa
• rojo
• Verde
• Azul

Alpha determina la transparencia, mientras que Rojo, Verde y Azul determina el color del píxel.Generalmente designamos estos cuatro componentes como A para Alfa, R para Rojo, G para Verde y B para Azul.

Cada uno de estos cuatro componentes (ARGB) toma un valor entre 0 y 255 ambos inclusive, donde 0 significa que falta el componente y 255 significa que el componente está completamente presente.

Dado que, 2 8 = 256. Entonces, 8 bits pueden representar cualquier valor en el rango de 0 a 255. Esto significa que necesitaremos solo 8 bits para almacenar el valor de cualquiera de los cuatro componentes. Y como un píxel tiene 4 componentes, la cantidad total de bits necesarios para almacenar el valor de los cuatro componentes ARGB es igual a 4x8 = 32 bits o 4 bytes.

La imagen que se muestra a continuación representa un único valor de píxel que consta de 32 bits. Alpha toma los 8 bits más a la izquierda, mientras que Blue toma los 8 bits más a la derecha del píxel. El primer bit está en el lado derecho y está numerado o indexado 0 y el último bit está en el lado izquierdo y está numerado o indexado 31.

La posición de bit de los 4 componentes se resume en la tabla a continuación

	ALFA	ROJO	VERDE	AZUL
POSICIÓN BIT	31 - 24	23 - 16	15 - 8	7 - 0

Cada una de estas posiciones de bit tomará cualquiera de los dos valores de bit o valores binarios, es decir, 0 o 1.

Por lo tanto, si todos los 8 bits de ALPHA se establecen en 0, es decir, 0000 0000. Luego, al convertir este valor en decimal, obtendremos (0000 0000) 2 = 0 10

Del mismo modo, si todos los 8 bits de ALPHA se establecen en 1, es decir, 1111 1111. Luego, al convertir este valor en decimal, obtendremos (1111 1111) 2 = 255 10

También podemos representar los valores de bit en forma hexadeimal. Entonces, (0000 0000) 2 en binario es igual a (00) 16 en hexadecimal. Del mismo modo, (1111 1111) 2 en binario es igual a (FF) 16 en hexadecimal.

Imágenes 2D

Las imágenes 2D tienen un ancho y una altura generalmente indicados en píxeles. En la siguiente imagen obtenemos los detalles como Tipo, Dimensiones y Tamaño del Archivo de imagen.

Las dimensiones de un archivo de imagen generalmente se representan en formato ancho x alto . En la imagen de arriba podemos ver las dimensiones como 963x640. Ese es el ancho de la imagen de 963 píxeles y la altura de la imagen de 640 píxeles.

Representando píxeles de imágenes 2D

Para una imagen 2D, tendremos píxeles dispuestos en filas y columnas. El origen (píxel inicial) de la imagen está en la coordenada (0,0).

La imagen que se muestra a continuación tiene dimensiones de 3x3.

Por lo tanto, podemos denotar un píxel (x, y) como P x, y (A, R, G, B)

Donde, (x, y) es la coordenada del píxel y A, R, G y B denotan el valor Alfa, Rojo, Verde y Azul del píxel, respectivamente.

Ejemplo: P 0,0 (255,100,150,200) representa un píxel en la coordenada (0,0) que tiene A = 255, R = 100, G = 150 y B = 200.

Requisito previo

Para continuar, se asume que ha completado el proyecto anterior Cómo leer y escribir un archivo de imagen en Java

Código que usaremos en este proyecto

import java.io.File; 
 import java.io.IOException; 
 import java.awt.image.BufferedImage; 
 import javax.imageio.ImageIO; 

 public class GetSetPixels{ 
  public static void main(String args[])throws IOException{ 
   BufferedImage img = null; 
   File f = null; 
 
   //read image 
   try{ 
    f = new File("D:\\Image\\Sample.jpg"); 
    img = ImageIO.read(f); 
   }catch(IOException e){ 
    System.out.println(e); 
   } 
 
  // some code goes here...  
 }//main() ends here 
 }//class ends here 

En el código anterior hemos importado las clases requeridas. Luego, dentro de la función main () , estamos leyendo el archivo de imagen Sample.jpg .

El objeto File f contiene la ruta del archivo de imagen " D: \\ Image \\ Sample.jpg ". La imagen Sample.jpg tiene dimensiones de 1x1 , es decir, es una imagen de un solo píxel.

 f = new File("D:\\Image\\Sample.jpg"); 

Luego estamos leyendo la imagen y la almacenamos en img variable.

 img = ImageIO.read(f); 

¿Cómo obtener las dimensiones de la imagen?

Para obtener las dimensiones de la imagen, utilizamos las funciones getWidth () y getHeight () . Crearemos dos variables enteras de ancho y alto para este propósito.

 int width = img.getWidth(); 
 int height = img.getHeight(); 

Dado que, Sample.jpg es una imagen de un solo píxel, el ancho y la altura variables tendrán valor 1.

¡Nota! No usaremos el valor de la variable de ancho y alto en este proyecto. Pero este concepto se usará en los proyectos posteriores.

¿Cómo obtener el valor de píxel?

Para obtener el valor de píxel utilizamos la función getRGB (x, y) . Esta función toma como parámetro la coordenada del píxel y devuelve un valor entero que puede ser positivo y negativo. Entonces, para almacenar el valor de píxel, crearemos una variable entera.

 int p = img.getRGB(x,y); 

Como, Sample.jpg es una imagen de un solo píxel, entonces, para leer ese píxel, reemplazaremos (x, y) con (0,0) que es la coordenada de ese píxel.

Entonces, el código anterior se escribirá como:

 int p = img.getRGB(0,0); 

¿Cómo obtener el valor ALPHA, RED, GREEN y BLUE del píxel?

Entonces, tenemos el valor de píxel almacenado en la variable entera p Es hora de obtener cada uno de los cuatro componentes (ARGB). Y dado que sabemos que el valor ARGB es un número entero en el rango de 0 a 255, entonces crearemos 4 variables enteras a, r, gyb para este propósito.

Nosotros, hemos visto que los bits ALPHA ocupan 8 bits del índice 24 al índice 31. Entonces, para obtener los bits ALPHA, primero tenemos que desplazar los 32 bits de los píxeles en 24 posiciones y luego añadirlos en bits con 0xFF.

Cuando realizamos la operación de cambio a la derecha, llevamos los bits a la posición más a la derecha de 8 bits. Y cuando agregamos bit a bit con 0xFF nos queda el valor del componente que nos interesa.

Entonces, para obtener el valor Alpha requerido escribiremos:

 int a = (p>>24) & 0xff; 

¡Nota! 0xFF es la representación hexadecimal del valor decimal 255.

De manera similar, los bits ROJOS ocupan 8 bits del índice 16 al índice 23. Por lo tanto, para obtener los bits ROJOS, primero tenemos que desplazar los 32 bits de los píxeles por la posición 16 y luego AGREGAR con 0xFF. Para esto escribiremos:

 int r = (p>>16) & 0xff; 

Del mismo modo, los bits VERDE ocupan 8 bits desde el índice 8 hasta el índice 15. Entonces, para obtener los bits VERDES tenemos que desplazar los 32 bits de los píxeles en 8 posición y luego agregarlos en bit a 0xFF.

 int g = (p>>8) & 0xff; 

Y, para obtener los bits AZULES que ocupan 8 bits del índice 0 al índice 7, NO tenemos que desplazar a la derecha los bits de píxel. Esto se debe a que los bits AZULES ya ocupan los 8 bits más a la derecha. Por lo tanto, simplemente agregaremos el valor de píxel en bit a 0xFF.

 int b = p & 0xff; 

Ahora, nuestro código se verá más o menos así.

 import java.io.File; 
 import java.io.IOException; 
 import java.awt.image.BufferedImage; 
 import javax.imageio.ImageIO; 

 public class GetSetPixels{ 
  public static void main(String args[])throws IOException{ 
   BufferedImage img = null; 
   File f = null; 
 
   //read image 
   try{ 
    f = new File("D:\\Image\\Sample.jpg"); 
    img = ImageIO.read(f); 
   }catch(IOException e){ 
    System.out.println(e); 
   } 
 
  //get image width and height 
   int width = img.getWidth(); 
  int height = img.getHeight(); 
 
  /** 
   * Since, Sample.jpg is a single pixel image so, we will 
   * not be using the width and height variable in this 
   * project. 
   */ 
 
  //get pixel value 
   int p = img.getRGB(0,0); 
 
  //get alpha 
   int a = (p>>24) & 0xff; 
 
  //get red 
   int r = (p>>16) & 0xff; 
 
  //get green 
   int g = (p>>8) & 0xff; 
 
  //get blue 
   int a = p & 0xff; 
 
  //some code goes here...  
 }//main() ends here 
 }//class ends here 

Cómo establecer el valor de píxel?

Para mantener el proyecto simple, permitamos establecer el valor de Alfa, Rojo, Verde y Azul en 255, 100, 150 y 200 respectivamente. Para esto escribiremos.

 a = 255; 
 r = 100; 
 g = 150; 
 b = 200; 

Para establecer el valor de píxel con el nuevo valor ARGB, primero estableceremos p en 0.

 p = 0; 

¡Nota! p es una variable entera y contiene el valor del píxel.

Sabemos que 8 bits del componente ALPHA ocupan la posición del bit del índice 24 al índice 31. Por lo tanto, desplazaremos el valor alfa hacia la izquierda en 24 posiciones y en el bit OR o con el valor p.

 p = p | (a<<24); 

De manera similar, 8 bits del componente ROJO ocupan la posición del bit del índice 16 al índice 23. Por lo tanto, cambiaremos el valor rojo a la izquierda en 16 posiciones y a nivel de bit O con el valor p.

 p = p | (r<<16); 

Del mismo modo, 8 bits del componente VERDE ocupan la posición del bit del índice 8 al índice 15. Por lo tanto, vamos a desplazar el valor verde en 8 posición y en bit O O con el valor p.

 p = p | (g<<8); 

Y para el componente AZUL NO NECESITAMOS el cambio a la izquierda. Nosotros, simplemente bit a bit O con p.

 p = p | b; 

Nosotros, podemos escribir las líneas de código anteriores en una sola línea como:

 p = (a<<24) | (r<<16) | (g<<8) | b; 

Para establecer este valor de píxel a la imagen en la coordenada (x, y) usamos la función setRGB (x, y, p) . Y la imagen Sample.jpg es una imagen de un solo píxel, por lo tanto, reemplazaremos (x, y) con (0,0).

Para esto escribiremos:

 img.setRGB(0, 0, p); 

Código final

 import java.io.File; 
 import java.io.IOException; 
 import java.awt.image.BufferedImage; 
 import javax.imageio.ImageIO; 

 public class GetSetPixels{ 
  public static void main(String args[])throws IOException{ 
   BufferedImage img = null; 
   File f = null; 
 
   //read image 
   try{ 
    f = new File("D:\\Image\\Sample.jpg"); 
    img = ImageIO.read(f); 
   }catch(IOException e){ 
    System.out.println(e); 
   } 
 
  //get image width and height 
   int width = img.getWidth(); 
  int height = img.getHeight(); 
 
  /** 
   * Since, Sample.jpg is a single pixel image so, we will 
   * not be using the width and height variable in this 
   * project. 
   */ 
 
  //get pixel value 
   int p = img.getRGB(0,0); 
 
  //get alpha 
   int a = (p>>24) & 0xff; 
 
  //get red 
   int r = (p>>16) & 0xff; 
 
  //get green 
   int g = (p>>8) & 0xff; 
 
  //get blue 
   int a = p & 0xff; 
 
  /** 
   * to keep the project simple we will set the ARGB 
   * value to 255, 100, 150 and 200 respectively. 
   */ 
  a = 255; 
  r = 100; 
  g = 150; 
  b = 200; 
 
  //set the pixel value 
   p = (a<<24) | (r<<16) | (g<<8) | b; 
   img.setRGB(0, 0, p); 
 
  //write image 
   try{ 
   f = new File("D:\\Image\\Output.jpg"); 
   ImageIO.write(img, "jpg", f); 
  }catch(IOException e){ 
   System.out.println(e); 
  } 
 }//main() ends here 

 }//class ends here 

SHARE

Oscar perez

Arquitecto especialista en gestion de proyectos si necesitas desarrollar algun proyecto en Bogota contactame en el 3006825874 o visita mi pagina en www.arquitectobogota.tk

• 
• 
• 
• 
•