INFORME FINAL

SISTEMA DE RECONOCIMIENTO AUTOMATICO DE

PLACAS PARA UN PARQUEADERO

INFORME FINAL
OBJETIVO:
Utilizar tcnicas de procesamiento de imgenes para solucionar un
problema especfico, el cual ser la creacin de un sistema reconocedor
automtico de placas que podr ser instalado a la entrada de un
parqueadero.
DESARROLLO DEL PROYECTO
Restricciones: Las imgenes tomadas pueden ser de cualquier
tamao, pero la placa debe cumplir con las siguientes condiciones de
150 a 210 pixels y de 50 a 110 pixels de ancho. Ademas, las fotos
tomadas de la placa no pueden estar inclinadas.
Procedimiento: Inicialmente se necesita diferenciar si la imagen est
en escala de grises o en RGB para poder hacer la conversin
correspondiente. Se utiliza el siguiente cdigo:
I=imread('C:\foto104.jpg');
info=imfinfo('C:\foto104.jpg');
if info.ColorType=='truecolor'
I=rgb2gray(I);
else
I=I;
End

%Ciclo para determinar si es a color o en

%escala de grises para poder hacer o no la
%conversion necesaria

Una vez realizado esto se recorta la imagen para poder eliminar zonas
en las que no existe informacin relevante a la placa como los bordes
superiores y externos, se muestra en la figura 1. Se observaron las fotos
para determinar cual es el rango aproximado que se puede cortar.

Figura 1. Imagen Recortada

Despus del recorte se determina el umbral ptimo de la imagen. Esto

se hace calculando el gradiente de la imagen utilizando la tcnica de
Sobel para hallar posibles picos en la imagen, y luego las siguientes
ecuaciones:

Se implement el siguiente cdigo para definir una funcin para calcular

el umbral ptimo de cada foto en particular:
%

umbral=UmbralOptimo(imagen, filasImagen, columnasImagen, gradiente);

% Algoritmo para calcular el umbral optimo para la binarizacion.

function umbral=UmbralOptimo(imagen, filasImagen, columnasImagen, gradiente)
%
%
%
%

Creo una variable que me dice de que color era el ultimo grupo que guarde
de esta forma se que la cola del final de la fila pertenece al otro color
la variable se llama ultimoColor, si vale cero fue oscuro y si vale uno
fue claro.

numOscuros=0;
numClaros=0;

oscuros=0;
claros=0;
cont=0;
acum=0;
%
%
%
%

Este if es para solucionar el problema que ocurre si no hay bordes en la

primer fila entonces no se sabe si es clara o oscura.
Supongo continuidad en los colores, si en la segunda fila tampoco hay bordes
estos los supongo del mismo color que la primera.

if imagen(1,1)<(max(max(imagen))/2)
% Como es oscuro pongo que el ultimo color fue claro.
ultimoColor=1;
else
% Como es claro pongo que el ultimo color fue oscuro.
ultimoColor=0;
end
for i=1:filasImagen
if ultimoColor==0
numClaros=numClaros+cont;
cont=0;
claros=claros+acum;
acum=0;
else
numOscuros=numOscuros+cont;
cont=0;
oscuros=oscuros+acum;
acum=0;
end
for j=1:columnasImagen
if gradiente(i,j)==0
cont=cont+1;
acum=acum+imagen(i,j);
else
if gradiente(i,j)==-1
numOscuros=numOscuros+cont;
cont=1;
oscuros=oscuros+acum;
acum=imagen(i,j);
ultimoColor=0;
else
numClaros=numClaros+cont;
cont=1;
claros=claros+acum;
acum=imagen(i,j);
ultimoColor=1;
end
end
end
end
if ultimoColor==0
numClaros=numClaros+cont;
claros=claros+acum;
else
numOscuros=numOscuros+cont;
oscuros=oscuros+acum;
end
% Media de los claros.
mediaClaros=claros/numClaros;

% Media de los oscuros.

mediaOscuros=oscuros/numOscuros;
% Umbral optimo para la binarizacion.
umbral=(mediaOscuros*numClaros+mediaClaros*numOscuros)/(numClaros+numOscuros);

Se defini la siguiente funcin para calcular el gradiente de Sobel:

%

gradienteSobel=Sobel(imagen, filasImagen, columnasImagen, X_Porciento);

function gradienteSobel=Sobel(imagen, filasImagen, columnasImagen, X_Porciento)

