Universidad Autónoma de occidente
Asignatura de Señales y sistemas
Descripción del código
Presentado por:
Jesus Ascuntar
Código: 2170331
Presentado a:
Juan Manuel Nogales Viedman
I. Base de dátos.
Lo primero que hacemos es crear una base de datos.
La base de datos es lo que no sirve para entrenar el logaritmo y así poder llevar
acabo el reconocimiento de los caracteres en una imagen.
II. Código Run.
RUN
imagen=imread('TEST_00.JPG');
En esta parte del código cargamos la imagen con el comando imread.
“imread(filename) lee la imagen del archivo especificado por filename, infiriendo el formato del
archivo a partir de su contenido. Si filename es un archivo de varias imágenes, imread lee la
primera imagen del archivo.”
imshow(imagen);
Aquí lo que hacemos es mostrar la imagen con el comando imshow.
“imshow(I) muestra la imagen en escala de grises en una figura. utiliza el rango de visualización
predeterminado para el tipo de datos de imagen y optimiza las propiedades de figura, ejes y
objetos de imagen para la visualización de imágenes.”
title('IMAGEN REAL')
Le damos un título a la imagen.
imagen=rgb2gray(imagen);
Convertimos la imagen a escala de grises con la función rgb2gray.
“I = rgb2gray(RGB) convierte la imagen truecolor RGB en la imagen de intensidad de escala de
grises I. La función rgb2gray convierte las imágenes RGB en escala de grises eliminando la
información de matiz y saturación mientras conserva la luminancia. Si tiene instalado Parallel
Computing Toolbox™ , rgb2gray puede realizar esta conversión en una GPU.”
threshold = graythresh(imagen);
Aqui guardamos la función graythresh de la imagen (utilizamos el método otsu)
“T = graythresh(I) calcula un umbral global a partir de la imagen en escala de grises, utilizando
el método de Otsu.TI[1] El método de Otsu elige un umbral que minimiza la varianza intraclase de
los píxeles en blanco y negro con umbral. El umbral global se puede utilizar para convertir una
imagen en escala de grises en una imagen binaria.”
imagen =~im2bw(imagen);
Convertimos la imagen de escala de grises a binaria con la función im2bw.
“BW = im2bw(I,level) convierte la imagen en escala de grises en imagen binaria, reemplazando
todos los píxeles de la imagen de entrada por luminancia mayor que con el valor (blanco) y
reemplazando todos los demás píxeles por el valor (negro).”
imagen = bwareaopen(imagen,30);
Esta parte del código con sirve para eliminar los componentes que tengan menos de p
pixeles.
“bwareaopen(BW,P) elimina todos los componentes conectados (objetos) que tienen menos de
píxeles de la imagen binaria, produciendo otra imagen binaria”
word=[ ];
En esta parte se crea un vector para almacenar las letras.
re=imagen;
En esta parte guardamos la imagen que obtuvimos anteriormente.
fid = fopen('text.txt', 'wt');
Aquí abrimos el txt donde vamos a escribir los datos.
load templates
Aquí cargamos el template o plantilla.
El template como se comentó anteriormente es el que no sirve para llevar a cabo el reconocimiento
de los caracteres.
global templates
Aquí hacemos un template global.
(Estos se hacen con ayuda del código Create_Templates que se mostrara más
adelante)
num_letras=size(templates,2);
Aquí le asignamos el tamaño que es igual al número de todas las filas y columnas del
template (Es el número de posiciones del template).
while 1
[fl re]=lines(re);
Aquí se le aplica el código “lines” a la imagen obtenida anteriormente “re”, (El código
“lines” se explica más adelante).
imgn=fl;
(fl Hace referencia a la imagen normal)
[L Ne] = bwlabel(imgn);
Esta parte lo que hace es devolvernos filas y columnas de la imagen (imgn) utilizando la
función “bwlabel”.
También debemos tener en cuenta que “[L Ne]” es un vector donde “L” son las filas y
“Ne” son las columnas.
for n=1:Ne
[r,c] = find(L==n);
Aquí encontramos los valores o los indices donde “L” se iguala a “n” es decir donde se
encuentra la parte blanca de la imagen (teniendo en cuenta que es una imagen binaria) y los
guarda en el vector [r,c].
n1=imgn(min(r):max(r),min(c):max(c));
Aquí se recorren cada uno de los valores máximos y mínimos del pixel encontrado
anteriormente.
img_r=imresize(n1,[42 24]);
Aquí lo que hacemos es recortar “n1” a un tamaño de 42 x 24 debido a que este es el
tamaño de las imágenes de nuestra base de datos.
letter=read_letter(img_r,num_letras);
Estas son las letras que nosotros vamos a buscar, en esta parte le aplicamos el código
“read_letter” (la función read_letter se explica más adelante) a la imagen recortada
(img_r) y al numero de letras (num_letras) que es el numero de posiciones que tiene el
template.
word=[word letter];
Aquí se va guardando cada letra que vamos encontrando.
end
fprintf(fid,'%s\n',word);
word=[ ];
if isempty(re)
Cuando ya no se encuentren mas caracteres se cierra el ciclo while.
break
end
end
fclose(fid);
Aquí se cierra el txt.
winopen('text.txt')
Aquí se abre el txt y nos muestra los caracteres obtenidos.
clear all
Aquí cerramos todo.
La función “while” lo que hace es clasificar cada una de las letras o números, este se
ejecuta para cada uno de los caracteres que vaya encontrando hasta clasificarlos todos.
“while expression, statements, end evalúa una expresión y repite la ejecución de un grupo
de instrucciones en un bucle mientras que la expresión es verdadera. Una expresión es verdadera
cuando su resultado no está vacío y contiene solo elementos no nulos (numéricos reales o lógicos).
De lo contrario, la expresión es falsa.”
III. Código Read_letter.
READ_LETTER
function letter=read_letter(imagn,num_letras)
“imagn” Hace referencia a la imagen ya recortada.
“num_letras” hace referencia al número de letras.
global templates
Hacemos el template global para poder llamarlo en cualquier parte de la
clase.
comp=[ ];
Este es el vector donde iremos guardando los caracteres de cada letra que vayamos
encontrando.
for n=1:num_letras
sem=corr2(templates{1,n},imagn);
comp=[comp sem];
Esta es la parte en la que se realiza la validación cruzada entre el template y la imagen
recortada para poder clasificarla, en esta parte el código compara la imagen recortada con
cada uno de los datos que se encuentran en el template con ayuda de la función corr2.
“corr2(A,B) devuelve el coeficiente de correlación 2-D entre matrices”
end
vd=find(comp==max(comp));
Esta parte del código nos arroja como resultado la letra o el número del template con la que
más se parece la imagen recortada.
if vd==1 letter='B';
letter='A'; elseif vd==3
elseif vd==2 letter='C';
elseif vd==4 elseif vd==21
letter='D'; letter='U';
elseif vd==5 elseif vd==22
letter='E'; letter='V';
elseif vd==6 elseif vd==23
letter='F'; letter='W';
elseif vd==7 elseif vd==24
letter='G'; letter='X';
elseif vd==8 elseif vd==25
letter='H'; letter='Y';
elseif vd==9 elseif vd==26
letter='I'; letter='Z';
elseif vd==10 %*-*-*-*-*
letter='J'; elseif vd==27
elseif vd==11 letter='1';
letter='K'; elseif vd==28
elseif vd==12 letter='2';
letter='L'; elseif vd==29
elseif vd==13 letter='3';
letter='M'; elseif vd==30
elseif vd==14 letter='4';
letter='N'; elseif vd==31
elseif vd==15 letter='5';
letter='O'; elseif vd==32
elseif vd==16 letter='6';
letter='P'; elseif vd==33
elseif vd==17 letter='7';
letter='Q'; elseif vd==34
elseif vd==18 letter='8';
letter='R'; elseif vd==35
elseif vd==19 letter='9';
letter='S'; else
elseif vd==20 letter='0';
letter='T'; end
IV. Código Lines.
function [fl re]=lines(im_texto)
im_texto=clip(im_texto);
Esta parte del algoritmo le hace clip a la imagen “re”.
(Clip lo que hace es devolver los valores de una matriz dentro de un rango dado,
opcionalmente devuelve las matrices recortadas correspondientes.)
num_filas=size(im_texto,1);
for s=1:num_filas
if sum(im_texto(s,:))==0
nm=im_texto(1:s-1, :);
rm=im_texto(s:end, :);
fl = clip(nm);
re=clip(rm);
rm hace refencia a las partes recortadas.
break
else
fl=im_texto;
fl hace referencia a la imagen normal.
re=[ ];
end
end
Esta parte del código lo que hace es recorrer cada parte de la matriz (matlab lee la imagen
como una matriz) de forma vertical y la va segmentando, todo lo que va obteniendo de este
proceso lo guarda en “re”.
function img_out=clip(img_in)
[f c]=find(img_in);
Esta parte del código devuelve un vector que contiene los índices lineales de cada elemento
distinto de cero.
img_out=img_in(min(f):max(f),min(c):max(c));
V. Codigo CREATE_TEMPLATES
A=imread('letters_numbers\A.bmp');B=imread('letters_numbers\B.bmp');
C=imread('letters_numbers\C.bmp');D=imread('letters_numbers\D.bmp');
E=imread('letters_numbers\E.bmp');F=imread('letters_numbers\F.bmp');
G=imread('letters_numbers\G.bmp');H=imread('letters_numbers\H.bmp');
I=imread('letters_numbers\I.bmp');J=imread('letters_numbers\J.bmp');
K=imread('letters_numbers\K.bmp');L=imread('letters_numbers\L.bmp');
M=imread('letters_numbers\M.bmp');N=imread('letters_numbers\N.bmp');
O=imread('letters_numbers\O.bmp');P=imread('letters_numbers\P.bmp');
Q=imread('letters_numbers\Q.bmp');R=imread('letters_numbers\R.bmp');
S=imread('letters_numbers\S.bmp');T=imread('letters_numbers\T.bmp');
U=imread('letters_numbers\U.bmp');V=imread('letters_numbers\V.bmp');
W=imread('letters_numbers\W.bmp');X=imread('letters_numbers\X.bmp');
Y=imread('letters_numbers\Y.bmp');Z=imread('letters_numbers\Z.bmp');
%Number
one=imread('letters_numbers\1.bmp');
two=imread('letters_numbers\2.bmp');
three=imread('letters_numbers\3.bmp');four=imread('letters_numbers\4.bmp'
);
five=imread('letters_numbers\5.bmp');
six=imread('letters_numbers\6.bmp');
seven=imread('letters_numbers\7.bmp');eight=imread('letters_numbers\8.bmp
');
nine=imread('letters_numbers\9.bmp');
zero=imread('letters_numbers\0.bmp');
%*-*-*-*-*-*-*-*-*-*-*-
Este es el código con el cual creamos los templates, tomaremos como ejemplo el template
de la letra A para la explicación de esta parte del código.
A=imread('letters_numbers\A.bmp');
Esto quiere decir que para A se carga la imagen con la función “imread” en la ruta
“letters_numbers” que es la carpeta donde tenemos las letras y los números y seleccionar la
letra correspondiente “A.bmp”.
Este proceso se lleva a cabo con cada una de las letras y números.
letter=[A B C D E F G H I J K L M...
N O P Q R S T U V W X Y Z];
number=[one two three four five...
six seven eight nine zero];
Después de haber realizado el procedimiento anterior se arma un vector donde se van a
encontrar las letras y un vector donde se van a encontrar los números.
character=[letter number];
Entonces nuestro template general serán unos caracteres “character” que estarán
constituidos por “letter” y “number” que son los vectores que obtuvimos anteriormente.
templates=mat2cell(character,42,[24 24 24 24 24 24 24 ...
24 24 24 24 24 24 24 ...
24 24 24 24 24 24 24 ...
24 24 24 24 24 24 24 ...
24 24 24 24 24 24 24 24]);
Aquí lo que hacemos es recortar cada uno de los caracteres que obtuvimos anteriormente a
una resolución o dimensión de 24 x 42 que son las dimensiones de los datos que se
encuentran en nuestro témplate.
save ('templates','templates')
clear all
Por ultimo guardamos el template.
