Guía de Visión Artificial

Guía de visión artificial año 2018
Mario Andrés Pastrana Triana
Primera clase:
Se puede definir la “Visión Artificial” como un campo de la “Inteligencia

Artificial” que, mediante la utilización de las técnicas adecuadas, permite la obtención,
procesamiento y análisis de cualquier tipo de información especial obtenida a través de
imágenes digitales.
La visión artificial la componen un conjunto de procesos destinados a realizar el
análisis de imágenes. Estos procesos son: captación de imágenes, memorización de la
información, procesado e interpretación de los resultados.
¿Qué es una imagen digital?
Una imagen digital se considera como una cuadrícula. Cada elemento de esa cuadrícula se
llama Píxel (Picture element). Para cargar una imagen en Matlab se utiliza el comando
imread().
Figura 1: pixeles de una imagen RGB.

Tratamiento de imágenes:
Binarización de una imagen.
El tratamiento de imágenes sirve para detectar aspectos específicos de una imagen (como plagas
en imágenes, círculos, cuadrados, etc), para realizar esto se precisan de ciertos factores para
realizar el respectivo análisis.
Figura 2: Procesamiento de imagen para encontrar hierva no deseada.
Lo principal, como se observa en la figura anterior es binarizar la imagen, esto se puede realizar de
dos maneras. Creando una función de binarización(se puede consultar en internet la función de
binarización) o utilizar el comando im2bw.
Figura 3: Imagen (A) binarización por la función de Matlab, imagen (B) original en RGB.
Estas imágenes (imágenes binarizadas), poseen la característica de solo poseer ceros y unos en sus
pixeles, tal como se observa en la figura 4.
Figura 4: Características de los pixeles de una imagen binarizada
El comando para saber los pixeles de una imagen en Matlab se llama imtool().
Código para la binarización de una imagen:

clc;clear all;
I = imread('anabel.jpg'); %carga la imagen
ibn=im2bw(I,0.46);
figure (1)
imshow(I) % Muestra la imagen RGB
figure(2)
imshow(ibn) % Muestra la imagen binarizada
figure(3)
imtool(ibn) % Muestra las características de la imagen binarizada
NOTA: Las imágenes deben estar en la misma carpeta que el programa que se ejecuta, además el
número 0.46 es el porcentaje de binarización (se recomienda variarlo para observar que sucede).
Imagen en escala de grises:

A diferencia de una imagen binarizada una imagen en escala de gris posee valores de cero(0) a
doscientos cincuenta y cinco (255).
Figura 5: Imagen (A) en RGB, imagen (B) en escala de grises.
Figura 6: Pixeles de una imagen en escala de grises.
Código para colocar una imagen en escala de grises:

clc;clear all;
I = imread('anabel.jpg'); %carga la imagen
ibg=rgb2gray(I);
figure (1)
imshow(I) % Muestra la imagen RGB
figure (3)
imshow (ibg) %Muestra imagen en escala de grises
figure(4)
imtool (ibg)
Imagen RGB:
Esta imagen posee tres componentes (Componente rojo, azul y verde), lo cual permite observar 17
millones de colores(bueno casi 16.581.375).
Figura 7: Matrices roja, verde y azul de una imagen RGB.
Estas matrices rojas, verdes y azules se pasan a escala de grises(o binarizarlas) para realizar su
respectivo tratamiento de imagen.
Figura 8: Matrices roja, verde y azul en escala de grises.
Código para obtener las componentes R, G y B.