% Kernel Sobel para calcular el gradiente en la direccion horizontal.
kernel=(1/8)*[-1 0 1; -2 0 2; -1 0 1];
gradiente=Filtro(imagen, filasImagen, columnasImagen, kernel);
% Calculo del umbral para clasificar la respuesta del Sobel, este es tal que
% solo un X% de los gradientes van a superar el umbral.
moduloGradiente=abs(gradiente(:));
maximoModuloGradiente=round(max(moduloGradiente));
minimoModuloGradiente=round(min(moduloGradiente));
nivelesGradiente=maximoModuloGradiente-minimoModuloGradiente;
histogramaGradiente=hist(moduloGradiente, nivelesGradiente);
histogramaGradienteAcumulado=cumsum(histogramaGradiente);
umbralSobel=nivelesGradiente;
while (umbralSobel > 0)&(histogramaGradienteAcumulado(umbralSobel) >
(filasImagen*columnasImagen*(1-(X_Porciento/100))))
umbralSobel=umbralSobel-1;
end
umbralSobel=minimoModuloGradiente+umbralSobel;
% Clasificacion de la respuesta del Sobel en 1, 0 o -1.
gradienteSobel=[];
for i=1:filasImagen
for j=1:columnasImagen
if gradiente(i,j) > umbralSobel
gradienteSobel(i,j)=1;
else
if gradiente(i,j) < -umbralSobel
gradienteSobel(i,j)=-1;
else
gradienteSobel(i,j)=0;
end
end
end
end

Finalmente se implement el siguiente cdigo para el recorte y la

determinacin del umbral:

[R C]=size(I);
cropsize=[(R*0.25) (C*0.15) (C*0.625) (R*0.6)];
Ic=imcrop(I,cropsize);
fondo innecesario
figure; imshow(Ic)
Id=double(Ic); [R C]=size(Ic)
operaciones
I2=sobel(Id,R,C,2.5);
umbral=umbraloptimo(Id,R,C,I2);

%Halla el tamao de la imagen

%Determina seccion a cortar
%Recorta la imagen para eliminar
%Grafica Zona recortada
%Convierte imagen a doble para
%Halla gradiente de sobel
%Halla umbral optimo

Posteriormente se realizan operaciones morfolgicas. Inicialmente se

utilizar un elemento estructurante circular de radio 10 pxeles para
realizar una transformacin bottom-hat, que primero hace una
operacin de closing (dilatacin y luego erosin) y luego resta la
imagen obtenida de la imagen original para resaltar la placa y ciertos
bordes como se puede ver en la figura 2. Luego se aplica el umbral
hallado anteriormente como se muestra en la figura 3. Para eliminar el
ruido se hace primero una operacin de closing (dilatacin y luego
erosin) utilizando un elemento estructurante horizontal hallado
basndose en la separacin que existe entre los caracteres de la placa
como se muestra en la figura 4. Despus se realiza opening (erosin y
luego dilatacin)
con un elemento estructurante vertical hallado
basndose en la altura de los caracteres de la placa como se ve en la
figura 5. Finalmente se realizan dilataciones verticales y horizontales
para expandir la zona de la placa como se ve en la figura 6. Se
implement el siguiente cdigo:
st=strel('disk',10);
IM2=imbothat(Ic,st);
I3=IM2>umbral;
LH=strel('line',60,0);
IM3=imclose(I3,LH);
LV=strel('line',20,90);
IM4=imopen(IM3,LV);
figure;imshow(IM4)
DIV=strel('line',35,90);
DIH=strel('line',20,0);
IM5=imdilate(IM4,DIV);
IM6=imdilate(IM5,DIH);
figure; imshow(IM6)

%Elemento estructurante de 10 pixeles de radio

%Hace Bottom-Hat
%Aplica Umbral
%Elemento estructurante lineal horizontal
%Closing con elemento estructurante
%Elemento estructurante lineal vertical
%Hace opening con elemento estructurante
%Muestra Imagen
%Elemento estructurante lineal vertical
%Elemento estrucutrante lineal horizontal
%Dilata con E.E. vertical
%Dilata con E.E. horizontal
%Muestra imagen

Figura 2.

Figura 3. Umbral

Top-Hat

Figura 4. Closing Horizontal

Figura 5. Opening Vertical

Figura 6. Dilatacin

Finalmente a partir de la imagen binarizada de la zona de la placa, se

pueden hallar la ubicacin de la placa y sus dimensiones para hacer un
recorte de la imagen original de la zona de la placa como se muestra en
la figura 7. Se implement el siguiente cdigo:
L=bwlabel(IM6);
stats=regionprops(L,'all');
Idx=find([stats.Area]>(7000));
7000
IM6=ismember(L,Idx);

