Jueves 28 de septiembre de 2023

Laboratorio 1
Visión inteligente

Integrantes: Jose Gavilan

Zhi Fu
Introducción

Este informe se centra en el procesamiento básico de imágenes utilizando

MATLAB. Utilizaremos una imagen de muestra "alexislab.jpg" para realizar
operaciones como la extracción de canales de color (rojo, verde y azul), la
conversión a escala de grises y la modificación de componentes individuales de la
imagen. Estas técnicas esenciales en el procesamiento de imágenes nos
ayudarán a comprender mejor cómo trabajar con imágenes en MATLAB y
formarán la base para futuras exploraciones en este campo.

Contenido
Introducción.......................................................................................................................................2
Desarrollo...........................................................................................................................................4
Imagen 1:.......................................................................................................................................4
Imagen 2:.......................................................................................................................................4
Imagen 3:.......................................................................................................................................4
Imagen 4:.......................................................................................................................................4
Imagen 5........................................................................................................................................5
Imagen 6:.......................................................................................................................................5
Imagen 7........................................................................................................................................5
Imagen 8:.......................................................................................................................................5
Imagen 9:.......................................................................................................................................6
Imagen 10:.....................................................................................................................................6
Imagen 11:.....................................................................................................................................6
Imagen 12:.....................................................................................................................................6
Imagen 13:.....................................................................................................................................7
Imagen 14:.....................................................................................................................................7
Imagen 15:.....................................................................................................................................7
Imagen 16:.....................................................................................................................................8
Imagen 17:.....................................................................................................................................9
Imagen 18:...................................................................................................................................10
Análisis.............................................................................................................................................10
Conclusión........................................................................................................................................11
Desarrollo
Para empezar este laboratorio debemos cargar una imagen en Matlab, para ello
utilizaremos la función “imread” de la siguiente manera:

Imagen 1: Carga de imagen en Matlab.

Luego verificaremos que se cree la variable “imagen” en nuestro workspace y que
contenga la imagen correcta:

Imagen 2: Verificación de la imagen cargada.

Luego con el siguiente código, pasaremos la imagen a tonalidad completamente
roja como se ve a continuación:

Imagen 3: Código para pasar imagen a tonalidad roja.

 Imagen 4: Imagen en tonalidad completa roja.
Luego repetiremos el

proceso para la tonalidad ver y azul respectivamente:

Imagen 5: Código para tonalidad

verde.

Imagen 6: Imagen en tonalidad completa verde.

Imagen 7: Código para tonalidad azul.

 Imagen 8: Imagen en tonalidad azul.

Lo que se hace en los 3

códigos anteriores, es
almacenar la imagen en la
variables solo_rojo,
solo_azul y solo_verde, para
luego con solo_rojo(:,:,2) = 0
dejamos el canal 2, es decir,
el canal verde en 0 y luego repetir el proceso pero con el canal 3, es decir, el canal
azul, para que la imagen nos quede solo en tonalidad roja, y así se realiza para las
otras dos tonalidades, solo_azul se deja en 0 el canal 1 y 2 y para solo_verde se
deja en 0 el canal 1 y 3.
Ahora usaremos unos códigos para dejar la imagen
tonalidad verde-azul, rojo-azul y rojo-verde, partiendo
por verde-azul como se ve a continuación:

Imagen 9: Capa roja en 0.

Imagen 10: Imagen de tonalidad verde-azul.

Ahora para rojo-azul:

Imagen 11: Código para capa
verde en 0.

Imagen 12: Imagen en tonalidad rojo-azul.

Imagen 13: Código para capa azul en 0.

Imagen 14: Imagen en tonalidad rojo-verde.

Como se puede ver, en las 3 imágenes, se deja en 0 la capa que se desee quitar,
en este caso al ser una sola capa, las imágenes quedan en una tonalidad de dos
colores, en comparación a las anteriores en donde solo existía una tonalidad
fuerte. Lo que se hace en el código es dejar en 0 la capa por ejemplo 1, por lo que
la imagen quedara en la tonalidad verde-azul, y así con las otras 2 imágenes en
donde se deja en 0 la capa 2 y 3.
Escala de grises
Para la escala de grises utilizaremos dos métodos, el primero en donde se utilizará
la siguiente ecuación:
I Rojo ( x , y ) + I Verde ( x , y )+ I Azul ( x , y )
I Gris ( x , y )=
3
Ecuación (a)

Tenemos el siguiente algoritmo para representar esta ecuación:

Imagen 15: Algoritmo que usa la ecuación (a)

