Imágenes en Matlab. Cristian S. Rocha, Andrea Manna,... Taller 1

Transcripción

1 Imágenes en Matlab Cristian S. Rocha, Andrea Manna,... Taller 1 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 del octave no se puede mostrar imágenes. La razón se puede leer en el wiki: y se resuelve ejecutando el siguiente comando de la linea de comandos: pkg rebuild -noauto oct2mat que deshabilita el módulo oct2mat cada vez que se inicia el Octave. Aparentemente 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 guardada 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á indexado 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 : N 2+1 [0, 1] Cada tupla de naturales x, y : N 2 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 ma s comu n es descomponiendola en colores primarios rojo, verde y azul. La descomposicio 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 ma xima de ese canal. Por ejemplo en la representacio 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 segu n la descomposicio n elegida. Los canales ma s conocidos son Rojo, Verde y Azul (RGB), aunque existen otras combinaciones (ACM), (CMYK), (HSV), (YUV),... Una imagen con un u nico canal se lo conoce como imagen de escala de grises. La idea de Imagenes normalizadas surge porque existen muchas formas de almacenar esas ima genes en la computadora. Es comu 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 sate lites, o se quiera representar ima genes con mayor cantidad de colores. Pero ese es un tema del cual no vamos a hablar. Canales Imagen RGB sin descomponer Canal Rojo 2.2. Canal Verde Canal Azul Procesamiento ba sico de ima genes La forma ma s tradicional para trabajar con Ima genes es interpretando que son matrices de dimensiones. En Octavelas operaciones de lectura y escritura de ima genes son imread y imwrite. Para imread el nombre del archivo es suficiente para devolver una matriz 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 almacenar. Para ver la imagen se usa el comando imshow cuyo para metro de entrada es la matriz a mostrar como una imagen. Utilicen estos comandos y averigu en 2

3 la resolución (Cantidad de pixels en los ejes X e Y) que tiene la imagen usando el comando size Empezando a trabajar con imágenes en Octave y Matlab > A = imread( lena std.tif ); > imwrite(a, lena std.tif, tif ); > 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 información de la imagen. Empezando a trabajar con imágenes en Octave y Matlab > A = imread( lena std.tif ); > size(a) ans = > imshow(a(:,:,1)) > imfinfo( lena std.tif )... Para confirmar que la imagen no está normalizada obtener el máximo 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ón de la matriz. En este caso las imágenes no están normalizadas. Empezando a trabajar con imágenes 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ón. La función double convierte la matriz de números enteros a números reales y 255 normaliza los valores. Empezando a trabajar con imágenes en Octave y Matlab > A = imread( lena std.tif ); > N = double(a) / 255; > imshow(n) 2.3. s A partir de aquí se proponen los siguientes ejercicios. 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ón solo apagamos el canal Rojo. Solución > 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ón ndgrid que permite generar matrices a partir del índice. Se pide reconstruir una imagen a partir de canales generados a partir de las siguientes funciones. Solución 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π) > 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ón hist para conocer la distribución de la intensidad de los diferentes canales. Esto nos permite realizar otras operaciones a futuro. 5

6 Represente el histograma por cada canal. Rojo. Verde. Azul. Supongo que saben realizar estas operaciones. Las vieron en una clase anterior. Ahora la idea es jugar con partes de imágenes. 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á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. Creación de imágenes vacias Las imágenes 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ágenes. 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 = M t. Espejado horizontal H = M E Espejado vertical V = E M El problema principal de trabajar con estas operaciones es conseguir la matriz identidad del tamaño adecuada y asegurarse que la imagen es cuadrada. Recuerden 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 imagen que no es cuadrada y la copio a una imagen pre-creada cuadrada del tamaño 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 problema, se puede calcular con una doble iteración 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. s Ahora vamos a resolver algunos ejercicios de traslación y rotación. Primero vamos a encuadrar la imagen y centrar. Encuadrar y centrar la imagen san diego.tif en una nueva matriz. Solución > 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á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. Se pide realizar un espejado vertical y horizontal de lena. Solución > 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. 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 > 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. 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] = meshgrid(0:0.2:1,0:0.2:1) XX = YY =

11 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ón debe ir el valor de M(1, 2), entonces podemos fijarnos en las matrices resultantes de meshgrid, que en este caso está asociado a la coordenada XX(1), Y Y (1). Meshgrid > A = eyes(5); > [XX,YY] = meshgrid(0:1/(size(a,1)-1):1, > XX[1], YY[2], A(1,2) ans = 0 ans = ans = 0 0:1/(size(A,2)-1):1); En combinación con linspace se puede realizar varias tareas de interpolación lineal. la función 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ón de un vector por rango, excepto que linspace es más elegante. 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 reordenan los nuevos pixels. La función round pasa los valores reales a valores enteros 11

12 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 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