UNIVERSIDAD CATÓLICA DE SANTA MARÍA

ESCUELA PROFESIONAL DE INGENIERÍA ELECTRÓNICA

ASIGNATURA:
VISION ARTIFICIAL

TRABAJO:
IDENTIFICACIO DE COLORES

ALUMNOS:

 Quintanilla Chávez Nickolae

 Dennis Ramos

DOCENTE:
ING. PEDRO RODRIGUEZ

HORARIO:
Lunes 17:00 a 18:30 hrs.

Arequipa – Perú

2019
1.- INTRODUCCION

El color es una de las características que nos permite a los seres humanos identificar y clasificar
los objetos. La percepción visual del color se genera en nuestro cerebro a partir de las ondas
electromagnéticas reflejadas por los objetos y captadas por los ojos. Desde el punto de vista del
procesamiento de imágenes por computador, es preciso recurrir a los llamados espacios de color,
se trata de conjuntos de fórmulas matemáticas que permiten describir los colores y
descomponerlos en distintos canales.

Los espacios de color más utilizados son el RGB y el CMYK, debido a que el modelo RGB se
utiliza en periféricos como pantallas, cámaras y escáneres, y el modelo CMYK en impresoras.
En este trabajo se analizará también el sistema de coordenadas tridimensional (tono, saturación e
intensidad) del espacio de color HSI, donde cada color está representado por un punto en el
espacio.

1.1.- Espacios de Color

Existen diversos espacios para representar los colores. Un espacio de color es un

método de representación por el que se pueda especificar, crear o visualizar cualquier
color. La especificación numérica de un color se efectúa mediante tres cantidades
(luminancias) que definen dicho color de forma cualitativa y cuantitativamente.
Dependiendo del tipo de sensor y aplicación se han desarrollado diversos espacios de
colores que facilitan el empleo de esta característica. Así el hombre distingue un color
de otro dependiendo de su tono, brillo y colorido. En la televisión se trabaja con la
componente roja, verde y azul, mientras que para la impresión se utiliza cían, magenta,
amarillo y negro
2.- CODIGO EN MATLAB

vid=imread ('D:\vision\000001.jpeg');

A
h=imshow(vid);
hp=impixelinfo;
set(hp,'Position',[5 1 300 20]);

A: Los comandos imread y impixelinfo permiten obtener el valor del pixel (color), que
queremos identificar en nuestro programa

OBJ = VideoReader('D:\color.avi');
numFrames = OBJ.NumberOfFrames;
n=numFrames;
Folder = 'D:\vision';
for iFrame = 1:n
frames = read(OBJ, iFrame);
imwrite(frames, fullfile(Folder, sprintf('%06d.jpeg', iFrame)));
end

B
FileList = dir(fullfile(Folder, '*.jpeg'));
for iFile = 1:length(FileList)
aFile = fullfile(Folder, FileList(iFile).name);
img = imread(aFile);
end

myPath= 'D:\vision'; %'

fileNames = dir(fullfile(myPath, '*.tif'));
C = cell(length(fileNames), 1);
for k = 1:length(fileNames)
filename = fileNames(k).name;
C{k} = imread(filename);
end

B: Este programa permite convertir el video en imágenes utilizando el comando

VideoReader para leer el video, el comando read para leer el numero de frames del video
y el comando imwrite para escribirlos en una carpeta designada en la variable FileList
COLOR ROJO

imR=double(vid(:,:,1));
imG=double(vid(:,:,2));
imB=double(vid(:,:,3));

imagenR=(imR-imG-imB);
imagen_Binaria=imagenR > -20;

imagen_Binaria_filtrada = medfilt2(imagen_Binaria); C
mascara=1-imagen_Binaria_filtrada;

imagen_roja=double(imagenGris)/255;
imagen_verde=double(imagenGris).* mascara/255;
imagen_azul=double(imagenGris).* mascara/255;

imagen_final=cat(3,imagen_roja,imagen_verde,imagen_azul);
figure
imshow(imagen_final)

C: Para poder identificar el color rojo , se utiliza un rango en el valor del color rojo, para
que pueda identificarlo, y es representado por la variable Imagen_Binaria. Después se
utiliza el filtro medfilt2 y se crea una mascara con la diferencia del valor unitario y la
imagen binaria filtrada. Despues a la imagen roja se le divide entre los 255 valores de
color (pixeles) y para la imagen final se usa el comando cat para concantenar la imagen
roja, verde y azul y obtener en la imagen final solo el color que queremos identificar en la
imagen.

COLOR AZUL

imR=double(vid(:,:,1));
imG=double(vid(:,:,2));
imB=double(vid(:,:,3));

imagenB=(imB-imR-imG);
imagen_Binaria=imagenB > 0;

imagen_Binaria_filtrada = medfilt2(imagen_Binaria); D
mascara=1-imagen_Binaria_filtrada;

imagen_roja=double(imagenGris).* mascara/255;
imagen_verde=double(imagenGris).* mascara/255;
imagen_azul=double(imagenGris)/255;

imagen_final=cat(3,imagen_roja,imagen_verde,imagen_azul);
figure
imshow(imagen_final)

D: Realizamos los mismos pasos que la explicación de la parte C, solo que lo único que
variamos es el valor numérico que se le da en la comparación de la variable de la imagen
Binaria
COLOR VERDE

imR=double(vid(:,:,1));
imG=double(vid(:,:,2));
imB=double(vid(:,:,3));

imagenG=(imG-imR-imB);
imagen_Binaria=imagenG >-30;
imagen_Binaria_filtrada = medfilt2(imagen_Binaria);