%Crea regiones
%Estadisticas de las regiones
%Diferencia las regiones con Area >
%Crea una imagen con dichas regiones

L=bwlabel(IM6);
stats = regionprops(L,'all');
E=stats(1).BoundingBox;
X=E.*[[1] [0] [0] [0]]; X=max(X);
Y=E.*[[0] [1] [0] [0]]; Y=max(Y);
W=E.*[[0] [0] [1] [0]]; W=max(W)
H=E.*[[0] [0] [0] [1]]; H=max(H);
Corte=[X Y W H];
IMF=imcrop(Ic,Corte);
figure; imshow(IMF)

%Crea regiones
%Estadisticas de las regiones
%Toma tamao de la region
%Determina eje X esquina superior Izq. Placa
%Determina eje Y esquina superior Der. Placa
%Determina Ancho Placa
%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra imagen de la zona de la placa

Figura 7. Recorte Placa

A continuacin procedemos a binarizar la imagen de la placa recortada

con un umbral de 120, para poder recortar aun mas la placa y as borrar
las lneas y elementos que nos producen ruido (Figura 8). Esto lo
podemos realizar mediante una estadstica de la regin tomada, y
aplicando un porcentaje de recorte posible por las caractersticas
estndar que tienen las placas. Se realiza un filtro para ayudar a depurar
un poco mas la imagen (Figura 9). Se binariza la imagen obtenida
(Figura 10). Y por ultimo se aplica una propiedad de regin para que solo
las reas mayores a 1.5% del total queden presentes. El siguiente es el
cdigo implementado:
umbral=120;
placa=IMF>umbral;
L=bwlabel(placa);
stats=regionprops(L,'all');
placadx=find([stats.Area]>(4500));
4500
placa=ismember(L,placadx);
L=bwlabel(placa);
stats=regionprops(L,'all');
E2=stats(1).BoundingBox;
X2=E2.*[[1] [0] [0] [0]]; X2=max(X2);
Izq. Placa

%Aplico un Umbral de 120

%Aplica umbral a placa
%Crea regiones
%Estadisticas de las regiones
%Diferencia las regiones con Area >
%Crea una imagen con dichas regiones
%Crea regiones
%Estadisticas de las regiones
%Toma tamao de la region
%Determina eje X esquina superior

Y2=E2.*[[0] [1] [0] [0]]; Y2=max(Y2);

Der. Placa
W2=E2.*[[0] [0] [1] [0]]; W2=max(W2);
H2=E2.*[[0] [0] [0] [1]]; H2=max(H2);
Corte2=[X2 Y2 W2 H2];
C2=imcrop(IMF,Corte2);
Wx=round(W2*0.94); Hx=round(H2*0.756);
Cortex=[4 12 Wx Hx];
C2=imcrop(C2,Cortex);
figure; imshow(C2)
C3=imbothat(C2,st);
figure; imshow(C3)
umbral2=90;
C5=C3>umbral2;
figure; imshow(C5)
L=bwlabel(C5);
stats=regionprops(L,'all');
placadx=find([stats.Area]>((W2*H2)*0.015));
1.5% del area total
placa=ismember(L,placadx);
figure; imshow(placa)

%Determina eje Y esquina superior

%Determina Anchura placa
%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte

%Muestra Imagen

%Diferencia las regiones con Area >

%Crea una imagen con dichas regiones

FIGURA 9

FIGURA 8

FIGURA 10
El siguiente paso es recortar cada carcter por separado, para esto
utilizamos el comando bwlabel para que nos divida la imagen en
regiones y poder determinar el rea que posee cada regin (que en este
caso nos demarcar el rea ocupada por el carcter) y poder recortarlo
con el comando imcrop, obteniendo cada carcter en una variable por
separado. Luego, a cada carcter se le realiza un nuevo

dimensionamiento (24*42) para estandarizar los caracteres y poder

