matlab

1. Im´agenes en Matlab
Cristian S. Rocha, Andrea Manna, . . .
Taller 1
1. Prefacio
Antes de empezar a trabajar con el Octavehay que asegurarse que la versi´on
en la que se trabaja no tiene ning´un bug perdido.
Sabemos que en la versi´on 3.2.4 del octave no se puede mostrar im´agenes.
La raz´on se puede leer en el wiki:
http://wiki.octave.org/wiki.pl?OctaveForWindows
y se resuelve ejecutando el siguiente comando de la linea de comandos:
pkg rebuild -noauto oct2mat
que deshabilita el m´odulo oct2mat cada vez que se inicia el Octave. Aparente-
mente este m´odulo es el que provoca el problema. Una vez deshabilitado se
reinicia el Octavey el comando imshow vuelve a funcionar.
2. Primera Parte
2.1. Introducci´on
Para trabajar computacionalmente con una imagen hay que interpretarla
como una funci´on matem´atica. Algunas caracter´ısticas de una imagen guarda-
da de una computadora es que tiene una cantidad finitas de puntos, es una
interpretaci´on de una imagen original que deber´ıa formarse por una cantidad
infinita (o mucha mas grande) de puntos. Cada punto de la imagen est´a index-
ado a trav´es de valores naturales x, y que referencian a las coordenadas x e y
del plano. A su vez cada punto puede contener m´as de un canal asociado a una
frecuencia o energ´ıa que son capaces de reflejar”.
Im´agenes
Definition 1 (Im´agen). Una Imagen normalizada es una funci´on
I : N2+1
→ [0, 1]
Cada tupla de naturales x, y : N2
se la conoce como pixel. Y cada valor I(x, y, c)
es la intensidad asociada al pixel (x, y) del canal c.
1

2. Existen varias formas de representar la luz reflejada por los puntos, pero la
m´as com´un es descomponiendola en colores primarios rojo, verde y azul. La
descomposici´on se asocia a canales (c) cuyos valores se encuentran en general
entre 0 y 1, indicando el 0 la falta total de ese canal y 1 la intensidad m´axima
de ese canal. Por ejemplo en la representaci´on RGB tener todos los canales en 1
representan el color blanco, y tener todos los canales en 0 representan el negro.
Esto puede variar seg´un la descomposici´on elegida.
Los canales m´as conocidos son Rojo, Verde y Azul (RGB), aunque existen
otras combinaciones (ACM), (CMYK), (HSV), (YUV), . . .
Una imagen con un ´unico canal se lo conoce como imagen de escala de grises.
La idea de Imagenes normalizadas surge porque existen muchas formas de
almacenar esas im´agenes en la computadora. Es com´un encontrar que los valores
sean entre 0 y 255 ya que se almacenan en la computadora con 8 bits o un byte.
Y en general 256 valores son suficientes. Otro es el caso que la imagen provenga
de sat´elites, o se quiera representar im´agenes con mayor cantidad de colores.
Pero ese es un tema del cual no vamos a hablar.
Canales
Imagen RGB sin descomponer
Canal Rojo Canal Verde Canal Azul
2.2. Procesamiento b´asico de im´agenes
La forma m´as tradicional para trabajar con Im´agenes es interpretando que
son matrices de 2 + 1 dimensiones.
En Octavelas operaciones de lectura y escritura de im´agenes son imread y
imwrite. Para imread el nombre del archivo es suficiente para devolver una ma-
triz de la cantidad de pixels y canales que almacena el archivo. Para almacenar
una matriz como una imagen hay que indicar en que formato se debe almace-
nar. Para ver la imagen se usa el comando imshow cuyo par´ametro de entrada
es la matriz a mostrar como una imagen. Utilicen estos comandos y averig¨uen
2