mascara=1-imagen_Binaria_filtrada; E
imagen_roja=double(imagenGris).* mascara/255;
imagen_verde=double(imagenGris)/255;
imagen_azul=double(imagenGris).* mascara/255;

imagen_final=cat(3,imagen_roja,imagen_verde,imagen_azul);
figure
imshow(imagen_final)

E: Realizamos los mismos pasos que la explicación de la parte C, solo que lo único que
variamos es el valor numérico que se le da en la comparación de la variable de la imagen
Binaria

EJEMPLO:

Utilizamos el comando impixelinfo, que permite conocer el valor del pixel (color) que
queremos identificar en la imagen de nuestro programa.

vid=imread ('D:\vision\000001.jpeg');

h=imshow(vid);
hp=impixelinfo;
set(hp,'Position',[5 1 300 20]);

Valor pixel Color Rojo

Valor pixel Color Azul

Valor pixel Color Verde

Utilizando el comando videoreader, leemos el video avi localizado en la unidad D:,
para convertirlo en frames utilizando la variable Filelist, el comando read y
imwrite , y convertir cada frame en una imagen en una carpeta ya establecida, la
cual es D:\VISION

OBJ = VideoReader('D:\color.avi');
numFrames = OBJ.NumberOfFrames;
n=numFrames;
Folder = 'D:\vision';
for iFrame = 1:n
frames = read(OBJ, iFrame);
imwrite(frames, fullfile(Folder, sprintf('%06d.jpeg', iFrame)));
end

FileList = dir(fullfile(Folder, '*.jpeg'));

for iFile = 1:length(FileList)
aFile = fullfile(Folder, FileList(iFile).name);
img = imread(aFile);
end

myPath= 'D:\vision'; %'

fileNames = dir(fullfile(myPath, '*.tif'));
C = cell(length(fileNames), 1);
for k = 1:length(fileNames)
filename = fileNames(k).name;
C{k} = imread(filename);
end
vid=imread ('D:\vision\000001.jpeg');
imshow(vid)

Imagen Original
vid=imread ('D:\fotocolor.jpeg');
imshow(vid)

imagenGris=rgb2gray(vid);

Convertimos la imagen a escala de grises

imR=double(vid(:,:,1));
imG=double(vid(:,:,2));
imB=double(vid(:,:,3));

imagenR=(imR-imG-imB);
imagen_Binaria=imagenR > -20;
imagen_Binaria_filtrada = medfilt2(imagen_Binaria);
Aplicando el filtro medfilt2 en la imagen binaria o que se encuentra en
dos colores, el filtro permite reducir en la imagen el ruido

mascara=1-imagen_Binaria_filtrada;

imagen_roja=double(imagenGris)/255;
imagen_verde=double(imagenGris).* mascara/255;
imagen_azul=double(imagenGris).* mascara/255;
Aca se selecciona la región a través del escalado de grises utilizando
la mascara y un valor determinado en cada parte de la imagen según el
color

imagen_final=cat(3,imagen_roja,imagen_verde,imagen_azul);
figure
imshow(imagen_final)
La imagen final tiene seleccionado la región roja de toda la imagen

3.- Comandos de Matlab

impixelinfo crea una herramienta de información de

píxeles en la figura actual
VideoReader crea un objeto vpara leer datos de video del
archivo nombrado filename.

Imread Lee la imagen del archivo especificado por

filename, deduciendo el formato del archivo
de su contenido. Si filenamees un archivo de
imágenes múltiples, entonces imread lee la
primera imagen del archivo.

Imshow muestra la imagen en escala de grises en

una figura. Imshow utiliza el rango de
visualización predeterminado para el tipo de
datos de la imagen y optimiza las figuras, los
ejes y las propiedades del objeto de imagen
para la visualización de la imagen.

rgb2gray convierte la imagen truecolor RGBa la imagen

en escala de grises I. La rgb2grayfunción
convierte las imágenes RGB a escala de
grises eliminando la información de matiz y
saturación mientras retiene la luminancia

medfilt2 Realiza el filtrado mediano de la imagen en

dos dimensiones. Cada píxel de salida
contiene el valor de la mediana en un
vecindario de 3 por 3 alrededor del píxel
correspondiente en la imagen de entrada.
 El filtrado mediano es una operación no lineal
que se usa a menudo en el procesamiento
de imágenes para reducir el ruido de "sal y
pimienta". Un filtro de mediana es más
efectivo que la convolución cuando el
objetivo es reducir el ruido y preservar los
bordes simultáneamente. Para obtener
información sobre consideraciones de
rendimiento

CAT Concatena los arreglos y concatena todas las

matrices de entrada

imwrite escribe datos de imagen en el archivo

especificado filename

4.- Filtro Media 2D

Filtro de la media

El filtro de la media es el más simple, intuitivo y fácil de implementar

para suavizar imágenes que el de la mediana, es decir, reducir la

cantidad de variaciones de intensidad entre píxeles vecinos.

Filtro de la media

¿Cómo funciona? Se visita cada píxel de la imagen y se reemplaza

por la media de los píxeles vecinos. Se puede operar mediante

convolución con una máscara determinada.

Filtros en el dominio del espacio: filtros lineales

Ejemplo de máscara

3x3 para el filtro de la

media:
El modelo matemático es el siguiente

Fuentes de degradación de la imagen:

 Asociadas al propio proceso de captura

 a la iluminación

 a la óptica de la cámara

 al canal de transmisión.