realizar el reconocimiento de la letra y del numero. La figura 11 muestra
los 6 caracteres recortados. El cdigo utilizado es el siguiente:
L=bwlabel(placa);
stats=regionprops(L,'all');
E3=stats(1).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]]; X3=max(X3);
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]]; Y3=max(Y3);
Der. Placa
W3=E3.*[[0] [0] [1] [0]]; W3=max(W3);
H3=E3.*[[0] [0] [0] [1]]; H3=max(H3);
Corte3=[X3 Y3 W3 H3];
L1=imcrop(C2,Corte3);
L1b=imresize(L1,[42 24]);
L1b=L1b>150;
figure; imshow(L1b)
E3=stats(2).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]];
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]];
Der. Placa
W3=E3.*[[0] [0] [1] [0]];
H3=E3.*[[0] [0] [0] [1]];
Corte3=[X3 Y3 W3 H3];
L2=imcrop(C2,Corte3);
L2b=imresize(L2,[42 24]);
L2b=L2b>150;
figure; imshow(L2b)
E3=stats(3).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]];
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]];
Der. Placa
W3=E3.*[[0] [0] [1] [0]];
H3=E3.*[[0] [0] [0] [1]];
Corte3=[X3 Y3 W3 H3];
L3=imcrop(C2,Corte3);
L3b=imresize(L3,[42 24]);
L3b=L3b>150;
figure; imshow(L3b)
E3=stats(4).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]];
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]];
Der. Placa
W3=E3.*[[0] [0] [1] [0]];
H3=E3.*[[0] [0] [0] [1]];
Corte3=[X3 Y3 W3 H3];
L4=imcrop(C2,Corte3);
L4b=imresize(L4,[42 24]);
L4b=L4b>150;

%Toma tamao de la region 1, primer

%Determina eje X esquina superior
%Determina eje Y esquina superior
%Determina Anchura placa
%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra el primer caracter
%Toma tamao de la region 2, segundo

X3=max(X3);

%Determina eje X esquina superior

Y3=max(Y3);

%Determina eje Y esquina superior

W3=max(W3);
H3=max(H3);

%Determina Anchura placa

%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra el segundo caracter
%Toma tamao de la region 3, tercer

X3=max(X3);

%Determina eje X esquina superior

Y3=max(Y3);

%Determina eje Y esquina superior

W3=max(W3);
H3=max(H3);

%Determina Anchura placa

%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra el tercer caracter
%Toma tamao de la region 4, cuarto

X3=max(X3);

%Determina eje X esquina superior

Y3=max(Y3);

%Determina eje Y esquina superior

W3=max(W3);
H3=max(H3);

%Determina Anchura placa

%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte

figure; imshow(L4b)

%Muestra el cuarto caracter

E3=stats(5).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]];
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]];
Der. Placa
W3=E3.*[[0] [0] [1] [0]];
H3=E3.*[[0] [0] [0] [1]];
Corte3=[X3 Y3 W3 H3];
L5=imcrop(C2,Corte3);
L5b=imresize(L5,[42 24]);
L5b=L5b>150;
figure; imshow(L5b)
E3=stats(6).BoundingBox;
caracter
X3=E3.*[[1] [0] [0] [0]];
Izq. Placa
Y3=E3.*[[0] [1] [0] [0]];
Der. Placa
W3=E3.*[[0] [0] [1] [0]];
H3=E3.*[[0] [0] [0] [1]];
Corte3=[X3 Y3 W3 H3];
L6=imcrop(C2,Corte3);
L6b=imresize(L6,[42 24]);
L6b=L6b>150;
figure; imshow(L6b)

%Toma tamao de la region 5, quinto

X3=max(X3);

%Determina eje X esquina superior

Y3=max(Y3);

%Determina eje Y esquina superior

W3=max(W3);
H3=max(H3);

%Determina Anchura placa

%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra el quinto caracter
%Toma tamao de la region 6, sexto

X3=max(X3);

%Determina eje X esquina superior

Y3=max(Y3);

%Determina eje Y esquina superior

W3=max(W3);
H3=max(H3);

%Determina Anchura placa

%Determina Altura placa
%Determina coordenadas de corte
%Realiza el corte
%Muestra el sexto carcter

Figura 11. Caracteres de la placa

Desarrollo del OCR: En este momento ya poseemos los caracteres
individuales que componen el numero de la placa, por lo que se
proceder a realizar una base de datos de las 24 letras del alfabeto en
mayscula (no se tiene en cuanta la letra CH ni la ), y los dgitos del 0
al 9. Para ello se realizaran archivos de imagen con los caracteres de
21*42 pixels, binarizados, que sern cargados a matlab mediante
variables, y luego se creara una matriz denominada alfabeto que
contenga todas la letras del alfabeto, Figura 12, y una matriz
denominada numeral que contiene todos los digitos del 0 al 9, Figura 13.
El siguiente es el cdigo implementado.
a=imread('C:\MATLAB6p5\work\A.bmp');
c=imread('C:\MATLAB6p5\work\C.bmp');
e=imread('C:\MATLAB6p5\work\E.bmp');
g=imread('C:\MATLAB6p5\work\G.bmp');
i=imread('C:\MATLAB6p5\work\I.bmp');
k=imread('C:\MATLAB6p5\work\K.bmp');