clc;clear all;
RGB = imread('anabel.jpg'); %carga la imagen
R = RGB;, R(:,:,2:3) = 0; % Imagen con G y B nulas
G = RGB;, G(:,:,[1,3]) = 0; % Imagen con R y B nulas
B = RGB;, B(:,:,1:2) = 0; % Imagen con R y G nulas
f1 = figure(1);, set(f1, 'color', 'w');, clf; % Crea Figura
subplot(1,4,1); % Selecciona el 1 subplot
imshow(RGB); title('Imagen Color'); % Visualiza imagen color
imshow(R); title('Componente Rojo'); % Visualiza componente R
imshow(G); title('Componente Verde'); % Visualiza componente G
imshow(B); title('Componente Azul'); % visualiza componente B
Código para obtener las componentes R, G y B en escala de grises:
clc;clear all;
RGB = imread('anabel.jpg'); %carga la imagen
imshow(RGB(:,:,1)); title('Componente Rojo'); % Visualiza componente R
imshow(RGB(:,:,2)); title('Componente Verde'); % Visualiza componente G
imshow(RGB(:,:,3)); title('Componente Azul');
Filtro para procesamiento de imágenes:
Para eliminar ruido (datos no deseados), de nuestras imágenes se precisa de usar filtros, en el caso
de Matlab el filtro a utilizar se llama bwareaopen(bw,40), el valor bw es una imagen binarizada y
el numero 40 es el tamaño del ruido a eliminar(por lo general hay que jugar con la binarización y
con el valore del filtro para obtener mejores resultado).
Ejercicio
Tomar una imagen en RGB, obtener cualquier componente (una opción en rojo) en escala de
grises, realizar una binarización y posteriormente aplicarle el filtro.
Programa:
i=imread('anabel.jpg');% Carga la imagen RGB
R=i(:,:,1); %Toma la componente en rojo de la matriz RGB
bw=im2bw(R,0.79);% binarización de la componente en rojo
bwm1=bwareaopen(bw,79610); % Aplicación del filtro
figure (1)
imshow(i); %muestra la imagen RGB
figure(2)
imshow(R);% muestra la imagen de la componente roja
figure(3)
imshow(bwm1);% muestra la imagen aplicando el filtro
figure (4)
imshow(bw) %muestra la imagen binarizada
La finalidad del programa anterior es obtener la bluza, cara, cuello de la imagen RGB.
Figura 9: Ejercicio 1.
SEGUNDA CLASE:
En esta segunda sección se hablará del comando bwconncomp(), el cual permite encontrar los
objetos en una imagen binarizada, además utilizando el comando labelmatrix () permite etiquetar
las regiones encontradas con el comando anterior lo cual da como resultado que se pueda utilizar
el comando label2rgb() para visualizarla como se observa en las siguiente figuras:
Figura 10: Pre procesamiento de imagen de varios objetos del mismo color.
Figura 11: Negación de la imagen binarizada.

Esta negación se utiliza para trabajar con los comandos anteriormente descritos.
Figura 12: Figuras etiquetadas.
Ya con las figuras etiquetadas las podemos separar, para trabajar con cada objeto
independientemente.
Figura 13: Objetos separados por etiquetas.
Ya separando los objetos por etiquetado podemos cambiar los colores o colocar nombres (como
un programa que caracteriza objetos).
Figura 14: Cambio de colores de las imágenes originales.
Ademas de jugar con las apariencias podemos colocar el nombre a cada imagen para clasificarlas,
para eso se precisa de conocer los siguientes comandos, bwlabel () permite etiquetar las zonas
donde están los objetos, regionprops() permite conocer las estadísticas de la imagen, dando a
conocer aspectos propios de la imagen.
Este ultimo comando despliega toda una lista de estadísticas de una imagen como lo muestra la
siguiente figura:
Figura 15: Propiedades de una imagen.
Con las características de la imagen podemos colocarles nombre mediante el comando text() y
utilizando la propiedad del centroid, lo cual da como resultado final la siguiente imagen.
Figura 16 imagen original con nombres.
El código que representa todo el trabajo anterior esta dado por:

clear all;clc
I=imread('ejercicio2.jpg');% Carga la imagen RGB
R=I(:,:,1); %Toma la componente en rojo de la matriz RGB
G=I(:,:,2); %Toma la componente en verde de la matriz RGB
B=I(:,:,3); %Toma la componente en azul de la imagen RGB
bw=im2bw(R,0.9);% binarización de la componente en rojo
bwm1=bwareaopen(bw,20000); % Aplicación del filtro
imshow(I); title('Imagen Color'); % Visualiza imagen color
imshow(R); title('Componente Rojo'); % Visualiza componente R
imshow(bw); title('Imagen binarizada'); % Visualiza componente G
imshow(bwm1); title('Imagen con filtro'); % visualiza componente B
figure (2)
imshow(bwm1);%Muestra la imagen con filtro
bwm1=not(bwm1);%niega la imagen con filtro
bwm1=bwareaopen(bwm1,10);%filtro paraeliminar valores menores a 10
pixeles
CC = bwconncomp(bwm1); %Comando para encontrar elementos en una imagen
binarizada
L = labelmatrix(CC);% crea etiquetas para realizar la caracterización
[m,n]=size(L);%Halla las filas y columnas de la matriz L
T1=1; %Etiqueta de la figura 1
for i=1:m
for j = 1:n
if(L(i,j)~=T1) %Permite hallar solo la figura 1
salida1(i,j) = 0;
else
salida1(i,j) =1;
end
salida2(i,j) = 0;
else
salida2(i,j) =1;
end
if(L(i,j)~=T3) % Permite hallar solo la figura 3
salida3(i,j) = 0;
else
salida3(i,j) =1;
end
end
end
RGB = label2rgb(L,@jet, [.5 .5 .5]); %Construye la imagen RGB con las
etiquetas
figure(3)
imshow(RGB);
%%
primera=bwlabel(salida1); %Se etiqueta la primera imagen para hallar sus
caracteristicas
segunda=bwlabel(salida2); %%Se etiqueta la segunda imagen para hallar sus
caracteristicas
tercera=bwlabel(salida3); %%Se etiqueta la tercera imagen para hallar sus
caracteristicas
ESTADISTICAS1= regionprops(primera,'all');%Halla las propiedas de la
imagen 1
ESTADISTICAS2= regionprops(segunda,'all');%Halla las propiedas de la
imagen 2
ESTADISTICAS3= regionprops(tercera,'all');%Halla las propiedas de la
imagen 3
imshow(salida1); title('Meza'); %
imshow(salida2); title('zapato'); %
imshow(salida3); title('silla'); %
%% cambiar color
R(salida1==1)=0;
B(salida1==1)=0;
G(salida1==1)=255;
silla_verde=cat(3,R,G,B);
R(salida2==1)=0;
B(salida2==1)=255;
G(salida2==1)=0;
zapato_azul=cat(3,R,G,B);
R(salida3==1)=0;
B(salida3==1)=100;
G(salida3==1)=150;
mesa_diferente=cat(3,R,G,B);
figure (5)
imshow(mesa_diferente)
%%
EJEX=ESTADISTICAS1(1).Centroid(2); %Guarda el dato de centroide x de la
figura 1
EJEY=ESTADISTICAS1(1).Centroid(1); %Guarda el dato de centroide y de la
figura 1
EJEX1=ESTADISTICAS2(1).Centroid(2); %Guarda el dato de centroide x de la
figura 2
EJEY1=ESTADISTICAS2(1).Centroid(1);%Guarda el dato de centroide y de la
figura 2
EJEX2=ESTADISTICAS3(1).Centroid(2);%Guarda el dato de centroide x de la
figura 3
figura 3
xt=[EJEX,EJEX1,EJEX2];% Se colocan todos los centroides x en un vector
yt=[EJEY,EJEY1,EJEY2];% se colocan todos los centroides y en un vector
str={'mesa','zapato','silla'}%se coloca el texto de cada par de
centroides
figure(6),imshow(I)
text(yt,xt,str) %Se aplica el comando text a la imagen RGB inicial
Erosión
Esta función en Matlab permite desagrupar objetos que se encuentran unidos como en la
siguiente figura:
Figura 17: Imagen normal vs imagen erosionada
Se aplica mediante los siguientes comandos

se = strel('disk',11);
erodedBW = imerode(imagen_en_binario,se);
La función strel crea un elemento de estructura morfológica, pudiéndose aplicar a la función

imerode.
Dilatar:
Esta función en Matlab permite definir mejor un objeto (también lo hace un poco mas
grande).
Figura 18: Imagen normal vs imagen erosionada.
Se aplica mediante los siguientes comandos.

dilatedBW = imdilate(imagen_binarizada,se);
Closing:
Esta función permite dilatar y erosionar al mismo tiempo, permitiendo definir un objeto
dejando con su forma original.
Figura 19: Imagen original vs imagen aplicando closing.

closeBW = imclose(originalBW,se);
EJERCICIO 2
Con la siguiente imagen identificar las diferentes frutas presentes(Por favor tratar de hacerlo solo
antes de ver el código):
Figura 20: Frutas a clasificar
Figura 21: Matrices en RGB
En este punto utilizamos la matriz con componente azul para realizar la binarización y posterior
procesamiento.
Figura 22: binarización de la matriz azul.
Figura 23: Imagen con filtro y closing

Figura 24: Imagen negada.
Figura 25: Imagen etiquetada.
Figura 26: Imágenes de cada fruta.

Figura 27: Resultado final
Código del ejercicio.

