Universidad de Chile

Facultad de Ciencias Físicas y Matemáticas

Departamento de Ingeniría Eléctrica
Procesamiento Digital de Imágenes

EM752
Procesamiento Digital de Imágenes
Tarea Recuperativa

Estudiante David Pineda

Auxiliar Leonel Medina
Profesor Clauidio Pérez
Fecha 22/03/10
Índice de contenido
Estudio de características de la Madera................................................................................................3
Parte 1..............................................................................................................................................3
Parte 2..............................................................................................................................................6
Nudo Vivo.................................................................................................................................11
Medula......................................................................................................................................12
Grieta
...................................................................................................................................................13
Segmentación de una imagen de Arroz..............................................................................................14
Aplicación de algortimos locales en la obtención de características de un rostro..............................24
Local Normalization.....................................................................................................................24
Local Binary Pattern.....................................................................................................................25
Main...............................................................................................................................................26
Estudio de características de la Madera.

Se dispone de tres imágenes a analizar, se debe procesar de manera que la característica

buscada pueda ser detectada con los métodos a utilizar, para luego compararlo.
Las imágenes son:

Nudo Vivo Grieta Médula

Tabla 1. Imágenes a estudiar

Entonces, según la guía del problema, se deben filtrar los todos verdes de cada imágen y
luego operar en convolución con los métodos de gradiente Prewitt, Sobel y Roberts (al menos)

Parte 1
Para filtrar los tonos verdes, se deben separar las tres capas RGB de la imágen, tomar el
histograma de la capa verde y modificarla de manera que todos sus pixeles tengan un valor por
debajo del umbral en que el verde se hace notar. En este caso este umbral se determina con un valor
de 100 al analizar las imágenes.
Los pasos a seguir en MATLAB son:
1. Leer archivo de imagen:
Imagen=imread('archivo.bmp');
2. Separar las capas
3. Histograma de la capa Verde (G)
4. Filtro y ecualización de capa verde
5. Unir las capas Roja-Verde Filtrada-Azul
M=eliminaverde(Level,Imagen);
6. Guardar Imagén Filtrada
imwrite(M,'archivo_filtrada','png');
 El código de la función "eliminaverde" es:

function M=eliminaverde(Level,Imagen)
Igreen=Imagen(:,:,2);
maximo=max(max(Igreen))
figure
imshow(Igreen)
figure
imhist(Igreen);
%p2=imhist(Igris);
[m,n]=size(Igreen);
Level
k=double((maximo-Level))/Level;
k=ceil(k);

for i=1:m
for j=1:n
if Igreen(i,j)>=Level
u=Igreen(i,j)-Level;
B=u/k;
Mgreen(i,j)=round(B);
else
Mgreen(i,j)=Igreen(i,j);
end
end
end
figure
imhist(Mgreen);
figure
imshow(Mgreen);
M(:,:,1)=Imagen(:,:,2);
M(:,:,2)=Mgreen(:,:);
M(:,:,3)=Imagen(:,:,3);

Cómo se observa, opera los pasos 2 al 5 del algoritmo.

Los resultados obtenidos son:

Nudo Vivo Grieta Médula

Tabla 2. Histogramas pre y psot filtrado, resultado final.

Cómo se observa, los tonos verdes desaparecen y las imágenes toman tonos magenta.
Parte 2
En base a las imágenes filtradas, se debe convolucionar cada una con los filtros Prewit,
Sobel y Roberts para hacer la detección de la característica particular, luego analizar la eficiencia en
la detección de cada caso.
Para esto, se debe invertir el filtro, luego operarlo sobre un pixel de la imagen y la zona
circundante. Luego convolucion entre una imagen y un filtro es:

function Ig=convolucion2d(Imagen,Filtro)
%I imagen
%G filtro
I=Imagen;
G=Filtro;

[m1,n1]=size(G);
%se invierte filtro en 180°
for i=0:m1-1
for j=0:n1-1
G_(i+1,j+1)=G(m1-i,n1-j);
end
end
G=G_;
[m,n]=size(I);