b=imread('C:\MATLAB6p5\work\B.bmp');
d=imread('C:\MATLAB6p5\work\D.bmp');
f=imread('C:\MATLAB6p5\work\F.bmp');
h=imread('C:\MATLAB6p5\work\H.bmp');
j=imread('C:\MATLAB6p5\work\J.bmp');
l=imread('C:\MATLAB6p5\work\L.bmp');

m=imread('C:\MATLAB6p5\work\M.bmp'); n=imread('C:\MATLAB6p5\work\N.bmp');
o=imread('C:\MATLAB6p5\work\O.bmp'); p=imread('C:\MATLAB6p5\work\P.bmp');
q=imread('C:\MATLAB6p5\work\Q.bmp'); r=imread('C:\MATLAB6p5\work\R.bmp');
s=imread('C:\MATLAB6p5\work\S.bmp'); t=imread('C:\MATLAB6p5\work\T.bmp');
u=imread('C:\MATLAB6p5\work\U.bmp'); v=imread('C:\MATLAB6p5\work\V.bmp');
w=imread('C:\MATLAB6p5\work\W.bmp'); x=imread('C:\MATLAB6p5\work\X.bmp');
y=imread('C:\MATLAB6p5\work\Y.bmp'); z=imread('C:\MATLAB6p5\work\Z.bmp');
uno=imread('C:\MATLAB6p5\work\1.bmp'); dos=imread('C:\MATLAB6p5\work\2.bmp');
tres=imread('C:\MATLAB6p5\work\3.bmp'); cuatro=imread('C:\MATLAB6p5\work\4.bmp');
cinco=imread('C:\MATLAB6p5\work\5.bmp'); seis=imread('C:\MATLAB6p5\work\6.bmp');
siete=imread('C:\MATLAB6p5\work\7.bmp'); ocho=imread('C:\MATLAB6p5\work\8.bmp');
nueve=imread('C:\MATLAB6p5\work\9.bmp'); cero=imread('C:\MATLAB6p5\work\0.bmp');
alfabeto=[[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]];
numeral=[[uno] [dos] [tres] [cuatro] [cinco] [seis] [siete] [ocho] [nueve] [cero]];

Figura 12. Matriz alfabeto

Figura 13 Matriz numeral

Procedemos a realizar una conversin de matrices a un arreglo de celdas
de las variables numeral, alfabeto y matricula, para poder trabajar con
elementos separados y definidos por una posicin para poder realizar
operaciones individuales sobre cada uno de los elementos. El siguiente
es el cdigo utilizado:
matricula=[[L1b] [L2b] [L3b] [L4b] [L5b] [L6b]];
ab=mat2cell(alfabeto,[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]);
numero=mat2cell(numeral,[42],[24 24 24 24 24 24 24 24 24 24]);
plac=mat2cell(matricula,[42],[24 24 24 24 24 24]);

Por ultimo, debemos encontrar un mtodo adecuado para realizar el

reconocimiento del carcter hallado en la placa con uno presenta en la
base de datos. En esta caso se utilizo la tcnica de correlacin. Matlab
permite calcular el coeficiente de correlacin entre dos matrices
bidimensionales, dando como resultado un valor que representa la
igualdad entre dos matrices. corr2 realiza el coeficiente de correlacin
usando la expresin:

donde A = mean2(A), and B = mean2(B)

Se desarroll un ciclo, el cual toma los valores de la correlacin del
carcter que est siendo analizado y lo introduce en una matriz de 3
filas por 26 o 10 columnas, segn sean letras o nmeros
respectivamente. Posteriormente se hallan los mximos de las tres
columnas y son almacenados en otra matriz. Finalmente se encuentran
las posiciones en las que estaban los mximos para as determinar la
letra o el nmero al que corresponden y mediante otro ciclo se muestra
esto en pantalla. El cdigo implementado fue el siguiente:
%Ciclo que reconoce las letras y les asigna la posicion en la matriz de abecedario
fila=1;
ind=1;
while fila < 4
posp=1;
for posp=1:3
plc=plac{1,posp};
pos=1;
temp=0;
while pos<27
temp=ab{1,pos};
co=corr2(temp,plc);
letra(fila,pos)=co;
pos=pos+1;
end
fila=fila+1;
posp=posp+1;
end
end
for ind = 1:3
maxs=max(letra,[],2);
[posx posy]=find(letra==maxs(ind,1));
letras(ind)=posy
ind=ind+1;
end
%Ciclo que reconoce los numeros y les asigna la posicion en la matriz de
%numeros
fila=1;
ind=1;
while fila < 4
posp=4;
for posp=4:6
plc=plac{1,posp};