3. la resoluci´on (Cantidad de pixels en los ejes X e Y) que tiene la imagen usando
el comando size
Empezando a trabajar con im´agenes en Octave y Matlab
> A = imread(’lena std.tif’);
> imwrite(A, ’lena std.tif’, ’tif’);
> imshow(A);
Proponer que generen las im´agenes en escala de grises a partir de los canales
Rojos, Verdes y Azul de la imagen. Se pueden obtener pidiendo la submatriz
A(:, :, 1), A(:, :, 2), A(:, :, 3) respectivamente. Aqu´ı puede verse como la imagen
tiene una resoluci´on de 512x512 pixels y tres canales correspondientes a los
canales del RGB. Mostramos el canal rojo en escalas de grises con el comando
imshow. El comando imshow siempre toman al canal rojo, verde y azul como
esas submatrices. Tambi´en puede usarse la funci´on imfinfo para conocer la in-
formaci´on de la imagen.
Empezando a trabajar con im´agenes en Octave y Matlab
> A = imread(’lena std.tif’);
> size(A)
ans =
512 512 3
> imshow(A(:,:,1))
> imfinfo(’lena std.tif’)
...
Para confirmar que la imagen no est´a normalizada obtener el m´aximo y
m´ınimo valor de la matriz usando las funciones max y min. Notar que hay que
repetir las funciones porque se aplican sucesivamente en cada dimensi´on de la
matriz. En este caso las im´agenes no est´an normalizadas.
Empezando a trabajar con im´agenes en Octave y Matlab
> A = imread(’lena std.tif’);
> max(max(max(A)))
ans = 255
3

4. > min(min(min(A)))
ans = 3
Para normalizar la imagen se puede realizar la siguiente operaci´on. La fun-
ci´on double convierte la matriz de n´umeros enteros a n´umeros reales y 255
normaliza los valores.
Empezando a trabajar con im´agenes en Octave y Matlab
> A = imread(’lena std.tif’);
> N = double(A) / 255;
> imshow(N)
2.3. Ejercicios
A partir de aqu´ı se proponen los siguientes ejercicios.
Ejercicio
Represente la imagen de Lena apagando los diferentes canales. Esto pude
hacerse asignando 0 a cada canal.
Deje encendido solo el canal Rojo.
Deje encendido solo el canal Verde.
Deje encendido solo el canal Azul.
Deje encendido solo los canales Rojo y Verde.
Deje encendido solo los canales Verde y Azul.
Deje encendido solo los canales Rojo y Azul.
Para ello recomiendo copiar la imagen a una matriz temporal e ir apagando
los canales de a poco. A continuaci´on solo apagamos el canal Rojo.
Soluci´on
> A = imread(’lena std.tif’);
> T = A
> T(:,:,2) = 0
4

5. > T(:,:,3) = 0
> imshow(T)
El siguiente ejercicio ayuda a reconstruir una imagen a partir de canales
calculados en forma independiente. Se introduce la funci´on ndgrid que permite
generar matrices a partir del ´ındice.
Ejercicio
Se pide reconstruir una imagen a partir de canales generados a partir de las
siguientes funciones.
r(x, y) = sin(x) + sin(y)
g(x, y) = sin(x + ,25π) + sin(y + ,25π)
b(x, y) = sin(x + ,5π) + sin(y + ,5π)
Soluci´on
> X = ndgrid(0:0.1:2*pi,0:0.1:2*pi);
> Y = X’;
> R = 0.5+sin(X)+sin(Y);
> G = 0.5+sin(X+0.25*pi)+sin(Y+0.25*pi);
> B = 0.5+sin(X+0.5*pi)+sin(Y+0.5*pi);
> I = zeros(size(R,1), size(R,2), 3);
> I(:,:,1)=R;
> I(:,:,2)=G;
> I(:,:,2)=B;
> imshow(I)
El siguiente ejercicio introduce el uso de la funci´on hist para conocer la
distribuci´on de la intensidad de los diferentes canales. Esto nos permite realizar
otras operaciones a futuro.
5