clc;clear all;
RGB= imread('ejercicio_23.jpg'); %carga la imagen
R=RGB(:,:,1); %Matriz Roja
G=RGB(:,:,2); %Matriz Verde
B=RGB(:,:,3); %Matriz Azul
b_b=im2bw(B,0.9); %Binarización de la matriz azul
figure (2)
figure(2)
imshow(b_b);
%% negacion y aplicacion del filtro
bwm1=bwareaopen(b_b,2000); % Aplicación del filtro
se = strel('disk',10); % Elemento estructurante
bwm1 = imclose(bwm1,se); % Operacion closing
bwnot=not(bwm1); %niega la imagen bwm1
figure(3)
imshow(bwnot)
bwm1=bwareaopen(bwnot,10);%filtro paraeliminar valores menores a 10
pixeles
CC = bwconncomp(bwnot); %Comando para encontrar elementos en una imagen
binarizada
for i=1:m
for j = 1:n
salida1(i,j) = 0;
else
salida1(i,j) =1;
end
salida2(i,j) = 0;
else
salida2(i,j) =1;
end
salida3(i,j) = 0;
else
salida3(i,j) =1;
end
salida4(i,j) = 0;
else
salida4(i,j) =1;
end
end
end
RGB1 = label2rgb(L,@jet, [.5 .5 .5]); %Construye la imagen RGB con las
etiquetas
figure(3)
imshow(RGB1);
%%
caracteristicas
segunda=bwlabel(salida2); %%Se etiqueta la segunda imagen para hallar sus
caracteristicas
tercera=bwlabel(salida3); %%Se etiqueta la tercera imagen para hallar sus
caracteristicas
cuarta=bwlabel(salida4); %%Se etiqueta la cuarta imagen para hallar sus
caracteristicas
imagen 1
imagen 2
imagen 3
ESTADISTICAS4= regionprops(cuarta,'all');%Halla las propiedas de la
imagen 4
imshow(salida1); title('Fresa'); %
imshow(salida2); title('Manzana'); %
imshow(salida3); title('Aguacate'); %
imshow(salida4); title('Naraja'); %
%%
figura 1
figura 1
figura 2
figura 2
figura 3
figura 3
figura 4
figura 4
xt=[EJEX,EJEX1,EJEX2,EJEX3];% Se colocan todos los centroides x en un
vector
yt=[EJEY,EJEY1,EJEY2,EJEY3];% se colocan todos los centroides y en un
vector
str={'fresa','Manzana','aguacate','naranja'}%se coloca el texto de cada
par de centroides
figure(6),imshow(RGB)
Tercera Clase.
Rotar una imagen.
Para realizar esta acción se precisa de utilizar el comando de imrotate(), el cual permite rotar la
imagen en cualquier ángulo.
Figura 28: Imagen original e imagen rotada 30 grados

RGB = imread('anabel.jpg'); % Carga la imagen
RGB_rotada = imrotate(RGB, 30 ); % Rota la imagen 30 grados
imshow(RGB); title('Imagen Original'); % Visualiza imagen color
imshow(RGB_rotada); title('Imagen Rotada'); % Visualiza imagen rotada
Recortar una imagen
Esta herramienta permite extraer unos pixeles específicos de la imagen (un recorte de la imagen),
el comando que permite realizar esto es el imcrop(imagen, [xmin,ymin,ancho,altura]).
Figura 29: Extracción de un recorte.

RGB_porcion = imcrop(RGB, [330, 80, 120, 70] );% Extrae Porcion
imshow(RGB); title('Imagen Original'); % Visualiza imagen original
imshow(RGB_porcion); title('Imagen extraida'); % Visualiza imagen
extraida
Extraer Bordes.
Esta función de que Matlab tiene predeterminada nos permite identificar los bordes de los objetos
de una imagen de manera fácil y sencilla permitiendo realizar un mejor tratamiento de imágenes.
El comando utilizado para esta tarea es el de edge(Gr,'canny'), donde Gr es la imagen en
escala de grises y canny es la función utilizada para hallar los bordes.
Utilizando la función sobel (la cual esta por defecto en caso tal que no se especifique la función).
Figura 30: Bordes con la función edge y sobel.

Gr = rgb2gray(RGB); % Imagen escala de grises
borde = edge(Gr,'sobel'); % Extrae los bordes
imshow(Gr); title('Imagen Escala de Grises'); % Visualiza imagen
imshow(borde); title('Bordes'); % Visualiza Bordes
Utilizando la función prewitt
Figura 31: Bordes con la función edge y prewitt.

borde = edge(Gr,'prewitt'); % Extrae los bordes
Utilizando la función Roberts
Figura 32: Bordes con la función edge y Roberts.

borde = edge(Gr,'roberts'); % Extrae los bordes
Utilizando la función Canny
Figure 33: Bordes con la función edge y canny.

borde = edge(Gr,'canny'); % Extrae los bordes
Función opening
Es básicamente erosión más dilatación.
Figura 34: Aplicación de la función opening en Matlab.

BW = imread('imagenE.bmp'); % Carga la imagen
openBW = imopen(BW,se); % Operacion Opening
imshow(BW); title('Imagen'); % Visualiza imagen
imshow(openBW); title('Opening'); % Visualiza imagen
Ejercicio de QUIZ de Robótica 2.

Con las 5 imágenes subidas al grupo de whatssap, detectar primero la llave en todas las fotos.
Figura 35: Llave y destornillador.

Solución Etiquetando solo la llave.
clc;clear all;
RGB= imread('2.jpeg'); %carga la imagen
[m n c]=size(RGB);
figure(2)
imshow(b_b);
pixeles
for i=800:m
for j = 1:n
if(bwm1(i,j)==1) %Permite hallar solo la figura 1
bwm1(i,j)=0;
end
end
end
binarizada
figure(3)
imshow(bwm1)
for i=1:m
for j = 1:n
salida1(i,j) = 0;
else
salida1(i,j) =1;
end
end
end
%%
caracteristicas
imagen 1
imshow(salida1); title('Llave'); %
%%
figura 1
figura 1
xt=[EJEX];% Se colocan todos los centroides x en un vector

