INFORME FINAL

SISTEMA DE RECONOCIMIENTO AUTOMATICO DE
PLACAS PARA UN PARQUEADERO

INFORME FINAL
OBJETIVO:
Utilizar técnicas de procesamiento de imágenes para solucionar un
problema específico, el cual será la creación de un sistema reconocedor
automático de placas que podrá ser instalado a la entrada de un
parqueadero.
DESARROLLO DEL PROYECTO
Restricciones: Las imágenes tomadas pueden ser de cualquier
tamaño, 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 conversión
correspondiente. Se utiliza el siguiente código:
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 información 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

Después del recorte se determina el umbral óptimo de la imagen. Esto
se hace calculando el gradiente de la imagen utilizando la técnica de
Sobel para hallar posibles picos en la imagen, y luego las siguientes
ecuaciones:

Se implementó el siguiente código para definir una función 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 función 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 código para el recorte y la
determinación 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 tamaño 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 morfológicas. Inicialmente se
utilizará un elemento estructurante circular de radio 10 píxeles para
realizar una transformación “bottom-hat”, que primero hace una
operación de “closing” (dilatación y luego erosión) 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 operación de “closing” (dilatación y luego
erosión) utilizando un elemento estructurante horizontal hallado
basándose en la separación que existe entre los caracteres de la placa
como se muestra en la figura 4. Después se realiza “opening” (erosión y
luego dilatación)
con un elemento estructurante vertical hallado
basándose 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 código:
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. Dilatación

Finalmente a partir de la imagen binarizada de la zona de la placa, se
pueden hallar la ubicación 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 código:
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 tamaño 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 continuación 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 líneas y elementos que nos producen ruido (Figura 8). Esto lo
podemos realizar mediante una estadística de la región tomada, y
aplicando un porcentaje de recorte posible por las características
estándar 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 región para que solo
las áreas mayores a 1.5% del total queden presentes. El siguiente es el
código 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 tamaño 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 carácter por separado, para esto
utilizamos el comando bwlabel para que nos divida la imagen en
regiones y poder determinar el área que posee cada región (que en este
caso nos demarcará el área ocupada por el carácter) y poder recortarlo
con el comando imcrop, obteniendo cada carácter en una variable por
separado. Luego, a cada carácter 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 código 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 tamaño 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 tamaño 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 tamaño 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 tamaño 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 tamaño 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 tamaño 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 carácter

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
mayúscula (no se tiene en cuanta la letra CH ni la Ñ), y los dígitos del 0
al 9. Para ello se realizaran archivos de imagen con los caracteres de
21*42 pixels, binarizados, que serán 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 código 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.bmp'); dos=imread('C:\MATLAB6p5\work.bmp');
tres=imread('C:\MATLAB6p5\work.bmp'); cuatro=imread('C:\MATLAB6p5\work.bmp');
cinco=imread('C:\MATLAB6p5\work.bmp'); seis=imread('C:\MATLAB6p5\work.bmp');
siete=imread('C:\MATLAB6p5\work.bmp'); ocho=imread('C:\MATLAB6p5\work.bmp');
nueve=imread('C:\MATLAB6p5\work.bmp'); cero=imread('C:\MATLAB6p5\work###BOT_TEXT###.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 conversión de matrices a un arreglo de celdas
de las variables numeral, alfabeto y matricula, para poder trabajar con
elementos separados y definidos por una posición para poder realizar
operaciones individuales sobre cada uno de los elementos. El siguiente
es el código 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 método adecuado para realizar el
reconocimiento del carácter hallado en la placa con uno presenta en la
base de datos. En esta caso se utilizo la técnica de correlación. Matlab
permite calcular el coeficiente de correlación entre dos matrices
bidimensionales, dando como resultado un valor que representa la
igualdad entre dos matrices. corr2 realiza el coeficiente de correlación
usando la expresión:

donde A = mean2(A), and B = mean2(B)
Se desarrolló un ciclo, el cual toma los valores de la correlación del
carácter que está siendo analizado y lo introduce en una matriz de 3
filas por 26 o 10 columnas, según sean letras o números
respectivamente. Posteriormente se hallan los máximos de las tres
columnas y son almacenados en otra matriz. Finalmente se encuentran
las posiciones en las que estaban los máximos para así determinar la
letra o el número al que corresponden y mediante otro ciclo se muestra
esto en pantalla. El código 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 utilización de los elementos estructurantes, definidos en
Matlab, es una herramienta poderosa para simplificar los
procedimientos a realizar cuando trabajamos con imágenes y
debemos eliminar estructuras y objetos irrelevantes al objetivo
propuesto.
No es aconsejable utilizar elementos estructurantes y propiedades
morfológicas si el objetivo es implementar el código en otro
compilador y programa diferente al de matlab, pero por facilidad y
economía de tiempo se podrían utilizar para tener un conocimiento
inicial de los pasos que se deben realizar para cumplir el objetivo
propuesto a la imagen.
Al utilizar métodos tradicionales de filtrado, erosionado y dilatado
de imágenes, aseguramos la portabilidad del código hacia otros
programas y dispositivos, como DSP´s, aunque su implementación
es mas larga, dificultosa y de mayor cuidado.