6. Ejercicio
Represente el histograma por cada canal.
Rojo.
Verde.
Azul.
Supongo que saben realizar estas operaciones. Las vieron en una clase ante-
rior.
Ahora la idea es jugar con partes de im´agenes.
Ejercicio
Se pide intercambiar el cuarto superior izquierdo de la imagen con el cuarto
inferior derecho.
Resultado
> L = imread(’lena std.tif’);
> Qsi = L(1:256,1:256,:);
> Qid = L(257:512,257:512,:);
> L(257:512,257:512,:)=Qsi;
> L(1:256,1:256,:)=Qid;
> imshow(L)
6

7. 3. Segunda Parte
3.1. Operaciones de matrices y resultados en im´agenes
Antes de cualquier cosa debemos poder crear im´agenes vac´ıas para poder
almacenar resultados en ellas. Ahora hay que hablar de c´omo crear matrices que
sean compatibles con las im´agenes, porque sino no se va a poder almacenarlas
ni verlas.
Creaci´on de im´agenes vacias
Las im´agenes se crean como cualquier matriz, pero hay que indicar que el
tipo de dato a usar es de tipo byte.
> zeros( [10,10,3], ’uint8’)
Algunas operaciones sobre matrices tienen efectos interesantes en las im´agenes.
Ahora enumeraremos algunas de estas operaciones.
Operaciones
Siendo M la matriz de la imagen, I la matriz identidad y E es la matriz
identidad espejada.
Espejado diagonal D = Mt
.
Espejado horizontal H = M · E
Espejado vertical V = E · M
El problema principal de trabajar con estas operaciones es conseguir la ma-
triz identidad del tama˜no adecuada y asegurarse que la imagen es cuadrada. Re-
cuerden que la multiplicaci´on de matrices require equivalencia entre el tama˜no
de las matrices. Se pueden multiplicar una imagen M de n × m por una matriz
I de m × p, y el resultado ser´a una matriz de n × p. Es por eso que recomiendo
usar matrices cuadradas. Para eso es necesario generar una matriz m´as grande
donde almacenar la imagen si es que esta no es cuadrada.
A continuaci´on muestro c´omo encuadrar la imagen. Cargo primero una ima-
gen que no es cuadrada y la copio a una imagen pre-creada cuadrada del tama˜no
adecuado.
Encuadrar una Imagen
> S = imread(’san diego.tif’);
> c = size(S,3);
> n = max(size(S)(1:2));
> D = zeros([n,n,3],’uint8’);
7

8. > D(1:size(S,1),1:size(S,2),:) = S;
En el caso que no se quiera utilizar operaciones con matrices porque tardan
mucho tiempo en resolverse o porque una matriz no puede resolver el proble-
ma, se puede calcular con una doble iteraci´on sobre el las filas y las columnas
respectivamente.
Aqu´ı por ejemplo mostramos como calcular cual es el valor promedio que
hay en los pixels de la imagen en el canal 1.
Modificar una imagen
> I = imread(’san diego.tif’);
> s =0;
> for i in 1:size(I,1)
> for j in 1:size(I,2)
> s = s + double(I(i,j,1));
> end
> end
> s/(size(I,1)*size(I,2))
3.2. Ejercicios
Ahora vamos a resolver algunos ejercicios de traslaci´on y rotaci´on.
Primero vamos a encuadrar la imagen y centrar.
Ejercicio
Encuadrar y centrar la imagen san diego.tif en una nueva matriz.
Soluci´on
> I = imread(’san diego.tif’);
> n = max(size(I)(1:2));
> D = zeros([n, n, size(I,3)], ’uint8’);
> top = (n - size(I,1)) / 2 + 1;
8