%encontrar punto medio

a=floor(m1/2)+1;
b=floor(n1/2)+1;

H=zeros(m+2*(a-1),n+2*(b-1));
h=0;
for i=a:a+n-1
h=h+1;
o=0;
for j=b:b+n-1
o=o+1;
H(i,j)=I(h,o);
end
end
size(H)
%Para cada pixel a partir del punto a,b hacer la
convolucion entre ambas
%matrices
h=0;
for i=a:m+a-1
h=1+h;
o=0;
for j=b:n+b-1
o=1+o;
suma=0;
%el valor sobre el pixel i,j
for f=1:m1
for g=1:n1
r(f,g)=double(G(f,g))*double(H((i-a)+f,(j-b)+g));
suma=suma+r(f,g);
end
end
Ig(h,o)=uint8(suma); %error en ultimo punto
Ig(h,o);
end
end
 Luego de aplicar el filtro, para obtener una mejor vizualización se define un umbral y se
asigna un valor 0 para los pixeles que se ubican sobre el umbral y un valor de 255 par alos pixeles
ubicados bajo el umbral.

function B=binariza(Imagen,Level)
I=Imagen;
[m,n]=size(I);
for i=1:m
for j=1:n
if I(i,j)>=Level
B(i,j)=0;
else
B(i,j)=255;
end
end
end
 Las funciones para invocar los métodos son las siguientes.

Prewitt

%main calculo segun prewitt, sobel, figure