pos=1;
temp=0;
while pos<11
temp=numero{1,pos};
co=corr2(temp,plc);
num(fila,pos)=co;
pos=pos+1;
end
fila=fila+1;
posp=posp+1;
end
end
for ind = 1:3
maxs=max(num,[],2);
[posx posy]=find(num==maxs(ind,1));
nums(ind)=posy
ind=ind+1;
end
close all
mal='a';
ltr=1;
lt=1;
while ltr < 4
while lt < 4
if letras(ltr)== 1
mal(lt)='A'
elseif letras(ltr)
mal(lt)='B'
elseif letras(ltr)
mal(lt)='C'
elseif letras(ltr)
mal(lt)='D'
elseif letras(ltr)
mal(lt)='E'
elseif letras(ltr)
mal(lt)='F'
elseif letras(ltr)
mal(lt)='G'
elseif letras(ltr)
mal(lt)='H'
elseif letras(ltr)
mal(lt)='I'
elseif letras(ltr)
mal(lt)='J'
elseif letras(ltr)
mal(lt)='K'
elseif letras(ltr)
mal(lt)='L'
elseif letras(ltr)
mal(lt)='M'
elseif letras(ltr)
mal(lt)='N'
elseif letras(ltr)
mal(lt)='O'
elseif letras(ltr)
mal(lt)='P'
elseif letras(ltr)
mal(lt)='Q'
elseif letras(ltr)
mal(lt)='R'

== 2
== 3
== 4
== 5
== 6
== 7
== 8
== 9
== 10
== 11
== 12
== 13
== 14
== 15
== 16
== 17
== 18

elseif letras(ltr) ==
mal(lt)='S'
elseif letras(ltr) ==
mal(lt)='T'
elseif letras(ltr) ==
mal(lt)='U'
elseif letras(ltr) ==
mal(lt)='V'
elseif letras(ltr) ==
mal(lt)='W'
elseif letras(ltr) ==
mal(lt)='X'
elseif letras(ltr) ==
mal(lt)='Y'
elseif letras(ltr) ==
mal(lt)='Z'
else
mal(lt)='Paila'
end
lt=lt+1;
ltr=ltr+1;

19
20
21
22
23
24
25

end

26

end
nmr=1;
man='1';
nm=1;
while nmr < 4
while nm < 4
if nums(nmr)== 1
man(nm)='1'
elseif nums(nmr) ==
man(nm)='2'
elseif nums(nmr) ==
man(nm)='3'
elseif nums(nmr) ==
man(nm)='4'
elseif nums(nmr) ==
man(nm)='5'
elseif nums(nmr) ==
man(nm)='6'
elseif nums(nmr) ==
man(nm)='7'
elseif nums(nmr) ==
man(nm)='8'
elseif nums(nmr) ==
man(nm)='9'
elseif nums(nmr) ==
man(nm)='0'
else
disp('Paila')
end
nm=nm+1;
nmr=nmr+1;
end
end
plate=horzcat(mal,man);
disp(plate)

2
3
4
5
6
7
8
9
10

CONCLUSIONES

La utilizacin de los elementos estructurantes, definidos en

Matlab, es una herramienta poderosa para simplificar los
procedimientos a realizar cuando trabajamos con imgenes y
debemos eliminar estructuras y objetos irrelevantes al objetivo
propuesto.
No es aconsejable utilizar elementos estructurantes y propiedades
morfolgicas si el objetivo es implementar el cdigo en otro
compilador y programa diferente al de matlab, pero por facilidad y
economa de tiempo se podran utilizar para tener un conocimiento
inicial de los pasos que se deben realizar para cumplir el objetivo
propuesto a la imagen.
Al utilizar mtodos tradicionales de filtrado, erosionado y dilatado
de imgenes, aseguramos la portabilidad del cdigo hacia otros
programas y dispositivos, como DSPs, aunque su implementacin
es mas larga, dificultosa y de mayor cuidado.