9. > left = (n - size(I,2)) / 2 + 1;
> D(top:top+size(I,1)-1, left:left+size(I,2)-1, :) = I;
> imshow(D);
Ahora vamos a rotar las im´agenes. Una funci´on importante para rotar es
fliplr que realiza un espejo vertical. Aunque esta funci´on puede resolver todo el
problema, lo interesante es usarla para conseguir la matriz identidad espejada
y luego aplicarla para rotar en horizontal y vertical.
Otro tema al que hay que prestar atenci´on es que no se pueden multiplicar
matrices de tipo ’uint8’. Lo que si se puede hacer es convertirlas en matrices de
tipo ’double’, multiplicar y luego volver a ’uint8’.
Ejercicio
Se pide realizar un espejado vertical y horizontal de lena.
Soluci´on
> I = imread(’lena std.tif’);
> E = eye(size(I)(1:2));
> E = fliplr(E);
> D = uint8(double(I(:,:,1))*double(E));
> showim(D);
> D = uint8(double(E)*double(I(:,:,1)));
> showim(D);
Ahora vamos a rotar la imagen 90 grados.
Ejercicio
Rotar 90 grados la imagen de lena.
Para la soluci´on podemos realizar un espejado diagonal para luego realizar
una espejado horizontal. O al rev´es. . .
Soluci´on
> I = imread(’lena std.tif’);
> E = eye(size(I)(1:2));
9

10. > E = fliplr(E);
> D = uint8(double(I(:,:,1))*double(E));
> D = uint8(double(D)’);
> showim(D);
Este es un ejercicio dif´ıcil de resolver, pero es un ejercicio bien completo.
Ejercicio
Se busca una funci´on que permita re-escalar una imagen.
Ayuda: Usar las funciones meshgrid y linspace para “rehubicar los pixels”
La funci´on meshgrid genera las coordenadas de una grilla de N dimensiones
asociada a una matriz.
Aqu´ı se presenta un ejemplo de lo que meshgrid devuelve
Meshgrid
> [XX,YY] = meshgrid(0:0.2:1,0:0.2:1)
XX =
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
0.00000 0.20000 0.40000 0.60000 0.80000 1.00000
YY =
0.00000 0.00000 0.00000 0.00000 0.00000 0.00000
0.20000 0.20000 0.20000 0.20000 0.20000 0.20000
0.40000 0.40000 0.40000 0.40000 0.40000 0.40000
0.60000 0.60000 0.60000 0.60000 0.60000 0.60000
0.80000 0.80000 0.80000 0.80000 0.80000 0.80000
10

11. 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000
Por ejemplo, tenemos una matriz M de 5x5 que representa valores en un
espacio bidimensional de 0 a 1. Entonces si queremos conocer en que posici´on
debe ir el valor de M(1, 2) , entonces podemos fijarnos en las matrices resultantes
de meshgrid, que en este caso est´a asociado a la coordenada XX(1), Y Y (1).
Meshgrid
> A = eyes(5);
> [XX,YY] = meshgrid(0:1/(size(A,1)-1):1,
0:1/(size(A,2)-1):1);
> XX[1], YY[2], A(1,2)
ans = 0
ans = 0.20000
ans = 0
En combinaci´on con linspace se puede realizar varias tareas de interpolaci´on
lineal.
la funci´on linspace(a,b,n) permite generar n valores intermedios entre dos
valores a y b en forma lineal. Muy parecido a lo que realizamos previamente con
la generaci´on de un vector por rango, excepto que linspace es m´as elegante.
Linspace
> linspace(0, 1, 5)
ans =
0.00000 0.25000 0.50000 0.75000 1.00000
> 0:1/(5-1):1
ans =
0.00000 0.25000 0.50000 0.75000 1.00000
Ahora esta interpolaci´on puede usarse para conocer que pixel debe asociarse
a la matriz resultante. La funci´on meshgrid me permite conocer como se reorde-
nan los nuevos pixels. La funci´on round pasa los valores reales a valores enteros
11

12. que representan donde est´an los pixels originales correspondiente a ese punto de
la matriz.
Entonces la soluci´on a este problema es el siguiente:
Soluci´on
function [ ret ] = imagezoom (I, factor)
[ width, height, c ] = size(I);
new width = width * factor;
new height = height * factor;
ret = zeros([new width, new height, c], ’uint8’);
[XX, YY] = meshgrid(linspace(1,width,new width),
linspace(1,height,new height));
XX = round(XX);
YY = round(YY);
for i = 1:new width
for j = 1:new height
ret(i,j,:) = I(XX(j,i),YY(j,i),:);
end
end
endfunction
12