BELLO

UNIVERSIDAD ANDRES
DEPARTAMENTO DE CIENCIAS FISICAS

Curso: Procesamiento Digital de Imagenes

Alumno: Eduardo Jeraldo
Fecha de entrega 22 de Agosto 2013

Tarea 1

1.

Preguntas

1. Se tiene la siguiente imagen (Santiago 01.jpg)

Figura 1: Santiago 01.jpg

a) Separar los tres canales RGB, encontrar los histogramas de cada canal R, G y B.
Comente resultados. Si quisieramos solo segmentar las monta
nas que habra que
hacer mirando solo el grafico de histograma.
b) Graficar el perfil del pixel (para cada canal) para las filas indicadas (aproximadamente) en la figura anterior. Comente que habra que hacer para poder segmentar
solo el cerro mirando solo el perfil de pixeles.
c) Convierta la imagen en colores en una imagen gris.
2. Usando la imagen anterior (imagen gris obtenida anteriormmiente) segmentar:
a) 128 niveles de gris.
b) 64 niveles de gris.
c) 2 valores (binarizar ).
1

3. Usando los 255 valores de gris (imagen gris original ) se pide:

a) Reducir la dimension de imagen a la mitad, sin perder informacion visual es decir
de tal forma que se puedan aun distinguir los elementos mas importantes de la
imagen.
b) Reducir en forma inteligente por ejemplo cada cuatro pixeles encontrar la media
y reemplazar por esa media.
c) Comparar resultados y comentar.
4. Se tiene la siguiente imagen (Santiago 02.jpg)

Figura 2: Santiago 02.jpg

Se quiere publicar en un periodico de poco presupuesto, para cada canal haga un

proceso de halftoning o dithering (elegido por usted ) y luego obtenga una imagen en
colores indicando que proceso realizo. Comente resultados.

2.

Soluci
on

1. Haciendo un analisis con otro programa (GIMP), pude encontrar la ubicacion de la

lineas rojas. Primera linea 90 o 91 pixel, segunda linea 556 o 557 pixel y tercera linea
851 o 852 pixel. Esta informacion la usaremos mas adelante.
a) Primero separamos la imagen por canal.

Figura 3: img r.png

Figura 4: img g.png

Para realizar la separacion por capas

recordamos que Matlab reconoce una imagen
como una matriz de f filas, c columnas y
l capas, entonces cargamos la imagen y la
separamos asignandoles valores especificos a
la capa l (1,2,3 = R,G,B) y creamos cada
imagen en escala de grises.

Figura 5: img b.png

Luego usando imhist podemos ver el histograma para cada imagen en su respectivo filtro (R,G o B).

Figura 6: histimg r.png

Figura 7: histimg g.png

Los histogramas suguieren que la imagen

tiene bastante pixeles oscuros, ya que la
mayoria de los pixeles se agolpan en los
valores de pixeles mas bajos, eso implica que
la imagen en si es un poco oscura.

Figura 8: histimg b.png

Luego si quisieramos segmentar las monta

nas mirando solo los historiales de los
filtros, tenemos que notar que las monta
nas estan ubicadas en la parte que tiene
los pixeles mas claros, entonces tenemos que crear un filtro que solo deje pasar
los valores altos, pero no los mas altos ya que estaria tomando tb el cielo y todas
las nubes, nuestro fitro estara entonces entre 200 y 250.
for i =1: f { for j =1: c { for k=1: l
i f img ( i , j , k)>200 && img ( i , j , k ) < 250
mon( i , j , k ) = img ( i , j , k ) ;
end
end } end } end

Finalmente la imagen quedara como:

Figura 9: mon.png

b) Ahora usamos la informacion que encontramos haciendo uso del programa GIMP
y graficamos los perfiles de pixel para cada linea.

Figura 10: perfcord.png

Figura 11: perfcerr.png

Nuevamente los perfiles suguieren que en la

