09/Diciembre/2021

Acelerador gráfico
Introducción

E l modelo RGB (Red, Green, Blue) es el modo por defecto para las imágenes digitales
y los monitores de ordenador muestran siempre los colores en este modelo. Las imágenes
RGB utilizan tres colores primarios para reproducir en pantalla hasta 16.7 millones de colores.

El modelo RGB es un modelo de color basado en la síntesis aditiva, con el que es posible
representar un color mediante la mezcla por adición de los tres colores luz primarios. Para
indicar con qué proporción mezclamos cada color, se asigna un valor a cada uno de los colores
primarios, de manera que, por ejemplo, el valor “0” significa que no interviene en la mezcla
dicho color y, a medida que ese valor aumenta, se entiende que aporta más intensidad a la
mezcla. Aunque el intervalo de valores podría ser cualquiera, es frecuente que cada color
primario se codifique con un byte (8 bits). Así, de manera usual, la intensidad de cada una de
las componentes se mide según una escala que va del 0 al 255.
Para representar los colores se utilizan los códigos en hexadecimal dispuestos en tres pares,
los cuales muestran la intensidad de cada color según el porcentaje de luminosidad. Así por
ejemplo para obtener un 25% de luminosidad en el color rojo habría que multiplicar el valor
máximo de ese píxel (255 ya que estamos trabajando con 8 bits o 1 byte) por 0.25 y así
obtendríamos el “espacio de color” que se requiere en la escala utilizada.

Objetivo
Se plantea realizar el procesamiento de una imagen RGB apoyándonos en el uso de Matlab y
ModelSim con los cuales, usando los conocimientos previamente adquiridos a lo largo de la
materia, se pueda desarrollar una descripción que nos permita manipular datos de una
imagen como entrada de texto para generar efectos que puedan ser recuperados y mostrados
en una nueva imagen de salida.
Para este trabajo consideramos 4 conversiones: RGB a escala de grises, la multiplicación de
un escalar por cada píxel, RGB a blanco y negro y una conversión donde se realicen las
operaciones lógicas AND, OR y XOR de cada píxel por una constante.

Desarrollo
La siguiente metodología permitió llevar a cabo cada conversión descrita anteriormente.

Procesamiento de los datos de la imagen

Inicialmente se escogió la imagen a convertir, para este trabajo todas las conversiones se
efectuaron a partir de la imagen Lena.bmp. La imagen seleccionada se introdujo dentro de un
programa elaborado en Matlab, en donde se obtuvo una salida de texto que almacena una
matriz con los datos RGB de la imagen.
09/Diciembre/2021

Imagen Original Lena.bmp

Descripción en VHDL
Para el siguiente paso se realizó una descripción de VHDL en donde se efectuaron operaciones
aritméticas con una entrada de texto que contiene los datos RGB de la imagen con la que se
trabajó. La entrada de texto de esta descripción es la salida de texto que se obtuvo de Matlab.
A continuación, se presentan y explican las descripciones que se realizaron para cada
conversión mostrando de igual forma su diagrama conceptual.
Se utiliza una misma entidad para los tres primeros casos y las mismas librerías IEEE std logic
y numeric para todos los casos.

library IEEE;
use IEEE.std_logic_1164.all;
use ieee.numeric_std.all;

entity RGB2Gray is
port (
r, g, b : in std_logic_vector(7 downto 0);
gr : out std_logic_vector(7 downto 0)
);
end RGB2Gray;
09/Diciembre/2021

RGB a Escala de Grises

Las constantes decimales por las que se multiplica cada color generan en este caso resultados
que aproximan la imagen original a su escala de grises.

architecture arch of RGB2Gray is

signal x1, x2, x3:std_logic_vector (7 downto 0);
begin
gr <= std_logic_vector(unsigned(x1) + unsigned(x2) + unsigned(x3));
x1 <=std_logic_vector(shift_right(unsigned(r),2));
x2 <=std_logic_vector(shift_right(unsigned(g),1));
x3 <=std_logic_vector(shift_right(unsigned(b),3));
end arch;

Multiplicación de Cada Píxel Por un Escalar

El valor de la respectiva constante por la que se multiplica en este caso a cada color oscurece
la imagen original, ajustándose con el modelo RGB.

architecture arch of MultEscalar is

signal x1, x2, x3: std_logic_vector (7 downto 0);
begin
ME <= std_logic_vector(unsigned(x1) + unsigned(x2) + unsigned(x3));
x1 <=std_logic_vector(shift_right(unsigned(r),1));
x2 <=std_logic_vector(shift_right(unsigned(g),6));
x3 <=std_logic_vector(shift_right(unsigned(b),6));
end arch;
09/Diciembre/2021

RGB a Blanco y Negro

El valor del coeficiente con la que se multiplica cada color para este caso genera que los
colores se aproximen a su valor de luminosidad más cercano, así los colores más luminosos
se vuelven al blanco y los más oscuros al negro. Para la siguiente descripción se hace uso del
tipo de dato “signed” (que van del rango −2𝑛−1 𝑎 (2𝑛−1 − 1)).