yt=[EJEY];% se colocan todos los centroides y en un vector
str={'llave'}%se coloca el texto de cada par de centroides
Figura 36: Resultado del código.

Solución etiquetando el fondo, la llave, el destornillador y el ruido.
clc;clear all;
RGB= imread('5.jpeg'); %carga la imagen
[m n c]=size(RGB);
figure(2)
imshow(b_b);
pixeles
%
% for i=800:m
% for j = 1:n
% if(bwm1(i,j)==1) %Permite hallar solo la figura 1
% bwm1(i,j)=0;
% end
% end
% end
binarizada
no=CC.NumObjects;
figure(3)
imshow(bwm1)
for i=1:no
T(i)=i;
end
for i=1:m
for j = 1:n
if(L(i,j)~=T(1)) %Permite hallar solo la figura 1
salida1(i,j) = 0;
else
salida1(i,j) =1;
end
salida2(i,j) = 0;
else
salida2(i,j) =1;
end
salida3(i,j) = 0;
else
salida3(i,j) =1;
end
salida4(i,j) = 0;
else
salida4(i,j) =1;
end
end
end
%%
caracteristicas
segunda=bwlabel(salida2); %Se etiqueta la primera imagen para hallar sus
caracteristicas
tercera=bwlabel(salida3); %Se etiqueta la primera imagen para hallar sus
caracteristicas
cuarta=bwlabel(salida4); %Se etiqueta la primera imagen para hallar sus
caracteristicas
imagen 1
imagen 1
imagen 1
ESTADISTICAS4= regionprops(cuarta,'all');%Halla las propiedas de la
imagen 1
imshow(salida1); title('Fondo'); %
imshow(salida2); title('Ruido'); %
imshow(salida3); title('llave'); %
imshow(salida4); title('Destornillador'); %
%%
figura 1
figura 1
figura 1
EJEY1=ESTADISTICAS2(1).Centroid(1); %Guarda el dato de centroide y de la
figura 1
figura 1
figura 1
figura 1
figura 1
Area3=ESTADISTICAS3(1).Area;
Area4=ESTADISTICAS4(1).Area;
if (Area3<=Area4)
Ex3=EJEX2;
Ey3=EJEY2;
Ey2=EJEY3;
Ex2=EJEX3;
else
Ex3=EJEX3;
Ey3=EJEY3;
Ey2=EJEY2;
Ex2=EJEX2;
end
xt=[EJEX,EJEX1,Ex2,Ex3];% Se colocan todos los centroides x en un vector
yt=[EJEY,EJEY1,Ey2,Ey3];% se colocan todos los centroides y en un vector
str={'Fondo','ruido','Llave','Destornillador'}%se coloca el texto de cada
par de centroides
Figura 37: Resultado del código anterior.
Cuarta clase:
En esta cuarta clase se mostrara como capturar imágenes en tiempo real mediante el comando
imread(), el cual combinándolo con la aplicación ipwebcam
https://play.google.com/store/apps/details?id=com.pas.webcam&hl=es el cual se puede
descargar desde la play store de Android.
La combinación de estos dos comandos permite capturar fotos en tiempo real, para esto nos
disponemos a utilizar el siguiente comando de Matlab, el cual permite tomar solo 3 fotos en timpo
real:
for i=1:3
RGB=imread('http://192.168.1.5:8080/shot.jpg');
imshow(RGB)
pause(10)
end
Para tomar más fotos solo debemos aumentar el número tres de nuestro for al número que
queramos.
Ahora pasamos a la aplicación de ip webcam:

Figura 36: Aplicación de escritorio Ipwebcam
Esta es la aplicación que utilizaremos para realizar la respectiva captura de imagen en tiempo real.
Las ventajas de utilizar esta aplicación es que se puede instalar en cualquier teléfono Android y
convertirlo en un emisor de imágenes a bajo costo.
Una vez descargada e instalada la aplicación nos disponemos a abrirla e inicializar el servidor, el
cual nos da una dirección ip para cargar nuestra imagen.
Figura 37: Inicializar el servidor de nuestro aplicación ip webcam.
Por ultimo utilizamos la dirección ip para cargar la respectiva imagen.

Figura 38: Ip de nuestra cámara.
Con esta ip podremos capturar las imágenes en tiempo real de nuestr celular.
RGB=imread('http://192.168.1.5:8080/shot.jpg');
La cual colocaremos en el comando imread() como se muestra en el anterior código.
Ejercicio:
Utilizar el comando ipwebcam para la detección de un objeto (o varios en un ambiente

determinado).
En este caso la idea es detectar el raton rojo que poseo.
Figura 39: Ratón a detectar.

Resultados:
Figura 40: Imagen detectada 1
Figura 41: Imagen detectada 2.