parte de monta`
nas los pixeles son mas claros,
eso avala el uso de lo encontrado por los
histogramas.

Figura 12: perfciud.png

c) Para convertir la imagen en una imagen de grises tenemos 2 opciones claras, la

primera seria usar los comandos de Matlab (rgb2gray) o usar la formula mostrada
en clases gray = 0,299 R + 0,587 G + 0,114 B, usando el metodo mostrado
en clases obtenemos:

Figura 13: img gris.png

2. Para segmentar los niveles de color (de gris en este caso), podemos dividir la imagen
por valores especificos para que el valor final maximo corresponda al valor de segmentacion deseado.
a) Para 128 niveles de gris dividimos la imagen en 2, debido a que 256/2 = 128, pero
esto nos deja como valor maximo de pixel el 128 y el valor maximos debe ser 127,
matlab aproxima hacia arriba y necesitamos que aproxime hacia abajo, por eso
usamos:
img_gris128=uint8(double(img_gris / 2)-1.5);
Al convertir los valores de la matriz en Double nos aseguramos que matlab conservara los decimales, luego restamos 1.5 a cada pixel y asi aseguramos que al
convertir en uint8 aproximara hacia arriba y los valores maximos seran de 127.
Finalmente la imagen en 128 niveles de gris es:

Figura 14: img gris128.png

Figura 15: img gris64.png

b) Hacemos lo mismo para la obtener la imagen anterior de 64 niveles de gris, solo

que ahora dividimos por 4.
img_gris64=uint8(double(img_gris / 4)-1.5);
c) Para la imagen de 2 colores o imagen binaria, debemos escoger el valor al cual
vamos a separar los colores, hacemos un estudio del historial de la imagen para
encontrar la moda de los pixeles y en base a este valor binarizamos de la siguiente
manera:
[ y ( : , 1 ) , y ( : , 2 ) ] = i m h i s t ( i m g g r i s ) ; m=max( y ( : , 2 ) ) ; n=max( y ( : , 1 ) ) ;
for i =1:m
i f y ( i , 1 ) == n ;
med=y ( i , 2 ) ;
end
end
7

Luego binarizamos para obtener:

Figura 16: img gris2.png

3. Ahora usamos la imagen de 255 valores de gris para redimensionarla.

a) Usando el comando de Matlab (imresize) podemos especificar cuando queremos
redimensionar la imagen, en este caso a la mitad.
b) Para redimensionar de forma inteligente como se se
nala en el enunciado, desarrollamos la siguiente linea de codigo:
I =1; J =1;
for i = 1 : 2 : f 2
for j = 1 : 2 : c2
i m g r e z 2 ( I , J)= u i n t 8 (mean ( [ double ( i m g g r i s ( i , j ) ) ; . . .
double ( i m g g r i s ( i +1, j ) ) ; double ( i m g g r i s ( i , j + 1 ) ) ; . . .
double ( i m g g r i s ( i +1, j + 1 ) ) ] ) ) ;
J=j / 2 + 0 . 5 ;
end
I=i / 2 + 0 . 5 ;
end
8

c) Finalmente las imagenes redimensionadas son la siguientes:

Figura 17: img rez1.png

Figura 18: img rez2.png

El problema que se puede observar con el metodo inteligente es que nos agrega una
linea negra en algunos bordes, pero fuera de eso las imagenes son casi parecidas,
de hecho la siguiente imagen muestra la diferencia entre la imagenes.

Figura 19: dif rez.png

4. Ahora debemos escoger entre un halftoning o un dithering para la imagen (Santiago 02.jpg). Como no encontre una forma que me dejara satisfecho c/r a la calidad de
la imagen final, o que hiciera el dithering o halfotoning para imagen en RGB no llegue
a una conclusion para esta parte, pero adjunto una de las rutinas que me genera un
dithering para imagen RGB.
function D = F l o y d S t e i n b e r g D i t h e r i n g (G)
s w i t c h s i z e (G, 3 )
case 1
G = double (G) ; % c o n v e r t t h e o r i g i n a l image from u n i t 8 t o d o u b l e
D = zeros ( s i z e (G) ) ; % i n i t i a l i z e d i t h e r e d image D
[M,N] = s i z e (G) ; % e x t r a c t s i z e i n f o r m a t i o n o f t h e o r i g i n a l image
for r = 1 :M
i f mod( r , 2 ) == 0 % scan p i x e l from l e f t t o r i g h t
cOrder = 1 :N;
direction = l2r ;
e l s e % scan p i x e l from r i g h t t o l e f t
cOrder = N: 1 : 1 ;
direction = r2l ;
end
for c = cOrder
tP = G( r , c ) ; % c u r r e n t p i x e l i n t e n s i t y
% p i c k n e a r e s t i n t e n s i t y s c a l e two o p t i o n s 0 or 255
i f tP>=128 % c l o s e t o 255
D( r , c ) = 2 5 5 ; % p i c k 255
else % c l o s e to 0
D( r , c ) = 0 ; % p i c k 0
end
eP = tPD( r , c ) ; % d i f f e r e n c e b e f o r e and a f t e r s e l e c t i o n
% d i f f u s e d i f f e r e n c e eP t o n e i g h b o r p i x e l s
i f r=M % d e a l w i t h none bottom rows
switch d i r e c t i o n
case l2r
i f c == 1 % l e f t most p i x e l c a s e
G( r , c +1) = G( r , c+1)+eP 7 / 1 3 ;
G( r +1, c ) = G( r +1, c)+eP 5 / 1 3 ;
G( r +1, c +1) = G( r +1, c+1)+eP 1 / 1 3 ;
e l s e i f c == N
G( r +1, c ) = G( r +1, c)+eP 5 / 8 ;
G( r +1,c 1) = G( r +1,c1)+eP 3 / 8 ;
e l s e % t h e normal c a s e
G( r , c +1) = G( r , c+1)+eP 7 / 1 6 ;
G( r +1, c ) = G( r +1, c)+eP 5 / 1 6 ;
G( r +1, c +1) = G( r +1, c+1)+eP 1 / 1 6 ;
G( r +1,c 1) = G( r +1,c1)+eP 3 / 1 6 ;
10

end
case r2l
i f c == N % r i g h t most p i x e l c a s e
G( r , c 1) = G( r , c1)+eP / 2 ;
G( r +1, c ) = G( r +1, c)+eP 3 / 8 ;
G( r +1,c 1) = G( r +1,c1)+eP 1 / 8 ;
e l s e i f c == 1 % l e f t most p i x e l c a s e
G( r +1, c ) = G( r +1, c)+eP 5 / 8 ;
G( r +1, c +1) = G( r +1, c+1)+eP 3 / 8 ;
e l s e % normal c a s e
G( r , c 1) = G( r , c1)+eP 7 / 1 6 ;
G( r +1, c ) = G( r +1, c)+eP 5 / 1 6 ;
G( r +1,c 1) = G( r +1,c1)+eP 1 / 1 6 ;
G( r +1, c +1) = G( r +1, c+1)+eP 3 / 1 6 ;
end
end
e l s e % d e a l w i t h t h e bottom row
switch d i r e c t i o n
case l2r
i f c =N % normal c a s e
G( r , c +1) = G( r , c+1)+eP ;
end
case r2l
i f c = 1 % normal c a s e
G( r , c 1) = G( r , c1)+eP ;
end
end
end
end
end
otherwise
for i = 1 : s i z e (G, 3 )
tD = F l o y d S t e i n b e r g D i t h e r i n g (G( : , : , i ) ) ;
D ( : , : , i ) = tD ;
end
end
D = u i n t 8 (D) ; % c o n v e r t d o u b l e D t o u i n t 8

11