Universidad de ChileFacultad de Ciencias Físicas y MatemáticasDepartamento de Ingeniría EléctricaProcesamiento Digital de Imágenes

EM752Procesamiento Digital de Imágenes

Tarea Recuperativa

Estudiante David Pineda

Auxiliar Leonel Medina

Profesor Clauidio Pérez

Fecha 22/03/10

Índice de contenidoEstudio de características de la Madera................................................................................................3

Parte 1..............................................................................................................................................3Parte 2..............................................................................................................................................6

Nudo Vivo.................................................................................................................................11Medula......................................................................................................................................12Grieta...................................................................................................................................................13

Segmentación de una imagen de Arroz..............................................................................................14Aplicación de algortimos locales en la obtención de características de un rostro..............................24

Local Normalization.....................................................................................................................24 Local Binary Pattern.....................................................................................................................25Main...............................................................................................................................................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édulaTabla 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 1Para 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:

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

function M=eliminaverde(Level,Imagen)Igreen=Imagen(:,:,2);maximo=max(max(Igreen))figureimshow(Igreen)figureimhist(Igreen);%p2=imhist(Igris);[m,n]=size(Igreen);Levelk=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 endendfigureimhist(Mgreen);figureimshow(Mgreen);M(:,:,1)=Imagen(:,:,2);M(:,:,2)=Mgreen(:,:);M(:,:,3)=Imagen(:,:,3);

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 2En 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 filtroI=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); endendG=G_;[m,n]=size(I); %encontrar punto medioa=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); endendsize(H)%Para cada pixel a partir del punto a,b hacer la convolucion entre ambas%matricesh=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); endend

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 endend

Las funciones para invocar los métodos son las siguientes.

Prewitt

%main calculo segun prewitt, sobel, etcI1=imread('nudovivo_filtrado.png');I2=imread('medula_filtrado.png');I3=imread('grieta_filtrado.png');%PrewittP_1=[ 1 1 1;0 0 0; -1 -1 -1];P_2=[1 0 -1;1 0 -1;1 0 -1];%imagenes filtradasI1_gray=rgb2gray(I1);I2_gray=rgb2gray(I2);I3_gray=rgb2gray(I3);%nudo vivoI1_h=convolucion2d(I1_gray,P_1);I1_v=convolucion2d(I1_gray,P_2);figureimshow(I1_h)figureimshow(I1_v)I_nudo=abs(I1_h)+abs(I1_v);figureimshow(I_nudo)%medulaI2_h=convolucion2d(I2_gray,P_1);I2_v=convolucion2d(I2_gray,P_2);figureimshow(I2_h)figureimshow(I2_v)I_medula=abs(I2_h)+abs(I2_v);figureimshow(I_medula)%grietaI3_h=convolucion2d(I3_gray,P_1);I3_v=convolucion2d(I3_gray,P_2);figureimshow(I3_h)figureimshow(I3_v)I_grieta=abs(I3_h)+abs(I3_v);figureimshow(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);figureimshow(B1)figureimshow(B2)

figureimshow(B3)imwrite(uint8(I1_h),'D:\TareaImagenes\nudo_prewitt_h.png','png')imwrite(uint8(I1_v),'D:\TareaImagenes\nudo_prewitt_v.png','png')imwrite(uint8(I_nudo),'D:\TareaImagenes\nudo_prewitt.png','png')imwrite(uint8(B1),'D:\TareaImagenes\nudo_prewitt_bin.png','png')imwrite(uint8(I2_h),'D:\TareaImagenes\grieta_prewitt_h.png','png')imwrite(uint8(I2_v),'D:\TareaImagenes\grieta_prewitt_.png','png')imwrite(uint8(I_medula),'D:\TareaImagenes\grieta_prewitt.png','png')imwrite(uint8(B2),'D:\TareaImagenes\grieta_prewitt_bin.png','png')imwrite(uint8(I3_h),'D:\TareaImagenes\grieta_prewitt_h.png','png')imwrite(uint8(I3_v),'D:\TareaImagenes\grieta_prewitt_v.png','png')imwrite(uint8(I_grieta),'D:\TareaImagenes\grieta_prewitt.png','png')imwrite(uint8(B3),'D:\TareaImagenes\medula_prewitt_bin.png','png')

Roberts

%main calculo segun prewitt, sobel, etcI1=imread('nudovivo_filtrado.png');I2=imread('medula_filtrado.png');I3=imread('grieta_filtrado.png');%PrewittR_1=[ 1 0; 0 -1];R_2=[ 0 1;-1 0];%imagenes filtradas%I1 nudo vivo%I2 medula %I3 grietaR1_gray=rgb2gray(I1);R2_gray=rgb2gray(I2);R3_gray=rgb2gray(I3);%nudo vivoR1_h=convolucion2d(R1_gray,R_1);R1_v=convolucion2d(R1_gray,R_2);figureimshow(R1_h)figureimshow(R1_v)R_nudo=abs(R1_h)+abs(R1_v);figureimshow(R_nudo)%medulaR2_h=convolucion2d(R2_gray,R_1);R2_v=convolucion2d(R2_gray,R_2);figureimshow(R2_h)figureimshow(R2_v)R_medula=abs(R2_h)+abs(R2_v);figureimshow(R_medula)%grietaR3_h=convolucion2d(R3_gray,R_1);R3_v=convolucion2d(R3_gray,R_2);figureimshow(R3_h)figureimshow(R3_v)R_grieta=abs(R3_h)+abs(R3_v);figureimshow(R_grieta)