Figura 42: Imagen detectada 3.
Código:
clc;clear all;
for i=1:3
RGB= imread('http://192.168.1.5:8080/shot.jpg'); %carga la imagen
[m n c]=size(RGB);
b_b=im2bw(R,0.8); %Binarización de la matriz azul
figure(2)
imshow(b_b);
pixeles
%
% for i=800:m
% for j = 1:n
% if(bwm1(i,j)==1) %Permite hallar solo la figura 1
% bwm1(i,j)=0;
% end
% end
% end
binarizada
no=CC.NumObjects;
figure(3)
imshow(bwm1)
%%
primera=bwlabel(bwm1); %Se etiqueta la primera imagen para hallar sus
caracteristicas
imagen 1
imshow(bwm1); title('raton'); %
%%
figura 1
figura 1
xt=[EJEX];% Se colocan todos los centroides x en un vector

yt=[EJEY];% se colocan todos los centroides y en un vector
str={'Raton'}%se coloca el texto de cada par de centroides
pause(30);
end
Quinta clase:
En esta quinta clase se mostrará como obtener los puntos de interés o características de una
imagen utilizando el Speeded-Up Robust Features o SURF, además de la identificación de un
objeto en una imagen determinada.
Obtener características de una imagen RGB.
Para obtener estas características se utilizará el comando de MATLAB llamado

detectSURFFeatures,el cual permite obtener los puntos de interés de una imagen en escala de
grises (o características).
La utilización de este comando viene dada por el siguiente código.
clear all; close all; clc;
%% Carga la imagen de referencia, y calcula los puntos de características

SURF
ref_img = imread('reina2.png'); %Carga la imagen en RGB
ref_img_gray = rgb2gray(ref_img); %La convierta a escala de grises
ref_pts = detectSURFFeatures(ref_img_gray); %Se aplica la detección de
puntos de interes
[ref_features, ref_validPts] = extractFeatures(ref_img_gray, ref_pts);
%Extrae de la imagen en escala de grises los puntos mas significativos
figure; imshow(ref_img); % muestra la imagen RGB

hold on; plot(ref_pts.selectStrongest(50)); %muestra los puntos de la
imagen en RGB
Figura 43: Imagen de referencia RGB con los puntos más relevantes.
Ademas se puede observar por separado cada uno de los puntos de interés como se observa en la
siguiente imagen:
Figura 44: 25 primeros puntos de interés de la imagen en RGB.
figure;
subplot(5,5,3); title('First 25 Features');
for i=1:25
scale = ref_pts(i).Scale;
image = imcrop(ref_img,[ref_pts(i).Location-10*scale 20*scale
20*scale]);
subplot(5,5,i);
imshow(image);
hold on;
rectangle('Position',[5*scale 5*scale 10*scale
10*scale],'Curvature',1,'EdgeColor','g');
end
Se puden observar los diferentes puntos por separado de la imagen en RGB estos puntos son
importantes para realizar la respectiva detección de la imagen en una imagen mas general.
Ahora tomamos una imagen mas general como la que sigue acontinuación:
Figura 45: Imagen general con la reina de picas.
Ahora hallamos los respectivos puntos de interés como lo hicimos anteriormente.
Figura 46: Imagen 45 con los puntos de interés hallados.
El código utilizado es el siguiente:

image = imread('reina.jpg');
I = rgb2gray(image);
% Detecta las caracteristicas.
I_pts = detectSURFFeatures(I);
[I_features, I_validPts] = extractFeatures(I, I_pts);
figure;imshow(image);
hold on; plot(I_pts.selectStrongest(100));
Ahora se hallan los puntos coincidentes entre la imagen de referencia y la imagen general con el
siguiente código.
index_pairs = matchFeatures(ref_features, I_features); %Encuentra los

puntos coincidentes entre las dos imagenes
ref_matched_pts = ref_validPts(index_pairs(:,1)).Location; %Toma los
puntos de la imagen de referencia
I_matched_pts = I_validPts(index_pairs(:,2)).Location; %Toma los puntos
de la imagen en general
figure, showMatchedFeatures(image, ref_img, I_matched_pts,

ref_matched_pts, 'montage'); %Muestra las dos imagenes con los puntos
coincidentes
title('Mostrando todos los puntos');
Imagen 47: Imagen con los supuestos puntos comunes entre la imagen de referencia y la imagen
general.
Ahora nos disponemos a hallar solamente los puntos coincidentes, para eso se utilizara el
siguiente código:
gte = vision.GeometricTransformEstimator; %Estimar la transformación

geométrica a partir de pares de puntos coincidentes
gte.Method = 'Random Sample Consensus (RANSAC)';
[tform_matrix, inlierIdx] = step(gte, ref_matched_pts, I_matched_pts);