Este código lo primero que hace es obtener el tamaño de la imagen para saber
cuántas filas y columnas tiene.
Luego, se inician dos contadores, uno para las filas y otro para las columnas, para
ayudar a recorrer cada píxel de la imagen.
El código utiliza un par de bucles (un bucle dentro de otro) para moverse por cada
fila y columna de la imagen.
En cada píxel de la imagen, se calcula un valor de "gris" promediando cuánta luz
roja, verde y azul tiene ese píxel. Esto crea una especie de promedio de colores
que representa cuán brillante será ese píxel en la imagen en blanco y negro.
Luego, ese valor de "gris" se coloca en la misma posición en una nueva imagen en
blanco y negro.
El código se asegura de avanzar a la siguiente columna dentro de la misma fila
antes de pasar a la siguiente fila, y así sucesivamente, hasta que se haya
procesado toda la imagen.
Como resultado nos entrega la siguiente imagen, luego de cambiar el colormap a
“gray”:
 Imagen 16: Imagen con la escala de grises utilizando la ecuación (a)
Por último, utilizaremos la ecuación (b):
I Gris ( x , y )=0,2989 ∙ I Rojo ( x , y ) +0,5870 ∙ I Verde ( x , y ) +0,1140 ∙ I Azul ( x , y )
Ecuación (b) para calcular la escala de grises de una imagen con los coeficientes correspondientes.

En donde ya se tienen los coeficientes para calcular las escalas de grises en cada
capa, por lo que utilizaremos un algoritmo como este para que la imagen se
convierta a escala de grises utilizando esta ecuación:

Imagen 17: Representa el algoritmo que representa la ecuación (b)

En donde este algoritmo lo que hace es:

1. Obtener el Tamaño de la Imagen: Primero, obtiene el número de filas y

columnas de la imagen de entrada para saber cuántos píxeles contiene.
Esto se almacena en las variables "filas" y "columnas".
 2. Crear una Imagen en Blanco y Negro: Luego, se crea una nueva imagen en
blanco y negro llamada "gris" con las mismas dimensiones que la imagen
original. Inicialmente, todos los píxeles de esta imagen están configurados
en negro (valor cero).

3. Recorrer la Imagen: El algoritmo utiliza dos bucles para recorrer cada píxel
de la imagen original. Un bucle se encarga de las filas, y el otro de las
columnas.

4. Calcular el Valor de Gris: Para cada píxel, se extraen los valores de los
componentes de color rojo (R), verde (V) y azul (A). Luego, se aplica una
fórmula que combina estos valores ponderando el rojo con 0.2989, el verde
con 0.5870 y el azul con 0.1140. Esto crea un valor de gris representativo
de ese píxel.

5. Asignar el Valor de Gris: El valor de gris calculado se coloca en la misma

ubicación en la imagen en blanco y negro "gris".

6. Mostrar la Imagen en Escala de Grises: Finalmente, se muestra la imagen

en escala de grises resultante utilizando la función "imshow". Se realiza una
conversión de tipo de datos ("uint8") para asegurarse de que los valores
estén en el rango adecuado para mostrar la imagen correctamente.
Lo que nos genera finalmente una imagen así:

Imagen 18: Imagen en escala de grises con la ecuación (b)

Análisis
En el informe se presentan dos métodos para convertir imágenes en color en
imágenes en escala de grises en MATLAB. Ambos métodos son claramente
explicados y se muestran los resultados visuales. El análisis concluye que el
método con fórmula ponderada produce imágenes en escala de grises de mayor
calidad y realismo, basándose en la percepción humana. El informe es claro y
ofrece una recomendación sólida, aunque una evaluación cuantitativa de la
calidad de imagen podría mejorar aún más el análisis. En general, es un recurso
útil para comprender estos métodos de conversión de imágenes en MATLAB.

Conclusión
En este artículo, se han explorado dos métodos básicos para el procesamiento de
imágenes utilizando MATLAB. En primer lugar, se analizaron métodos para
convertir imágenes a escala de grises, comparando un promedio simple de
componentes RGB con un método que utiliza una fórmula ponderada basada en la
percepción del color de los componentes RGB humanos. Después de una
evaluación visual y analítica, se concluyó que el método ponderado proporciona
imágenes en escala de grises más realistas y de mayor calidad, gracias a su
capacidad para resaltar el contraste y representar el brillo real neutro de la imagen
original.

Además, también se han explorado los procesos que convierten imágenes en

color en componentes de color individuales, incluidos el rojo, el azul y el verde.
Estos procesos permiten aislar y resaltar un solo componente de color en una
imagen, lo que puede resultar útil en diversas aplicaciones de procesamiento de
imágenes.