Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Imagenes
Imagenes
1. Prefacio
Antes de empezar a trabajar con el Octavehay que asegurarse que la versión
en la que se trabaja no tiene ningún bug perdido.
Sabemos que en la versión 3.2.4 del octave no se puede mostrar imágenes.
La razón 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:
que deshabilita el módulo oct2mat cada vez que se inicia el Octave. Aparente-
mente este módulo 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ón
Para trabajar computacionalmente con una imagen hay que interpretarla
como una función matemática. Algunas caracterı́sticas de una imagen guarda-
da de una computadora es que tiene una cantidad finitas de puntos, es una
interpretación de una imagen original que deberı́a formarse por una cantidad
infinita (o mucha mas grande) de puntos. Cada punto de la imagen está index-
ado a través de valores naturales x, y que referencian a las coordenadas x e y
del plano. A su vez cada punto puede contener más de un canal asociado a una
frecuencia o energı́a que son capaces de reflejar”.
Imágenes
Definition 1 (Imágen). Una Imagen normalizada es una función
I : N2+1 → [0, 1]
1
Existen varias formas de representar la luz reflejada por los puntos, pero la
más común es descomponiendola en colores primarios rojo, verde y azul. La
descomposición 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áxima
de ese canal. Por ejemplo en la representación 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ún la descomposición elegida.
Los canales más conocidos son Rojo, Verde y Azul (RGB), aunque existen
otras combinaciones (ACM), (CMYK), (HSV), (YUV), . . .
Una imagen con un único canal se lo conoce como imagen de escala de grises.
La idea de Imagenes normalizadas surge porque existen muchas formas de
almacenar esas imágenes en la computadora. Es común 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élites, o se quiera representar imágenes con mayor cantidad de colores.
Pero ese es un tema del cual no vamos a hablar.
Canales
2
la resolución (Cantidad de pixels en los ejes X e Y) que tiene la imagen usando
el comando size
> imshow(A);
Proponer que generen las imágenes 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ón 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én puede usarse la función imfinfo para conocer la in-
formación de la imagen.
> size(A)
ans =
512 512 3
> imshow(A(:,:,1))
> max(max(max(A)))
ans = 255
3
> min(min(min(A)))
ans = 3
> 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.
Solución
> T = A
> T(:,:,2) = 0
4
> T(:,:,3) = 0
> imshow(T)
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ón
> 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(:,:,1)=R;
> I(:,:,2)=G;
> I(:,:,2)=B;
> imshow(I)
5
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ágenes.
Ejercicio
Se pide intercambiar el cuarto superior izquierdo de la imagen con el cuarto
inferior derecho.
Resultado
> L(257:512,257:512,:)=Qsi;
> L(1:256,1:256,:)=Qid;
> imshow(L)
6
3. Segunda Parte
3.1. Operaciones de matrices y resultados en imágenes
Antes de cualquier cosa debemos poder crear imágenes vacı́as para poder
almacenar resultados en ellas. Ahora hay que hablar de cómo crear matrices que
sean compatibles con las imágenes, porque sino no se va a poder almacenarlas
ni verlas.
Operaciones
Siendo M la matriz de la imagen, I la matriz identidad y E es la matriz
identidad espejada.
Espejado diagonal D = M t .
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ño adecuada y asegurarse que la imagen es cuadrada. Re-
cuerden que la multiplicación de matrices require equivalencia entre el tamaño
de las matrices. Se pueden multiplicar una imagen M de n × m por una matriz
I de m × p, y el resultado será una matriz de n × p. Es por eso que recomiendo
usar matrices cuadradas. Para eso es necesario generar una matriz más grande
donde almacenar la imagen si es que esta no es cuadrada.
A continuación muestro cómo encuadrar la imagen. Cargo primero una ima-
gen que no es cuadrada y la copio a una imagen pre-creada cuadrada del tamaño
adecuado.
> c = size(S,3);
> n = max(size(S)(1:2));
> D = zeros([n,n,3],’uint8’);
7
> D(1:size(S,1),1:size(S,2),:) = S;
> s =0;
> 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ón y rotación.
Primero vamos a encuadrar la imagen y centrar.
Ejercicio
Encuadrar y centrar la imagen san diego.tif en una nueva matriz.
Solución
> n = max(size(I)(1:2));
8
> left = (n - size(I,2)) / 2 + 1;
> imshow(D);
Ahora vamos a rotar las imágenes. Una función importante para rotar es
fliplr que realiza un espejo vertical. Aunque esta función 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ón 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ón
> 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);
Ejercicio
Rotar 90 grados la imagen de lena.
Para la solución podemos realizar un espejado diagonal para luego realizar
una espejado horizontal. O al revés. . .
Solución
> E = eye(size(I)(1:2));
9
> E = fliplr(E);
> D = uint8(double(I(:,:,1))*double(E));
> D = uint8(double(D)’);
> showim(D);
Ejercicio
Se busca una función que permita re-escalar una imagen.
Ayuda: Usar las funciones meshgrid y linspace para “rehubicar los pixels”
La función 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 =
10
1.00000 1.00000 1.00000 1.00000 1.00000 1.00000
Meshgrid
> A = eyes(5);
0:1/(size(A,2)-1):1);
ans = 0
ans = 0.20000
ans = 0
Linspace
> linspace(0, 1, 5)
ans =
> 0:1/(5-1):1
ans =
Ahora esta interpolación puede usarse para conocer que pixel debe asociarse
a la matriz resultante. La función meshgrid me permite conocer como se reorde-
nan los nuevos pixels. La función round pasa los valores reales a valores enteros
11
que representan donde están los pixels originales correspondiente a ese punto de
la matriz.
Entonces la solución a este problema es el siguiente:
Solución
linspace(1,height,new height));
XX = round(XX);
YY = round(YY);
ret(i,j,:) = I(XX(j,i),YY(j,i),:);
end
end
endfunction
12