%Encuentra solamente los puntos realmente coincidentes
ref_inlier_pts = ref_matched_pts(inlierIdx,:);
I_inlier_pts = I_matched_pts(inlierIdx,:);
% Draw the lines to matched points
figure;showMatchedFeatures(image, ref_img, I_inlier_pts, ref_inlier_pts,
'montage');
title('Muestra solamente los puntos realmente coincidentes');
Figura 48: Todos los puntos coincidentes entre la imagen de referencia y la imagen general.
Ahora solo nos queda por detectar en la imagen general la de referencia utilizando el siguiente
código.
tform = maketform('affine',double(tform_matrix));%Crea un espacio de

transformacion estructural
[width, height,~] = size(ref_img); %halla el tamño de la imagen de
referencia
corners = [0,0;height,0;height,width;0,width];%crea una matriz con el
tamaño de la imagen de referencia
new_corners = tformfwd(tform, corners(:,1),corners(:,2));
figure;imshow(image); %Muestra la imagen general
patch(new_corners(:,1),new_corners(:,2),[0 0 1],'FaceAlpha',0.5);%Aplica
una cortina azul donde deberia estar la imagen de referencia
Figura 49: Detectando la imagen de referencia en la imagen general.
Con esto encontramos diferentes formas de detectar un objeto en una imagen general, teniendo
en cuenta que la imagen de referencia se toma aparte de la imagen general (la imagen de
referencia no es un recorte de la imagen general).
Sexta clase:
En la quinta clase identificamos estancias específicas, ahora la pregunta es ¿cómo identificamos

estancias generales como rostros, personas, carros, etc?
Para estas identificaciones se utilizará las funciones de MATLAB para visión artificial, la cual seria
bueno que cada persona las revisara en la casa (debido a que son muchas y el tiempo de clase se
iria en revisarlas todas).
Por ahora se comenzará con la identificación de cara por medio de imágenes anteriormente
tomadas, para el cual se tomarán las diferentes clases de la función “Visión” de MATLAB, las cuales
son:
 vision.CascadeObjectDetector
Esta clase permite identificar rostros, naris, ojos, etc. Mediante la utilización del algoritmo
de Viola-Jaime. Cabe aclarar que este algortimo sirve únicamente caundo los rostros se
encuentran de forma frontal.
 vision.ShapeInserter
Esta clase permite dibujar líneas, rectángulos, polígonos en una imagen determinada.
Ya con estos dos comandos se podrán realizar tareas de identificación de rostros tal como se
observa en la siguiente imagen.
Figura 50: Reconocimientos de rostros en MATLAB.
Figura 51: Reconocimiento de rostros mediante MATLAB
Se puede realizar este reconocimiento de imágenes con el siguiente código de MATLAB

I = imread('jorge.jpeg');
figure,imshow(I);
%% Detecta la cara en la imagen

% Crea un detector de objetos
faceDetector = vision.CascadeObjectDetector('FrontalFaceCART');
% Detecta las caras
bbox = step(faceDetector, I);
% Dibuja las cajas en la cara dentro de la imagen

shapeInserter =
vision.ShapeInserter('BorderColor','Custom','CustomBorderColor',[255 0
0]);
I_faces = step(shapeInserter, I, int32(bbox));
imshow(I_faces);
Además de realizar la detección de caras podemos realizar el respectivo etiquetado como se

muestra a continuación utilizando el comando insertObjectAnnotation.
Figura 52: Detección de imágenes con etiquetado.
Solo agregamos el comando anteriormente hablado tal como se muestra en el siguiente código.
I_faces = insertObjectAnnotation(I,'rectangle',bbox,'caras');
imshow(I_faces);
Además de detectar rostros, también se puede realizar la identificacón de la llamada comúnmente

foto de carnet la cual cubre desde el pecho hasta la cara, como sigue a continuación.
Código
%% Detecta el cuerpo superior de la imagen
% Crea un detector de objeto
bodyDetector = vision.CascadeObjectDetector('UpperBody');
bodyDetector.MinSize = [60 60];
bodyDetector.ScaleFactor = 1.05;
bbox_body = step(bodyDetector, I);

% Dibuja las cajas en la imagen
I_body = insertObjectAnnotation(I,'rectangle',bbox_body,'Foto Carnet');
figure, imshow(I_body);
Figura 53: Detección del cuerpo superior en MATLAB.
Como se observa a la función vision.CascadeObjectDetector se le cambio únicamente el

comando a utilizar, que paso de detección de caras a detección de cuerpo superior, asi mismo se
puede cambiar para detectar el par de ojos, los ojos por separados, naris,etc.
Figura 54: Detección de ojos mediante MATLAB.