figure imhist(uint8(R_nudo))figure imhist(uint8(R_medula))figure imhist(uint8(R_grieta)) Br1=binariza(R_nudo,25);Br2=binariza(R_grieta,35);Br3=binariza(R_medula,25); figureimshow(Br1)figureimshow(Br2)figureimshow(Br3) imwrite(uint8(R1_h),'D:\TareaImagenes\nudo_robert_h.png','png')imwrite(uint8(R1_v),'D:\TareaImagenes\nudo_robert_v.png','png')imwrite(uint8(R_nudo),'D:\TareaImagenes\nudo_robert.png','png')imwrite(uint8(Br1),'D:\TareaImagenes\nudo_robert_bin.png','png') imwrite(uint8(R2_h),'D:\TareaImagenes\grieta_robert_h.png','png')imwrite(uint8(R2_v),'D:\TareaImagenes\grieta_robert_.png','png')imwrite(uint8(R_medula),'D:\TareaImagenes\grieta_robert.png','png')imwrite(uint8(Br2),'D:\TareaImagenes\grieta_robert_bin.png','png') imwrite(uint8(R3_h),'D:\TareaImagenes\medula_robert_h.png','png')imwrite(uint8(R3_v),'D:\TareaImagenes\medula_robert_v.png','png')imwrite(uint8(R_grieta),'D:\TareaImagenes\medula_robert.png','png')imwrite(uint8(Br3),'D:\TareaImagenes\medula_robert_bin.png','png')

Sobel

%main calculo segun , sobel, etcS1=imread('nudovivo_filtrado.png');S2=imread('medula_filtrado.png');S3=imread('grieta_filtrado.png');%sobelP_1=[ 1 2 1;0 0 0; -1 -2 -1];P_1=[ 1 0 -1;2 0 -2; 1 0 -1];%Smagenes fSltradas%S1 nudo vSvo%S2 medula %S3 grSetaS1_gray=rgb2gray(S1);S2_gray=rgb2gray(S2);S3_gray=rgb2gray(S3);%nudo vSvoS1_h=convolucion2d(S1_gray,P_1);S1_v=convolucion2d(S1_gray,P_2);figureimshow(S1_h)figureimshow(S1_v)S_nudo=abs(S1_h)+abs(S1_v);figureimshow(S_nudo)%medulaS2_h=convolucion2d(S2_gray,P_1);S2_v=convolucion2d(S2_gray,P_2);figureimshow(S2_h)figureimshow(S2_v)S_medula=abs(S2_h)+abs(S2_v);figureimshow(S_medula)%grSetaS3_h=convolucion2d(S3_gray,P_1);S3_v=convolucion2d(S3_gray,P_2);figureimshow(S3_h)figureimshow(S3_v)S_grieta=abs(S3_h)+abs(S3_v);figureimshow(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);figureimshow(Bs1)figureimshow(Bs2)figureimshow(Bs3)imwrite(uint8(S1_h),'D:\Tareaimagene

s\nudo_sobel_h.png','png')imwrite(uint8(S1_v),'D:\Tareaimagenes\nudo_sobel_v.png','png')imwrite(uint8(S_nudo),'D:\Tareaimagenes\nudo_sobel.png','png')imwrite(uint8(B1),'D:\Tareaimagenes\nudo_sobel_bin.png','png')imwrite(uint8(S2_h),'D:\Tareaimagenes\grieta_sobel_h.png','png')imwrite(uint8(S2_v),'D:\Tareaimagenes\grieta_sobel_.png','png')imwrite(uint8(S_medula),'D:\Tareaimagenes\grieta_sobel.png','png')imwrite(uint8(B2),'D:\Tareaimagenes\grieta_sobel_bin.png','png')imwrite(uint8(S3_h),'D:\Tareaimagenes\medula_sobel_h.png','png')imwrite(uint8(S3_v),'D:\Tareaimagenes\medula_sobel_v.png','png')imwrite(uint8(S_grieta),'D:\Tareaimagenes\medula_sobel.png','png')imwrite(uint8(B3),'D:\Tareaimagenes\medula_sobel_bin.png','png')

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:16LoG1(:,:,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_',num2str(l*.1),'.png'),'png')end figurefor i=1:16subplot(4,4,i)imhist(uint8(Ig(:,:,i)))title(strcat('Histograma Sigma=',num2str(i*.1))) end figurefor i=1:16subplot(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 endendend

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 endendend

Main

I=imread('cara.png');%etapa local nomalizationsubplot(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')endfigure%etapa Local binary patternLBP=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 patternsubplot(1,2,1);imshow(I);title('Original')subplot(1,2,2);imshow(LN(:,:,1));title('LN 3x3')

figure%etapa Local binary patternsubplot(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:

En la forma requerida, para una venta 3x3

O r i g i n a l L o c a l N o r m . V e n t a n a 3 x 3 L o c a l N o r m . V e n t a n a 5 x 5 L o c a l N o r m . V e n t a n a 7 x 7 L o c a l N o r m . V e n t a n a 9 x 9

O r i g i n a l L N 3 x 3

Luego, la LBP resultante es:

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

O r i g i n a l L B P

L B P L N 3 x 3

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.