|
|
Línea 5: |
Línea 5: |
| [[Imagen:Girasol.png|200px|thumb|]] | | [[Imagen:Girasol.png|200px|thumb|]] |
|
| |
|
|
| |
| ***** eduardo jose de almeida
| |
|
| |
| function [ error, disparidad ] = extraer_objetos( izda, dcha, limites_col_izda, limites_filas_izda, limites_col_dcha, limites_filas_dcha, componente_actual, proyeccion_izda_cols, proyeccion_dcha_cols )
| |
| %calcula el porcentaje de pÌxeles diferentes entre la imagen izda y dcha,
| |
| %asÌ como su disparidad
| |
|
| |
| %Recorte del primer componente
| |
| recorte_izda = izda(limites_filas_izda(1):limites_filas_izda(2), limites_col_izda(1):limites_col_izda(2));
| |
| recorte_dcha = dcha(limites_filas_dcha(1):limites_filas_dcha(2), limites_col_dcha(1):limites_col_dcha(2));
| |
|
| |
| %asumo que los objetos son oscuros y el fondo blanco
| |
| recorte_izda = 1 - recorte_izda;
| |
| recorte_dcha = 1 - recorte_dcha;
| |
|
| |
| figure(componente_actual)
| |
| title(strcat('Componente izquierda ', num2str(componente_actual)));
| |
| imshow(recorte_izda);
| |
|
| |
| figure(componente_actual)
| |
| title(strcat('Componente derecha ', num2str(componente_actual)));
| |
| imshow(recorte_dcha);
| |
|
| |
| %Calcular el centro de las proyecciones del componente actual
| |
| centro_izda = sum((limites_col_izda(1):limites_col_izda(2)).*proyeccion_izda_cols(limites_col_izda(1):limites_col_izda(2))/sum(proyeccion_izda_cols(limites_col_izda(1):limites_col_izda(2))));
| |
| centro_dcha = sum((limites_col_dcha(1):limites_col_dcha(2)).*proyeccion_dcha_cols(limites_col_dcha(1):limites_col_dcha(2))/sum(proyeccion_dcha_cols(limites_col_dcha(1):limites_col_dcha(2))));
| |
|
| |
| disparidad(componente_actual) = centro_izda - centro_dcha;
| |
|
| |
| error(componente_actual) = tasa_error_pixeles_bn(recorte_izda, recorte_dcha);
| |
|
| |
|
| |
| end
| |
|
| |
|
| |
| function [error, disparidad] = identificar_objetos_disparidad(umbral_binarizacion, alto_min, ancho_min)
| |
| %Hay n objetos coplanares
| |
|
| |
| close all;
| |
| dcha = imread('par4-d.jpg');
| |
| izda = imread('par4-izq.jpg');
| |
| %Convertir a escala de grises
| |
| dcha = rgb2gray(dcha);
| |
| izda = rgb2gray(izda);
| |
| %Recortar el elemento no deseado
| |
| dcha = dcha(1:600,1:1024);
| |
| izda = izda(1:600,1:1024);
| |
|
| |
| [filas, columnas] = size(dcha);
| |
| %BinarizaciÛn
| |
| izda = izda < umbral_binarizacion;
| |
| dcha = dcha < umbral_binarizacion;
| |
|
| |
| %ProyecciÛn por columnas
| |
| proyeccion_izda_cols = sum(izda);
| |
| proyeccion_dcha_cols = sum(dcha);
| |
|
| |
| %ProyecciÛn por filas
| |
| proyeccion_izda_filas = sum(izda');
| |
| proyeccion_dcha_filas = sum(dcha');
| |
|
| |
| %C·lculo de los lÌmites de la proyecciÛn del primer componente
| |
| [min_col_izda, max_col_izda] = limites_proyeccion(proyeccion_izda_cols, columnas, alto_min);
| |
| [min_col_dcha, max_col_dcha] = limites_proyeccion(proyeccion_dcha_cols, columnas, alto_min);
| |
| [min_fila_izda, max_fila_izda] = limites_proyeccion(proyeccion_izda_filas, filas, alto_min);
| |
| [min_fila_dcha, max_fila_dcha] = limites_proyeccion(proyeccion_dcha_filas, filas, alto_min);
| |
|
| |
| ancho_izda = abs(min_col_izda - max_col_izda);
| |
| ancho_dcha = abs(min_col_dcha - max_col_dcha);
| |
|
| |
| limites_col_izda = [min_col_izda, max_col_izda];
| |
| limites_filas_izda = [min_fila_izda, max_fila_izda];
| |
|
| |
| limites_col_dcha = [min_col_dcha, max_col_dcha];
| |
| limites_filas_dcha = [min_fila_dcha, max_fila_dcha];
| |
|
| |
| componente_actual = 1;
| |
|
| |
| [error, disparidad] = extraer_objetos(izda, dcha, limites_col_izda, limites_filas_izda, limites_col_dcha, limites_filas_dcha, componente_actual, proyeccion_izda_cols, proyeccion_dcha_cols);
| |
| error_1 = error(1);
| |
| disparidad_1 = disparidad(1);
| |
| proyeccion_izda_cols(1:max_col_izda) = 0;
| |
| proyeccion_dcha_cols(1:max_col_dcha) = 0;
| |
| componente_actual = componente_actual + 1;
| |
| while(ancho_izda > ancho_min) && (ancho_dcha > ancho_min)
| |
|
| |
|
| |
| %C·lculo de los lÌmites de la proyecciÛn del primer componente
| |
| [min_col_izda, max_col_izda] = limites_proyeccion(proyeccion_izda_cols, columnas, alto_min);
| |
| [min_col_dcha, max_col_dcha] = limites_proyeccion(proyeccion_dcha_cols, columnas, alto_min);
| |
| [min_fila_izda, max_fila_izda] = limites_proyeccion(proyeccion_izda_filas, filas, alto_min);
| |
| [min_fila_dcha, max_fila_dcha] = limites_proyeccion(proyeccion_dcha_filas, filas, alto_min);
| |
|
| |
| ancho_izda = min_col_izda - max_col_izda;
| |
| ancho_dcha = min_col_dcha - max_col_dcha;
| |
|
| |
| limites_col_izda = [min_col_izda, max_col_izda];
| |
| limites_filas_izda = [min_fila_izda, max_fila_izda];
| |
|
| |
| limites_col_dcha = [min_col_dcha, max_col_dcha];
| |
| limites_filas_dcha = [min_fila_dcha, max_fila_dcha];
| |
|
| |
| [error, disparidad] = extraer_objetos(izda, dcha, limites_col_izda, limites_filas_izda, limites_col_dcha, limites_filas_dcha, componente_actual, proyeccion_izda_cols, proyeccion_dcha_cols);;
| |
| %anulo el componente tratado en las columnas
| |
| %al ser im·genes coplanares solo hay un componente
| |
| %en la proyecciÛn por filas
| |
| proyeccion_izda_cols(min_col_izda:max_col_izda) = 0;
| |
| proyeccion_dcha_cols(min_col_dcha:max_col_dcha) = 0;
| |
| componente_actual = componente_actual + 1;
| |
|
| |
| end
| |
|
| |
| error(1) = error_1;
| |
| disparidad(1) = disparidad_1;
| |
|
| |
|
| |
| end
| |
|
| |
| function [ min, max ] = limites_proyeccion( proyeccion, dim, umbral_ruido)
| |
|
| |
| %primer componente, limite inferior de la proyecciÛn izda
| |
| for min=1:dim
| |
| if proyeccion(min) > umbral_ruido
| |
| break;
| |
| end
| |
| end
| |
| %primer componente, limite superior de la proyecciÛn izda
| |
| for max=min:dim
| |
| if proyeccion(max) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
|
| |
| end
| |
|
| |
|
| |
| function [ tasa_error ] = tasa_error_pixeles_bn( im_1, im_2 )
| |
|
| |
| %Recorte de las im·genes para que coincidan en tamaÒos
| |
| [filas_im_1, col_im_1] = size(im_1);
| |
| [filas_im_2, col_im_2] = size(im_2);
| |
| % [filas_segundo_izda, col_segundo_izda] = size(recorte_izda_im_2);
| |
| % [filas_segundo_dcha, col_segundo_dcha] = size(recorte_dcha_im_2);
| |
|
| |
| [min_filas] = min([filas_im_1, filas_im_2]);
| |
| [min_cols] = min([col_im_1, col_im_2]);
| |
|
| |
| im_1 = im_1(1:min_filas,1:min_cols);
| |
| im_2 = im_2(1:min_filas,1:min_cols);
| |
|
| |
| %Cuenta del n˙mero de pÌxeles diferentes y porcentaje respecto el total
| |
| diferencia_pix = sum(sum(abs(im_1 - im_2)));
| |
| tasa_error = diferencia_pix*100/(min_filas*min_cols);
| |
|
| |
| end
| |
|
| |
|
| |
|
| |
| ******** abraham tena
| |
|
| |
| function disparidadt = calculo_disparidad_proyeccionest(izda, dcha, umbral)
| |
|
| |
| %asumo que los objetos son oscuros y el fondo blanco
| |
| izda = izda < umbral;
| |
| dcha = dcha < umbral;
| |
|
| |
| proyeccion_izda = sum(izda); %Suma vertical de 1's
| |
| proyeccion_dcha = sum(dcha); %Suma vertical de 1's
| |
| proyeccion_izdat = sum(izda'); %Suma horizontal de 1's
| |
| proyeccion_dchat = sum(dcha'); %Suma horizontal de 1's
| |
|
| |
| figure(1)
| |
| plot(proyeccion_izda);
| |
| figure(2)
| |
| plot(proyeccion_dcha);
| |
| figure(3)
| |
| plot(proyeccion_izdat);
| |
| figure(4)
| |
| plot(proyeccion_dchat);
| |
|
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| |
| %primer componente, limite inferior de la proyecciÛn izda
| |
| for i_1=1:1000
| |
| if proyeccion_izda(i_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| %primer componente, limite superior de la proyecciÛn izda
| |
| for i_2=i_1:1000
| |
| if proyeccion_izda(i_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| %primer componente, limite inferior de la proyecciÛn derecha
| |
| for j_1=1:1000
| |
| if proyeccion_dcha(j_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| %primer componente, limite superior de la proyecciÛn derecha
| |
| for j_2=j_1:1000
| |
| if proyeccion_dcha(j_2) == 0
| |
| break;
| |
| end
| |
| end
| |
| %%%
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| |
| %%%
| |
| %primer componente, limite inferior de la proyecciÛn izda
| |
| for it_1=1:1000
| |
| if proyeccion_izdat(it_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| %primer componente, limite superior de la proyecciÛn izda
| |
| for it_2=it_1:1000
| |
| if proyeccion_izdat(it_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| %primer componente, limite inferior de la proyecciÛn derecha
| |
| for jt_1=1:1000
| |
| if proyeccion_dchat(jt_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| %primer componente, limite superior de la proyecciÛn derecha
| |
| for jt_2=jt_1:1000
| |
| if proyeccion_dchat(jt_2)2 == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| %Calcular el centro de las proyecciones de los componentes
| |
| centro_izda = sum((1:i_2).*proyeccion_izda(1:i_2)/sum(proyeccion_izda(1:i_2)));
| |
| centro_dcha = sum((1:j_2).*proyeccion_dcha(1:j_2)/sum(proyeccion_dcha(1:j_2)));
| |
| centro_izdat = sum((1:it_2).*proyeccion_izdat(1:it_2)/sum(proyeccion_izdat(1:it_2)));
| |
| centro_dchat = sum((1:jt_2).*proyeccion_dchat(1:jt_2)/sum(proyeccion_dchat(1:jt_2)));
| |
|
| |
| disparidadt(1) = centro_izda - centro_dcha;
| |
| disparidadt(3) = centro_izdat - centro_dchat;
| |
|
| |
| %anulo el primer componente
| |
| proyeccion_izda(1:i_2) = 0;
| |
| proyeccion_dcha(1:j_2) = 0;
| |
| proyeccion_izdat(1:it_2) = 0;
| |
| proyeccion_dchat(1:jt_2) = 0;
| |
|
| |
| %proceso para el segundo componente
| |
|
| |
| figure(5)
| |
| plot(proyeccion_izda);
| |
| figure(6)
| |
| plot(proyeccion_dcha);
| |
| figure(7)
| |
| plot(proyeccion_izdat);
| |
| figure(8)
| |
| plot(proyeccion_dchat);
| |
|
| |
| for i_1=1:1000
| |
| if proyeccion_izda(i_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| for i_2=i_1:1000
| |
| if proyeccion_izda(i_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| for j_1=1:1000
| |
| if proyeccion_dcha(j_1) > 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| for j_2=j_1:1000
| |
| if proyeccion_dcha(j_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| %%%
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| |
| %%%
| |
| for i_1t=1:1000
| |
| if proyeccion_izdat(it_1) > 0
| |
| break;
| |
| end
| |
| end
| |
| for it_2=it_1:1000
| |
| if proyeccion_izdat(it_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| for jt_1=1:1000
| |
| if proyeccion_dchat(jt_1) > 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| for jt_2=jt_1:1000
| |
| if proyeccion_dchat(jt_2) == 0
| |
| break;
| |
| end
| |
| end
| |
|
| |
| %Calcular el centro de las proyecciones de los componentes
| |
| centro_izda = sum((1:i_2).*proyeccion_izda(1:i_2)/sum(proyeccion_izda(1:i_2)));
| |
| centro_dcha = sum((1:j_2).*proyeccion_dcha(1:j_2)/sum(proyeccion_dcha(1:j_2)));
| |
| centro_izdat = sum((1:it_2).*proyeccion_izdat(1:it_2)/sum(proyeccion_izdat(1:it_2)));
| |
| centro_dchat = sum((1:jt_2).*proyeccion_dchat(1:jt_2)/sum(proyeccion_dchat(1:jt_2)));
| |
|
| |
| disparidadt(2) = centro_izda - centro_dcha;
| |
| disparidadt(4) = centro_izdat - centro_dchat;
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| |
|
| |
| end
| |
|
| |
| ********** lara regidor
| |
|
| |
| identificacion_objetos.m
| |
|
| |
| function disparidad=identificacion_objetos(izq, dcha, umbralbin,tamanomin)
| |
|
| |
| % Recorto las im�genes para quitar la parte inferior negra
| |
| izq=izq(1:600,1:1024);
| |
| dcha=dcha(1:600,1:1024);
| |
|
| |
| % Binarizo las im�genes
| |
| izq=izq<umbralbin;
| |
| dcha=dcha<umbralbin;
| |
|
| |
| % Calculo las proyecciones de cada imagen y las muestr
| |
| proyeccion_izq=sum(izq);
| |
| proyeccion_dcha=sum(dcha);
| |
| %figure(1)
| |
| plot(proyeccion_izq)
| |
| %figure(2)
| |
| %plot(proyeccion_dcha)
| |
|
| |
| % Calcular los limites de la imagen izquierda (por columnas)
| |
| % Primer y �ltimo punto del primer componente de la imagen izquierda
| |
| [i_1,f_1] = calcular_limites(1,proyeccion_izq);
| |
| % Primer punto del segundo componente de la imagen izquierda
| |
| [i_2,f_2] = calcular_limites(f_1,proyeccion_izq);
| |
|
| |
|
| |
| % Calcular los limites de la imagen derecha (por columnas)
| |
| % Primer y �ltimo punto del primer componente de la imagen izquierda
| |
| [i_3,f_3] = calcular_limites(1,proyeccion_dcha);
| |
| % Primer punto del segundo componente de la imagen izquierda
| |
| [i_4,f_4] = calcular_limites(f_3,proyeccion_dcha);
| |
|
| |
| % Buscamos los componentes de mayor tama�o
| |
| [comp_izq, num_comp_izq] = bwlabel(izq);
| |
| [comp_dch, num_comp_dch] = bwlabel(dcha);
| |
|
| |
| % Los dos componentes de la imagen izquierda
| |
| [comp1izq, comp2izq] = obtener_componentes(comp_izq, num_comp_izq,tamanomin);
| |
| %figure(3);
| |
| %title('Objeto izquierdo 1');
| |
| %imshow(comp_izq == comp1izq);
| |
| %figure(4);
| |
| %title('Objeto izquierdo 2');
| |
| %imshow(comp_izq == comp2izq);
| |
|
| |
| % Los dos componentes de la imagen derecha
| |
| [comp1dcha, comp2dcha] = obtener_componentes(comp_dch, num_comp_dch, tamanomin);
| |
| %figure(5);
| |
| %title('Objeto derecho 1');
| |
| %imshow(comp_dch == comp1dcha);
| |
| %figure(6);
| |
| %title('Objeto derecho 2');
| |
| %imshow(comp_dch == comp2dcha);
| |
|
| |
| % Calcular los limites de la imagen izquierda (por filas)
| |
| % Componente 1
| |
| proy_filas_izq_1 = sum((comp_izq == comp1izq)');
| |
| %plot(proy_filas_izq_1);
| |
| [j_1, e_1] = calcular_limites(1, proy_filas_izq_1);
| |
| % Componente 2
| |
| proy_filas_izq_2 = sum((comp_izq == comp2izq)');
| |
| %plot(proy_filas_izq_2);
| |
| [j_2, e_2] = calcular_limites(1, proy_filas_izq_2);
| |
|
| |
| % Calcular los limites de la imagen derecha (por filas)
| |
| % Componente 1
| |
| proy_filas_dcha_1 = sum((comp_dch == comp1dcha)');
| |
| %plot(proy_filas_dcha_1);
| |
| [j_3, e_3] = calcular_limites(1, proy_filas_dcha_1);
| |
| % Componente 2
| |
| proy_filas_dcha_2 = sum((comp_dch == comp2dcha)');
| |
| %plot(proy_filas_dcha_2);
| |
| [j_4, e_4] = calcular_limites(1, proy_filas_dcha_2);
| |
|
| |
|
| |
| %Recortar las imagenes para obtener solo los objetos
| |
| obj1izq = izq(j_1:e_1,i_1:f_1);
| |
| %figure,imshow(obj1izq);
| |
|
| |
| obj2izq = izq(j_2:e_2,i_2:f_2);
| |
| %figure,imshow(obj2izq);
| |
|
| |
| obj1dch = dcha(j_3:e_3,i_3:f_3);
| |
| %figure,imshow(obj1dch);
| |
|
| |
| obj2dch = dcha(j_4:e_4,i_4:f_4);
| |
| %figure,imshow(obj2dch);
| |
|
| |
| so1i = size(obj1izq);
| |
| so1d = size(obj1dch);
| |
| minh = min([so1i(1),so1d(1)]);
| |
| mina = min([so1i(2),so1d(2)]);
| |
|
| |
| % Recortamos las dos objetos 1 con el tama�o del mas peque�o:
| |
| obj1izqr = obj1izq(1:minh,1:mina);
| |
| obj1dchr = obj1dch(1:minh,1:mina);
| |
| dif = sum(sum(abs(obj1izqr - obj1dchr)));
| |
| tot = sum(sum(obj1izqr));
| |
| r1 = (dif/tot)*100;
| |
| disp('El porcentaje de error en el objeto 1 es:');
| |
| disp(r1)
| |
|
| |
| so2i = size(obj2izq);
| |
| so2d = size(obj2dch);
| |
| minh = min([so2i(1),so2d(1)]);
| |
| mina = min([so2i(2),so2d(2)]);
| |
|
| |
| % Recortamos las dos objetos 2 con el tama�o del mas peque�o:
| |
| obj2izqr = obj2izq(1:minh,1:mina);
| |
| obj2dchr = obj2dch(1:minh,1:mina);
| |
| dif = sum(sum(abs(obj2izqr - obj2dchr)));
| |
| tot = sum(sum(obj2izqr));
| |
| r2 = (dif/tot) * 100;
| |
| disp('El porcentaje de error en el componente 1 es:')
| |
| disp(r2)
| |
|
| |
|
| |
|
| |
|
| |
| end
| |
|
| |
|
| |
| obtener_componentes.m
| |
|
| |
| function [comp1,comp2] = obtener_componentes(componentes, num_componentes, tamanomin)
| |
| cont = 0;
| |
| for i= 1: num_componentes
| |
| if sum(sum(componentes == i)) > tamanomin
| |
| if(cont == 0)
| |
| comp1 = i;
| |
| cont = cont + 1;
| |
| else
| |
| comp2 = i;
| |
| break;
| |
| end
| |
| end
| |
| end
| |
| end
| |
|
| |
|
| |
| calcular_limites.m
| |
|
| |
| %Funci�n que devuelve el punto inicial y final de la proyeccion de un
| |
| %componente de una imagen
| |
| function [i_1,i_2] = calcular_limites(pinicial,proyeccion)
| |
| for i_1=pinicial:1000
| |
| if proyeccion(i_1)> 5
| |
| break
| |
| end
| |
| end
| |
| for i_2=i_1:1000
| |
| if proyeccion(i_2)==0
| |
| break
| |
| end
| |
| end
| |
| end
| |
|
| |
| ********** kepa moreno ******
| |
|
| |
| function disparidad=calculo_disparidad_proyecciones(izq,dcha,umbral)
| |
|
| |
| % asumo que los objetos son oscuros y el fondo blanco
| |
| izq=izq<umbral;
| |
| dcha=dcha<umbral;
| |
|
| |
| %proyecciones por columnas
| |
| proyeccion_izq_col=sum(izq);
| |
| proyeccion_dcha_col=sum(dcha);
| |
|
| |
| %proyecciones por filas
| |
| proyeccion_izq_fil=sum(izq');
| |
| proyeccion_dcha_fil=sum(dcha');
| |
|
| |
| figure(1)
| |
| plot(proyeccion_izq_col)
| |
| figure(2)
| |
| plot(proyeccion_dcha_col)
| |
|
| |
| figure(3)
| |
| plot(proyeccion_izq_fil)
| |
| figure(4)
| |
| plot(proyeccion_dcha_fil)
| |
|
| |
|
| |
| %primer componente por filas en una imagen (no necesito mirar la otra imagen porque no hay desplazamiento de filas asÌ que
| |
| %en la otra estar· en la misma fila)
| |
|
| |
| for i_1a=1:1000
| |
| if proyeccion_izq_fil(i_1a)>0
| |
| break
| |
| end
| |
| end
| |
| for i_2a=i_1a:1000
| |
| if proyeccion_izq_fil(i_2a)==0
| |
| break
| |
| end
| |
| end
| |
|
| |
| %continuo mirando por filas apartir de donde termina el primer objeto hasta
| |
| %encontrar el final del segundo objeto
| |
| for j_a=i_2a:1000
| |
| if proyeccion_dcha_fil(j_a)==0
| |
| break
| |
| end
| |
| end
| |
|
| |
| %recorto la zona donde est·n mis objetos
| |
|
| |
| izq=izq(1:i_1a,:); %inicio de primer objeto
| |
| izq=izq((j_a-i_1a),:);%final del ultimo objeto teniendo en cuenta que ya hemos hecho un primer recorte a la imagen
| |
|
| |
| %mismo corte para la imagen derecha
| |
| dcha=dcha(1:i_1a,:);
| |
| dcha=dcha((j_a-i_1a),:);
| |
|
| |
| figure(5)
| |
| imshow(izq);
| |
| figure(6)
| |
| imshow(dcha);
| |
|
| |
|
|
| |
|
transparencias para el curso de vision [1]
algunos codigos matlab para vision por computador
function disparidades=calculo_disparidad_correlacion(izq,dcha)
bizq=izq<70;
bdcha=dcha<70;
figure(1)
proy=sum(bizq');
indices=find(proy>0);
arriba=indices(1);
indices=find(proy(arriba+1:size(izq,1))==0);
abajo=indices(1)+arriba;
subplot(2,1,1)
imshow(izq(arriba:abajo,:))
izq=izq(arriba-2:abajo,:);
bizq=bizq(arriba-2:abajo,:);
proy=sum(bdcha');
indices=find(proy>0);
arriba=indices(1);
indices=find(proy(arriba+1:size(dcha,1))==0);
abajo=indices(1)+arriba;
subplot(2,1,2)
imshow(dcha(arriba:abajo,:))
dcha=dcha(arriba-2:abajo,:);
bdcha=bdcha(arriba-2:abajo,:);
comp_izq=bwlabel(bizq);
s_izq=regionprops(comp_izq,'all');
comp_dcha=bwlabel(bdcha);
s_dcha=regionprops(comp_dcha,'all');
nobjetos=0;
for c=1:size(s_izq,1);
if s_izq(c).Area>1000
nobjetos=nobjetos+1;
correlacion=[];
x=floor(s_izq(c).BoundingBox)
abajo=x(2)+x(4);
if x(2)+x(4)> size(dcha,1)
abajo=size(dcha,1);
end
c_izq=izq(x(2):abajo,x(1):x(1)+x(3));
for i=1:x(1)-1
size(dcha)
c_dcha=dcha(x(2):abajo,x(1)-i:x(1)-i+x(3));
correlacion(i)=sum(sum(abs(c_izq-c_dcha)));
end
figure
plot(correlacion)
[minimo imin]=min(correlacion);
disparidades(nobjetos)=imin;
figure
subplot(1,2,1)
imshow(c_izq)
c_dcha=dcha(x(2):abajo,x(1)-imin:x(1)-imin+x(3));
subplot(1,2,2)
imshow(c_dcha)
end
end
function disparidad=calculo_disparidad_proyecciones(izq,dcha,umbral)
%asumo que los objetos son oscuros y el fondo blanco
izq=izq<umbral;
dcha=dcha<umbral;
proyeccion_izq=sum(izq);
proyeccion_dcha=sum(dcha);
figure(1)
plot(proyeccion_izq)
figure(2)
plot(proyeccion_dcha)
%primer componente
for i_1=1:1000
if proyeccion_izq(i_1)>0
break
end
end
for i_2=i_1:1000
if proyeccion_izq(i_2)==0
break
end
end
for j_1=1:1000
if proyeccion_dcha(j_1)>0
break
end
end
for j_2=j_1:1000
if proyeccion_dcha(j_2)==0
break
end
end
% calcular el centro de las proyecciones de los componentes
c_izq=sum((1:i_2).*proyeccion_izq(1:i_2)/sum(proyeccion_izq(1:i_2)));
c_dcha=sum((1:j_2).*proyeccion_dcha(1:j_2)/sum(proyeccion_dcha(1:j_2)));
disparidad(1)= c_izq-c_dcha;
%anulo primer componente
proyeccion_izq(1:i_2)=0;
proyeccion_dcha(1:j_2)=0;
% proceso segundo componente....
figure(3)
plot(proyeccion_izq)
figure(4)
plot(proyeccion_dcha)
%segundo componente
for i_1=1:1000
if proyeccion_izq(i_1)>0
break
end
end
for i_2=i_1:1000
if proyeccion_izq(i_2)==0
break
end
end
for j_1=1:1000
if proyeccion_dcha(j_1)>0
break
end
end
for j_2=j_1:1000
if proyeccion_dcha(j_2)==0
break
end
end
% calcular el centro de las proyecciones de los componentes
c_izq=sum((1:i_2).*proyeccion_izq(1:i_2)/sum(proyeccion_izq(1:i_2)));
c_dcha=sum((1:j_2).*proyeccion_dcha(1:j_2)/sum(proyeccion_dcha(1:j_2)));
disparidad(2)= c_izq-c_dcha;
function disparidad=calculo_disparidad_estereo_naive(izq,dcha)
%imagenes en niveles de grises
% umbral_izq=metodo_otsu(izq);
% umbral_dcha=metodo_otsu(dcha);
umbral_izq=60;
umbral_dcha=60;
izq=izq>umbral_izq;
dcha=dcha>umbral_dcha;
izq=1-izq;
dcha=1-dcha;
figure(1)
imshow(izq)
title('izquierda')
figure(2)
imshow(dcha)
title('derecha')
[comp_izq, num_comp_izq]=bwlabel(izq);
[comp_dcha, num_comp_dcha]=bwlabel(dcha);
for i_izq=1:num_comp_izq
if sum(sum(comp_izq==i_izq))>500
break
end
end
for i_dcha=1:num_comp_dcha
if sum(sum(comp_dcha==i_dcha))>500
break
end
end
figure(3)
imshow(comp_izq==i_izq)
title('objeto izquierda')
figure(4)
imshow(comp_dcha==i_dcha)
title('objeto derecha')
c_izq=calcula_centroide(comp_izq==i_izq);
c_dcha=calcula_centroide(comp_dcha==i_dcha);
disparidad=c_izq(2)-c_dcha(2);
function centroide=calcula_centroide(x)
% x imagen binaria
[n m]=size(x);
p_filas=sum(x')/sum(sum(x));
p_cols=sum(x)/sum(sum(x));
centro_filas=sum((1:n).*p_filas);
centro_cols=sum((1:m).*p_cols);
centroide=[centro_filas,centro_cols];
function umbral=metodo_otsu(x)
h=imhist(x,256);
size(h)
for T=2:255
v1=var(h(1:T).*(1:T)');
v2=var(h(T+1:256).*(T+1:256)');
P1=sum(h(1:T));
P2=sum(h(T+1:256));
vintra(T)=P1*v1+P2*v2;
end
plot(vintra)
vintra(1)=inf;
[minvarintra umbral]=min(vintra);
%descomposicion en planos de bits x es la imagen original
x=double(cara);
plano_8=floor(x/2^7);
x=rem(x,2^7);
plano_7=floor(x/2^6);
x=rem(x,2^6);
plano_6=floor(x/2^5);
x=rem(x,2^5);
plano_5=floor(x/2^4);
x=rem(x,2^4);
plano_4=floor(x/2^3);
x=rem(x,2^3);
plano_3=floor(x/2^2);
x=rem(x,2^2);
plano_2=floor(x/2^1);
x=rem(x,2^1);
plano_1=x;
figure(1)
subplot(2,4,1)
imshow(plano_8)
subplot(2,4,2)
imshow(plano_7)
subplot(2,4,3)
imshow(plano_6)
subplot(2,4,4)
imshow(plano_5)
subplot(2,4,5)
imshow(plano_4)
subplot(2,4,6)
imshow(plano_3)
subplot(2,4,7)
imshow(plano_2)
subplot(2,4,8)
imshow(plano_1)
% reconstruccion a partir de los planos de bits
reconstruccion=zeros(size(cara));
reconstruccion=plano_1;
reconstruccion=reconstruccion + plano_2*2^1;
reconstruccion=reconstruccion + plano_3*2^2;
reconstruccion=reconstruccion + plano_4*2^3;
reconstruccion=reconstruccion + plano_5*2^4;
reconstruccion=reconstruccion + plano_6*2^5;
reconstruccion=reconstruccion + plano_7*2^6;
reconstruccion=reconstruccion + plano_8*2^7;
figure (2)
imshow(reconstruccion, gray(256))
% reconstruccion con un watermark sencillo en el primer plano de bits
reconstruccion=zeros(size(cara));
reconstruccion(20:80,20:80)=fspecial('disk',30)>0;
reconstruccion=reconstruccion + plano_2*2^1;
reconstruccion=reconstruccion + plano_3*2^2;
reconstruccion=reconstruccion + plano_4*2^3;
reconstruccion=reconstruccion + plano_5*2^4;
reconstruccion=reconstruccion + plano_6*2^5;
reconstruccion=reconstruccion + plano_7*2^6;
reconstruccion=reconstruccion + plano_8*2^7;
figure (3)
imshow(reconstruccion, gray(256))
function modelo=construir_modelo(nimagen)
cd orlfaces
d=dir;
modelo=zeros(112,92,size(d,1)-2);
for i=3:size(d,1);
cd (d(i).name)
ds=dir;
modelo(:,:,i-2)=imread(ds(nimagen+2).name);
cd ..
end
cd ..
function modelo=construir_modelo_LOO
cd orlfaces
d=dir;
modelo=zeros(112,92,size(d,1)-2,10);
for i=3:size(d,1);
cd (d(i).name)
ds=dir;
for j=3:size(ds,1)
modelo(:,:,i-2,j-2)=imread(ds(j).name);
end
cd ..
end
cd ..
function [error_acumulado, matriz_confusion]=calcular_error_test(modelo,nimagen)
cd orlfaces
d=dir;
nclases=size(d,1)-2;
distancia=zeros(nclases,1);
matriz_confusion=zeros(nclases);
error_acumulado=0;
for i=3:size(d,1);
cd(d(i).name)
ds=dir;
for j=3:size(ds,1)
if j ~= nimagen + 2
y=double(imread(ds(j).name));
for k=1:size(d,1)-2
distancia(k)=sum(sum(abs(modelo(:,:,k)-y)));
end
%
[dmin, clase]=min(distancia);
matriz_confusion(i-2,clase)=matriz_confusion(i-2,clase)+1;
error= (i-2) ~=clase;
error_acumulado= error_acumulado + error;
end
end
cd ..
end
cd ..
function [aciertos, error_acum]=calculo_error_LOO(m)
m=double(m);
[filas,cols,nsujetos,nimagenes]=size(m)
error_acum=0;
aciertos=0;
for i=1:40
i
for j=1:10
test=squeeze(m(:,:,i,j));
distancias=zeros(nsujetos,nimagenes);
for k=1:nsujetos
for l=1:nimagenes
distancias(k,l)=norm(test-m(:,:,k,l));
end
end
distancias(distancias==0)=inf;
[mincols rowinds]=min(distancias);
[minglobal colind]=min(mincols);
clase=rowinds(colind);
if clase==i
aciertos=aciertos+1;
else
error_acum=error_acum+1;
end
end
end