Figura 55: Detección de ojo en cada individuo de prueba mediante MATLAB.
Figura 56: Detección de la nariz mediante MATLAB.
En algunas imágenes tendremos detecciones erradas (como se pudo observar con la de nariz y de
ojos), para eso es necesario aplicar un filtrado donde se obtiene solamente lo que necesitamos.
Figura 57: Supuestamente reconocimiento de rostros por MATLAB
Al aplicar el siguiente código se obtiene un resultado mucho mejor ya que realizamos un filtrado
de los diferentes rostros que tenemos en la imagen obteniendo única y exclusivamente las caras
de los personajes.
bbox_face = zeros(size(bbox_body));
for i=1:length(bbox_body)
Icrop = imcrop(I,bbox_body(i,:));
bbox = step(faceDetector,Icrop);
if ~isempty(bbox)
bbox_face(i,:) = bbox + [bbox_body(i,1:2)-1 0 0];
end
end
I_faces2 =
insertObjectAnnotation(I,'rectangle',bbox_face,1:size(bbox_face,1));
figure, imshow(I_faces2)
Figura 58: Detección final de los rostros de cada personaje.
Ahora adicionalmente se realizará el recorte de una imagen que se encontró por la detección de
carnet, como sigue a continuación.
Figura 59: Identificación de la foto de carnet de los estudiantes.

Figura 60: Recorte de la caja que contiene el cuerpo superior en MATLAB, e identificación del
rostro del estudiante.
De la figura anterior se observa que se realizó el respectivo recorte y se dispuso a la respectiva

detección de rostros. Todo esto se realizó con el respectivo código que sigue a continuación:
%% Extrae la cara a utilizar
Icrop = imcrop(I,bbox_body(4,:));
figure;imshow(Icrop);
bbox = step(faceDetector,Icrop);
hold on;rectangle('Position',bbox,'EdgeColor','y');

Guía de Visión Artificial

Cargado por

Copyright:

Formatos disponibles

Guía de Visión Artificial

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía de Visión Artificial

Cargado por

Copyright:

Formatos disponibles

Guía de visión artificial año 2018

Mario Andrés Pastrana Triana

Se puede definir la “Visión Artificial” como un campo de la “Inteligencia

Figura 1: pixeles de una imagen RGB.

Binarización de una imagen.

Figura 2: Procesamiento de imagen para encontrar hierva no deseada.

Figura 4: Características de los pixeles de una imagen binarizada

Código para la binarización de una imagen:

Imagen en escala de grises:

Figura 5: Imagen (A) en RGB, imagen (B) en escala de grises.

Figura 6: Pixeles de una imagen en escala de grises.

Código para colocar una imagen en escala de grises:

Figura 7: Matrices roja, verde y azul de una imagen RGB.

Figura 8: Matrices roja, verde y azul en escala de grises.

Código para obtener las componentes R, G y B.

Código para obtener las componentes R, G y B en escala de grises:

Filtro para procesamiento de imágenes:

Figura 11: Negación de la imagen binarizada.

Figura 12: Figuras etiquetadas.

Figura 13: Objetos separados por etiquetas.

Figura 14: Cambio de colores de las imágenes originales.

El código que representa todo el trabajo anterior esta dado por:

Figura 17: Imagen normal vs imagen erosionada

Se aplica mediante los siguientes comandos

La función strel crea un elemento de estructura morfológica, pudiéndose aplicar a la función

Se aplica mediante los siguientes comandos.

Figura 19: Imagen original vs imagen aplicando closing.

Figura 20: Frutas a clasificar

Figura 21: Matrices en RGB

Figura 23: Imagen con filtro y closing

Figura 25: Imagen etiquetada.

Figura 26: Imágenes de cada fruta.

Código del ejercicio.

Rotar una imagen.

Figura 28: Imagen original e imagen rotada 30 grados

Recortar una imagen

Figura 29: Extracción de un recorte.

Figura 30: Bordes con la función edge y sobel.

RGB = imread('anabel.jpg'); % Carga la imagen

Figura 31: Bordes con la función edge y prewitt.

RGB = imread('anabel.jpg'); % Carga la imagen

Utilizando la función Roberts

Figura 32: Bordes con la función edge y Roberts.

Utilizando la función Canny

Figure 33: Bordes con la función edge y canny.

Es básicamente erosión más dilatación.

Figura 34: Aplicación de la función opening en Matlab.

Ejercicio de QUIZ de Robótica 2.

Figura 35: Llave y destornillador.

xt=[EJEX];% Se colocan todos los centroides x en un vector

Figura 36: Resultado del código.

Ahora pasamos a la aplicación de ip webcam:

Por ultimo utilizamos la dirección ip para cargar la respectiva imagen.

Utilizar el comando ipwebcam para la detección de un objeto (o varios en un ambiente

En este caso la idea es detectar el raton rojo que poseo.

Figura 39: Ratón a detectar.

Figura 40: Imagen detectada 1

Figura 41: Imagen detectada 2.