etc imshow(B3)
I1=imread('nudovivo_filtrado.png'); imwrite(uint8(I1_h),'D:\TareaImagene
I2=imread('medula_filtrado.png'); s\nudo_prewitt_h.png','png')
I3=imread('grieta_filtrado.png'); imwrite(uint8(I1_v),'D:\TareaImagene
%Prewitt s\nudo_prewitt_v.png','png')
P_1=[ 1 1 1;0 0 0; -1 -1 -1]; imwrite(uint8(I_nudo),'D:\TareaImage
P_2=[1 0 -1;1 0 -1;1 0 -1]; nes\nudo_prewitt.png','png')
%imagenes filtradas imwrite(uint8(B1),'D:\TareaImagenes\
I1_gray=rgb2gray(I1); nudo_prewitt_bin.png','png')
I2_gray=rgb2gray(I2); imwrite(uint8(I2_h),'D:\TareaImagene
I3_gray=rgb2gray(I3); s\grieta_prewitt_h.png','png')
%nudo vivo imwrite(uint8(I2_v),'D:\TareaImagene
I1_h=convolucion2d(I1_gray,P_1); s\grieta_prewitt_.png','png')
I1_v=convolucion2d(I1_gray,P_2); imwrite(uint8(I_medula),'D:\TareaIma
figure genes\grieta_prewitt.png','png')
imshow(I1_h) imwrite(uint8(B2),'D:\TareaImagenes\
figure grieta_prewitt_bin.png','png')
imshow(I1_v) imwrite(uint8(I3_h),'D:\TareaImagene
I_nudo=abs(I1_h)+abs(I1_v); s\grieta_prewitt_h.png','png')
figure imwrite(uint8(I3_v),'D:\TareaImagene
imshow(I_nudo) s\grieta_prewitt_v.png','png')
%medula imwrite(uint8(I_grieta),'D:\TareaIma
I2_h=convolucion2d(I2_gray,P_1); genes\grieta_prewitt.png','png')
I2_v=convolucion2d(I2_gray,P_2); imwrite(uint8(B3),'D:\TareaImagenes\
figure medula_prewitt_bin.png','png')
imshow(I2_h)
figure
imshow(I2_v)
I_medula=abs(I2_h)+abs(I2_v);
figure
imshow(I_medula)
%grieta
I3_h=convolucion2d(I3_gray,P_1);
I3_v=convolucion2d(I3_gray,P_2);
figure
imshow(I3_h)
figure
imshow(I3_v)
I_grieta=abs(I3_h)+abs(I3_v);
figure
imshow(I_grieta)
figure
imhist(uint8(I_nudo))
figure
imhist(uint8(I_medula))
figure
imhist(uint8(I_grieta))
B1=binariza(I_nudo,16);
B2=binariza(I_grieta,16);
B3=binariza(I_medula,16);
figure
imshow(B1)
figure
imshow(B2)
Roberts

%main calculo segun prewitt, sobel, figure

etc imhist(uint8(R_nudo))
I1=imread('nudovivo_filtrado.png'); figure
I2=imread('medula_filtrado.png'); imhist(uint8(R_medula))
I3=imread('grieta_filtrado.png'); figure
%Prewitt imhist(uint8(R_grieta))
R_1=[ 1 0; 0 -1];
R_2=[ 0 1;-1 0]; Br1=binariza(R_nudo,25);
%imagenes filtradas Br2=binariza(R_grieta,35);
%I1 nudo vivo Br3=binariza(R_medula,25);
%I2 medula
%I3 grieta figure
R1_gray=rgb2gray(I1); imshow(Br1)
R2_gray=rgb2gray(I2); figure
R3_gray=rgb2gray(I3); imshow(Br2)
%nudo vivo figure
R1_h=convolucion2d(R1_gray,R_1); imshow(Br3)
R1_v=convolucion2d(R1_gray,R_2);
figure imwrite(uint8(R1_h),'D:\TareaImagene
imshow(R1_h) s\nudo_robert_h.png','png')
figure imwrite(uint8(R1_v),'D:\TareaImagene
imshow(R1_v) s\nudo_robert_v.png','png')
R_nudo=abs(R1_h)+abs(R1_v); imwrite(uint8(R_nudo),'D:\TareaImage
figure nes\nudo_robert.png','png')
imshow(R_nudo) imwrite(uint8(Br1),'D:\TareaImagenes
%medula \nudo_robert_bin.png','png')
R2_h=convolucion2d(R2_gray,R_1);
R2_v=convolucion2d(R2_gray,R_2); imwrite(uint8(R2_h),'D:\TareaImagene
figure s\grieta_robert_h.png','png')
imshow(R2_h) imwrite(uint8(R2_v),'D:\TareaImagene
figure s\grieta_robert_.png','png')
imshow(R2_v) imwrite(uint8(R_medula),'D:\TareaIma
R_medula=abs(R2_h)+abs(R2_v); genes\grieta_robert.png','png')
figure imwrite(uint8(Br2),'D:\TareaImagenes
imshow(R_medula) \grieta_robert_bin.png','png')
%grieta
R3_h=convolucion2d(R3_gray,R_1); imwrite(uint8(R3_h),'D:\TareaImagene
R3_v=convolucion2d(R3_gray,R_2); s\medula_robert_h.png','png')
figure imwrite(uint8(R3_v),'D:\TareaImagene
imshow(R3_h) s\medula_robert_v.png','png')
figure imwrite(uint8(R_grieta),'D:\TareaIma
imshow(R3_v) genes\medula_robert.png','png')
R_grieta=abs(R3_h)+abs(R3_v); imwrite(uint8(Br3),'D:\TareaImagenes
figure \medula_robert_bin.png','png')
imshow(R_grieta)
Sobel
%main calculo segun , sobel, etc s\nudo_sobel_h.png','png')
S1=imread('nudovivo_filtrado.png'); imwrite(uint8(S1_v),'D:\Tareaimagene
S2=imread('medula_filtrado.png'); s\nudo_sobel_v.png','png')
S3=imread('grieta_filtrado.png'); imwrite(uint8(S_nudo),'D:\Tareaimage
%sobel nes\nudo_sobel.png','png')
P_1=[ 1 2 1;0 0 0; -1 -2 -1]; imwrite(uint8(B1),'D:\Tareaimagenes\
P_1=[ 1 0 -1;2 0 -2; 1 0 -1]; nudo_sobel_bin.png','png')
%Smagenes fSltradas imwrite(uint8(S2_h),'D:\Tareaimagene
%S1 nudo vSvo s\grieta_sobel_h.png','png')
%S2 medula imwrite(uint8(S2_v),'D:\Tareaimagene
%S3 grSeta s\grieta_sobel_.png','png')
S1_gray=rgb2gray(S1); imwrite(uint8(S_medula),'D:\Tareaima
S2_gray=rgb2gray(S2); genes\grieta_sobel.png','png')
S3_gray=rgb2gray(S3); imwrite(uint8(B2),'D:\Tareaimagenes\
%nudo vSvo grieta_sobel_bin.png','png')
S1_h=convolucion2d(S1_gray,P_1); imwrite(uint8(S3_h),'D:\Tareaimagene
S1_v=convolucion2d(S1_gray,P_2); s\medula_sobel_h.png','png')
figure imwrite(uint8(S3_v),'D:\Tareaimagene
imshow(S1_h) s\medula_sobel_v.png','png')
figure imwrite(uint8(S_grieta),'D:\Tareaima
imshow(S1_v) genes\medula_sobel.png','png')
S_nudo=abs(S1_h)+abs(S1_v); imwrite(uint8(B3),'D:\Tareaimagenes\
figure medula_sobel_bin.png','png')
imshow(S_nudo)
%medula
S2_h=convolucion2d(S2_gray,P_1);
S2_v=convolucion2d(S2_gray,P_2);
figure
imshow(S2_h)
figure
imshow(S2_v)
S_medula=abs(S2_h)+abs(S2_v);
figure
imshow(S_medula)
%grSeta
S3_h=convolucion2d(S3_gray,P_1);
S3_v=convolucion2d(S3_gray,P_2);
figure
imshow(S3_h)
figure
imshow(S3_v)
S_grieta=abs(S3_h)+abs(S3_v);
figure
imshow(S_grieta)
figure
imhist(uint8(S_nudo))
figure
imhist(uint8(S_medula))
figure
imhist(uint8(S_grieta))
Bs1=binariza(S_nudo,5);
Bs2=binariza(S_grieta,5);
Bs3=binariza(S_medula,5);
figure
imshow(Bs1)
figure
imshow(Bs2)
figure
imshow(Bs3)
imwrite(uint8(S1_h),'D:\Tareaimagene
Los resultados del estudio de las imágenes:

Nudo Vivo

Nudo Filtrado Prewitt

Roberts Sobel

Se observa que, para detectar nudos, el método roberts garantiza una mejor detección,
seguido del método sobel y por último prewitt (demasiado ténue).
Las imágenes de los gradientes por si mismas son muy oscuras, por lo que no vale la pena
ponerlas en este informe. El resultado es la aproximación binarizada de la suma algebraica de la
aplicación de los filtros por gradiente de cada método.
Medula

Médula Filstrada Prewitt

Roberts Sobel

Se observa en este caso que las respuestas de sobel o prewitt son mejores, ya que
practicamente no presentan ruido al detectar una medula en comparacion con roberts.
Grieta

Grieta Filtrada Prewitt

Roberts Sobel

Se observa que tanto sobel como prewitt son similares en su calidad de deteccion de la
grieta. En cambio roberts presenta perturbaciones que pueden complicar la detección, sin embargo
tambien se puede observar que la detecta con claridad.
Segmentación de una imagen de Arroz

El archivo arroz.txt se importa al matlab y luego se procesa como imagen, guardandola como
arroz.png.

El Log se define por el laplaciano del gaussiano:

Para obtener la segmentacion de arroz para distintos valores de sigma, desde 0.1 a 1.6, con un
tamaño de ventana 5 se escribió el siguiente código:

%LOG=laplacianodelgauss(mu,sigma,Imagen)
%para obtener el LoG se escribe:
%LOG=laplacianodelgauss(mu,sigma,Imagen)
%para obtener el LoG se escribe:
LoG1=[];
m=0;
for l=1:16
LoG1(:,:,l)=fspecial('log',5,.1*l);
Ig(:,:,l)=convolucion2d(Arroz,LoG1(:,:,l));
[y,u]=size(Ig)
subplot(4,4,l)
imshow(Ig(:,:,l))
title(strcat('Sigma=',num2str(l*.1)))
imwrite(uint8(Ig(:,:,l)),strcat('D:\TareaImagenes\parte2\Sigma_7_'
,num2str(l*.1),'.png'),'png')
B(:,:,l)=binariza(Ig(:,:,l),16);
imwrite(uint8(B(:,:,l)),strcat('D:\TareaImagenes\parte2\BIN_7_',nu
m2str(l*.1),'.png'),'png')
end
figure
for i=1:16
subplot(4,4,i)
imhist(uint8(Ig(:,:,i)))
title(strcat('Histograma Sigma=',num2str(i*.1)))
end
figure
for i=1:16
subplot(4,4,i)
imshow(B(:,:,i))
title(strcat('Binarizado Sigma=',num2str(i*.1)))
end
Lo que resulta en para un tamaño de matriz 3x3 y  variante

Se obtiene el histograma de cada imagen procesada para filtrar:

Filamente, se binariza:
Para un tamaño de matriz 5x5:
Y, por último, para un tamaño 7x7:
 A partir de la aplicacion del LOG sobre la imagen, luego de un análisis de los histogramas
de cada imagen, se observa en la binarización que la mejor segmentación con este tamaño de
ventana para este caso se obtiene para un sigma cercano a 1. El tamaño escogido de la matriz no
imfluye en gran medida, por lo que para optimizar cálculos se escoje una matriz de 5x5 que
representa lo más equilibrado en cuanto a resolución y tiempo de cálculo.

LoG1(:,:,1) =

8.0000 8.0000 8.0000 8.0000 8.0000

8.0000 8.0000 8.0000 8.0000 8.0000
8.0000 8.0000 -192.0000 8.0000 8.0000
8.0000 8.0000 8.0000 8.0000 8.0000
8.0000 8.0000 8.0000 8.0000 8.0000

LoG1(:,:,2) =

1.9996 1.9996 1.9996 1.9996 1.9996

1.9996 1.9996 2.0018 1.9996 1.9996
1.9996 2.0018 -47.9996 2.0018 1.9996
1.9996 1.9996 2.0018 1.9996 1.9996
1.9996 1.9996 1.9996 1.9996 1.9996

LoG1(:,:,3) =
 0.8131 0.8131 0.8131 0.8131 0.8131
0.8131 0.8164 1.1985 0.8164 0.8131
0.8131 1.1985 -21.0694 1.1985 0.8131
0.8131 0.8164 1.1985 0.8164 0.8131
0.8131 0.8131 0.8131 0.8131 0.8131

LoG1(:,:,4) =

0.2475 0.2475 0.2479 0.2475 0.2475

0.2475 0.3545 1.2336 0.3545 0.2475
0.2479 1.2336 -10.3145 1.2336 0.2479
0.2475 0.3545 1.2336 0.3545 0.2475
0.2475 0.2475 0.2479 0.2475 0.2475

LoG1(:,:,5) =

0.0448 0.0468 0.0564 0.0468 0.0448

0.0468 0.3167 0.7146 0.3167 0.0468
0.0564 0.7146 -4.9048 0.7146 0.0564
0.0468 0.3167 0.7146 0.3167 0.0468
0.0448 0.0468 0.0564 0.0468 0.0448

LoG1(:,:,6) =

0.0056 0.0192 0.0483 0.0192 0.0056

0.0192 0.2758 0.2426 0.2758 0.0192
0.0483 0.2426 -2.4429 0.2426 0.0483
0.0192 0.2758 0.2426 0.2758 0.0192
0.0056 0.0192 0.0483 0.0192 0.0056

LoG1(:,:,7) =

0.0034 0.0338 0.0697 0.0338 0.0034

0.0338 0.1800 0.0105 0.1800 0.0338
0.0697 0.0105 -1.3250 0.0105 0.0697
0.0338 0.1800 0.0105 0.1800 0.0338
0.0034 0.0338 0.0697 0.0338 0.0034

LoG1(:,:,8) =

0.0094 0.0470 0.0742 0.0470 0.0094

0.0470 0.0933 -0.0765 0.0933 0.0470
0.0742 -0.0765 -0.7770 -0.0765 0.0742
0.0470 0.0933 -0.0765 0.0933 0.0470
0.0094 0.0470 0.0742 0.0470 0.0094
LoG1(:,:,9) =

0.0173 0.0501 0.0643 0.0501 0.0173

0.0501 0.0369 -0.0973 0.0369 0.0501
0.0643 -0.0973 -0.4850 -0.0973 0.0643
0.0501 0.0369 -0.0973 0.0369 0.0501
0.0173 0.0501 0.0643 0.0501 0.0173

LoG1(:,:,10) =

0.0239 0.0460 0.0499 0.0460 0.0239

0.0460 0.0061 -0.0923 0.0061 0.0460
0.0499 -0.0923 -0.3182 -0.0923 0.0499
0.0460 0.0061 -0.0923 0.0061 0.0460
0.0239 0.0460 0.0499 0.0460 0.0239

LoG1(:,:,11) =

0.0276 0.0390 0.0367 0.0390 0.0276

0.0390 -0.0087 -0.0792 -0.0087 0.0390
0.0367 -0.0792 -0.2173 -0.0792 0.0367
0.0390 -0.0087 -0.0792 -0.0087 0.0390
0.0276 0.0390 0.0367 0.0390 0.0276

LoG1(:,:,12) =

0.0285 0.0316 0.0263 0.0316 0.0285

0.0316 -0.0146 -0.0652 -0.0146 0.0316
0.0263 -0.0652 -0.1534 -0.0652 0.0263
0.0316 -0.0146 -0.0652 -0.0146 0.0316
0.0285 0.0316 0.0263 0.0316 0.0285

LoG1(:,:,13) =

0.0275 0.0252 0.0187 0.0252 0.0275

0.0252 -0.0161 -0.0527 -0.0161 0.0252
0.0187 -0.0527 -0.1114 -0.0527 0.0187
0.0252 -0.0161 -0.0527 -0.0161 0.0252
0.0275 0.0252 0.0187 0.0252 0.0275

LoG1(:,:,14) =

0.0255 0.0199 0.0133 0.0199 0.0255

0.0199 -0.0155 -0.0425 -0.0155 0.0199
0.0133 -0.0425 -0.0828 -0.0425 0.0133
0.0199 -0.0155 -0.0425 -0.0155 0.0199
 0.0255 0.0199 0.0133 0.0199 0.0255

LoG1(:,:,15) =

0.0230 0.0158 0.0095 0.0158 0.0230

0.0158 -0.0140 -0.0342 -0.0140 0.0158
0.0095 -0.0342 -0.0628 -0.0342 0.0095
0.0158 -0.0140 -0.0342 -0.0140 0.0158
0.0230 0.0158 0.0095 0.0158 0.0230

LoG1(:,:,16) =

0.0203 0.0125 0.0069 0.0125 0.0203

0.0125 -0.0124 -0.0277 -0.0124 0.0125
0.0069 -0.0277 -0.0486 -0.0277 0.0069
0.0125 -0.0124 -0.0277 -0.0124 0.0125
0.0203 0.0125 0.0069 0.0125 0.0203

Las imagenes en forma separada se ubican en la carpeta "parte2".

Ahora bien, si se ocupa el método de Prewitt para segmentar se obtiene la imagen binaria
siguiente, con un corte deumbral 120.

Se observa que es bastante más difusa la segmentación que con el método LOG.

Con el método roberts se obtuvo un mejor resultado, con un umbral de corte en 100:

Lo que era de esperarse ya que en la parte 1 este método detecta de mejor forma las figuras
ovaladas.
Aplicación de algortimos locales en la obtención de
características de un rostro

Consiste en implementar los métodos que aplican un estudio sobre la zona circundante del
pixel en cuestión.
Los dos métodos implementados son Local Normalization y Local Binary Pattern.
Se escribió primero el código correspondiente a las funciones de cada método y luego un
archivo central (main) que los invoca y muestra los resultados.

Local Normalization

function LN=localnormalization(Imagen,N)
%N grado de la local norma,[0,1,2,] induce una ventana cuadrada de
tamaño imapar
K=2*N+1

I=Imagen;
[m,n]=size(I);

LN=zeros(m,n);% una imagen retorna del mismo tamaño pero procesada

a=(K-1)/2

for i=K-a:m-a
for j=K-a:n-a
g_=double(I(i-a:i+a,j-a:j+a));
g=g_(:);
mu=mean(g);
st=std(g);
LN(i,j)=((double(I(i,j))-mu)/st);%uint8
end
end
end
Local Binary Pattern

function LBP=localbinarypattern(Imagen)
K=3;
I=Imagen;
[m,n]=size(I);

LBP=zeros(m,n);% una imagen retorna del mismo tamaño pero procesada

a=(K-1)/2;

for i=K-a:m-a-1
for j=K-a:n-a-1

for k=1:K
for l=1:K
g_(a+1,a+1)=0;
if I(i-2+k,j-2+l)<I(i,j)
g_(k,l)=1;
else
g_(k,l)=0;
end

end
end
g=g_(:);
a=g(1:4);
b=g(6:9);
g=[a;b];
g=flipud(g);
LBP(i,j)=binvec2dec(g');%uint8
end
end
end
Main

I=imread('cara.png');
%etapa local nomalization
subplot(1,6,1);
imshow(I);
title('Original')
for i=1:4
LN(:,:,i)=localnormalization(I,i);
subplot(1,6,i+1);
imshow(LN(:,:,i));
title(strcat('Local Norm. Ventana
',num2str(2*i+1),'x',num2str(2*i+1)));
imwrite((LN(:,:,i)),strcat('D:\TareaImagenes\parte3\cara_ventana_
',num2str(2*i+1),'.png'),'png')
end
figure
%etapa Local binary pattern
LBP=localbinarypattern(I);
subplot(1,2,1);
imshow(I);
title('Original')
subplot(1,2,2);
imshow(LBP);
title('LBP')
imwrite(LBP,'D:\TareaImagenes\parte3\cara_LBP_.png','png')

figure
%etapa Local binary pattern
subplot(1,2,1);
imshow(I);
title('Original')
subplot(1,2,2);
imshow(LN(:,:,1));
title('LN 3x3')

figure
%etapa Local binary pattern
subplot(1,2,1);
imshow(LBP);
title('LBP')
subplot(1,2,2);
imshow(LN(:,:,1));
title('LN 3x3')
 La función localnormalization permite obtener resultados para distintos tamaños de ventana,
como se observa de los resultados de la primera parte del main:

O r ig in a l L o c a l N o rm . V e n ta n a 3 x 3 L o c a l N o rm . V e n ta n a 5 x 5 L o c a l N o rm . V e n ta n a 7 x 7 L o c a l N o rm . V e n ta n a 9 x 9

En la forma requerida, para una venta 3x3

O rig in a l LN 3x3
Luego, la LBP resultante es:

O r ig in a l LB P

Luego, la comparación de ambos métodos:

LB P LN 3x3
 Con esto, se puede observar que en ambos métodos se pueden extraer características de la
imagen, sin embargo se puede decir que LN al ser un resultado estadistico de la zona circundante
retorna mejores resultados que LBP que retorna resultados booleanos de la zona circundante. LN
sería entonces, como se observa, más sensible a características obviadas en el caso LBP.

En cuanto a las velocidades de procesamiento, se percibe en LN mayor rapidez de cálculo

que LBP. Esto se debería a que LBP se demora más al realizar operaciones booleanas, en cambio
LN sólo realiza sumas y multiplicaciones.