architecture arch of BlackAWhite is

signal x1, x2, x3, x4:std_logic_vector (7 downto 0);
begin
BW <= std_logic_vector(signed(x1) + signed(x2) + signed(x3));
x1 <=std_logic_vector(shift_right(signed(r),4));
x2 <=std_logic_vector(shift_right(signed(g),4));
x3 <=std_logic_vector(shift_right(signed(b),4));
end arch;
09/Diciembre/2021

Operaciones lógicas con And,Or,Xor

El valor de la constante c (de tamaño de 8 bits, ya que cada canal del modelo RGB mide
también 8 bits) a simple vista puede ser completamente arbitrario, pero con determinados
valores de este en ciertas salidas se obtiene resultados particulares que se acomodan con el
modelo RGB.

entity project_ej4 is
port (
r, g, b : in std_logic_vector(7 downto 0);
rslt_AND, rslt_OR, rslt_XOR : out std_logic_vector(7 downto 0)
);
end project_ej4;
09/Diciembre/2021

Architecture arch of project_ej4 is

Constant c: std_logic_vector (7 downto 0):=(7|5|3|1=>’1’, others=>’0’);

Signal and_r, and_g, and_b:std_logic_vector (7 downto 0);

Signal or_r, or_g, or_b:std_logic_vector (7 downto 0);

Signal xor_r, xor_g, xor_b:std_logic_vector (7 downto 0);

Begin

Rslt_AND<= std_logic_vector(unsigned(and_r) + unsigned(and_g) + unsigned(and_b));

And_r<=r and c;

And_g<=g and c;

And_b<=b and c;

Rslt_OR<= std_logic_vector(unsigned(or_r) + unsigned(or_g) + unsigned(or_b));

Or_r<=r or c;

Or_g<=g or c;

Or_b<=b or c;

Rslt_XOR<= std_logic_vector(unsigned(xor_r) + unsigned(xor_g) + unsigned(xor_b));

Xor_r<=r xor c;

Xor_g<=g xor c;

Xor_b<=b xor c;

End arch;
09/Diciembre/2021

Análisis de Resultados
Escala de grises Operaciones lógicas AND, OR y XOR

Resultado de operación OR con valor de

c=11111111

Resultado de operación AND con valor de

Multiplicación de Cada Píxel Por un
c=00000000
Escalar

RGB a Blanco y Negro

Resultado de operación AND, OR y XOR,

respectivamente, con valor de
c=10101010
09/Diciembre/2021

Conclusiones
En este trabajo estudiamos las tonalidades de la escala RGB obteniendo resultados
satisfactorios para el procesamiento de la imagen prevista en nuestro objetivo.
Para los primero 3 casos (RGB a Escala de Grises, multiplicación por un escalar y la conversión
a blanco y negro) se necesitaron coeficientes que hicieran posible la manipulación de la
imagen conforme a lo planeado en nuestro objetivo.
Para el último punto (Operaciones lógicas con AND, OR, XOR) se generaron conversiones con
las compuertas AND, OR, XOR y en cada una de ellas la constante fue determinante para la
manipulación de la imagen resultante, ya que al hacer la operación lógica con la compuerta
and por una constante 010 el resultado obtenido fue una imagen en negro, lo contario ocurrió
al hacer la misma operación, pero con la compuerta OR con 25510. Cuando se hacía
operaciones con la compuerta XOR la imagen parece contener más dispersión en sus colores
y se hizo la observación que los colores se invertían respecto a la imagen con la compuerta
anterior (OR).

Referencias:
• Jesús Flores (2009),” Síntesis digital de color utilizando tonos de gris”, MX, SLP,
UASLP Facultad de Ciencias.
• Pong P. Chu (2006), “RTL HARDWARE DESIGN USING VHDL” EUA, Ohio, Cleveland
State University.
09/Diciembre/2021

Distribución del Trabajo

Nombres de los integrantes:
-José Luis Romero Vázquez
1)Escala de grises
2)Convierte la imagen a una imagen en blanco y negro
3)Introducción y objetivo
4)Resultados
5)Descripciones VHDL mostrando consideraciones
-Juan Alberto Moreno Castro
1)Escala de grises
2)Convierte la imagen a una imagen en blanco y negro
3) Diagramas conceptuales del proyecto
4)Resultados
5)Descripciones VHDL mostrando consideraciones
-Ulises Antonio Sánchez Rodríguez
1)Multiplicación por un escalar cada píxel de la Imagen
2)Convierte la imagen a una imagen en blanco y negro
3)Resultados
4)Conclusiones
5)Descripciones VHDL mostrando consideraciones
-Gerardo Manuel Mata Hernández
1)Realizar las operaciones lógicas AND, OR y XOR de cada píxel por una constante
2)Diagramas conceptuales del proyecto
3)Resultados
4)Descripciones VHDL mostrando consideraciones
-Misael Ortega Guillén
1)Multiplicación por un escalar cada píxel de la Imagen
2)Convierte la imagen a una imagen en blanco y negro
3)Resultados
4)Conclusiones
5)Descripciones VHDL mostrando consideraciones