MAV. Python.

Pilow

Imagen a partir de una matriz

Cuando creamos por primera vez una imagen mediante Pilow lo primero que pensé fue que poco interés tenía la cosa; cuando sobre esa base unimos dos imágenes para componer una tercera, ya me pareció más interesante y a la vista del interés que tiene para la descomposición de la imagen en colores parece que el tema va ganando en interés. Añado ahora una razón más para valorar positivamente la creación de imágenes en Pilow.

Me refiero a la construcción de una imagen (sencilla, eso sí) no mediante la función ya conocida (img_base = Image.new("L",(d_x,d_y),"white")), sino mediante una nueva función que ilustra la relación entre Pilow y NumPy: la función  fromarray(array_base). Pero no adelantemos acontecimientos.

from PIL import Image

import numpy as np

#Crear array  de base

array_base = np.zeros([550,750,3], dtype = np.uint8)

#Agregar colores

array_base[:,0:300] = [255,128,0]

array_base[:,300:] = [0,0,255]

#Crear la imagen a partir del arreglo

img_array = Image.fromarray(array_base)

#Mostrar la imagen creada

img_array.show()

Mediante este script he creado una sencilla imagen a partir de datos numéricos organizados en una matriz tridimensional (array_base = np.zeros([550,750,3], dtype = np.uint8)) mediante la función np.zeros(), que recibe como primer parámetro una tupla con tres valores: ancho, alto y 3 canales de color como tercer dimensión.

Los dos primeros, además de definir el tamaño de la matriz, también nos sirven como referencias necesarias para concretar las posiciones de las diferentes configuraciones de color que compondrán la imagen final...

vg. array_base[:,0:300] = [255,128,0]

... atribuye al primer elemento la posición 0-0 a 0:300 (ejes x-y) y como color asignado la tupla [R.G.B] [255,128,0].

Posteriormente se construye la imagen a partir de esos datos mediante el método fromarray() que recibe como parámetro la variable imagen (img_array = Image.fromarray(array_base)).

Si en lugar de una imagen RGB quisiéramos crear una imagen en escala de grises deberíamos usar un script como el siguiente:

from PIL import Image

import numpy as np

#Crear array  de base

array_base = np.zeros([550,750], dtype = np.uint8)

#Agregar grises

array_base[:,0:300] = [50]

array_base[:,300:] = [235]

#Crear la imagen a partir del arreglo

img_array = Image.fromarray(array_base)

#Mostrar la imagen

img_array.show()

Puedes apreciar el cambio en la construcción del array (ahora array_base = np.zeros([550,750], dtype = np.uint8)) y en el procedimiento para agregar el color (vg array_base[:,0:300] = [50]). El resto es igual.

MAV. Python.

Pillow

Filtros a partir de la separación de colores

Hablando de filtros, toda imagen se puede entender como una mas o menos compleja combinación de los tres colores básicos (rojo-verde-azul), cuando de una imagen en color se trata, y de la menor o mayor intensidad de la presencia de cada uno de ellos, siendo su valor mínimo 0 y máximo 255. El blanco resulta de la máxima intensidad de los tres (255,255,255) y el negro de la mínima (0,0,0). A partir de aquí, podemos trabajar con una imagen como con una matriz de datos numéricos, lo que abre interesantes posibilidades de trabajo. La primera de ellas generar filtros basados en la manipulación de las intensidades de los colores básicos de la imagen.

La consecuencia de lo anterior, lo que realmente nos interesa, es el trabajo con la imagen como matriz de datos, siendo la cuestión de su uso como filtro más bien secundaria. Se trata, en realidad, de estudiar la interesante combinación del trabajo con Pillow y con NumPy, como recurso para facilitar el manejo de imágenes mediante código. Ahora nos centraremos en uno de los procedimientos básicos y seguiremos trabajando en esta dirección en las entradas que siguen.

Dicho esto empezaremos por importar las dos bibliotecas

from PIL import Image

import numpy as np

... y cargando una imagen con la que trabajar

img_dir = 'img/formas.jpg'

img = Image.open(img_dir)

Obtenemos sus dimensiones (ancho y alto)...

d_x, d_y = img.size

... para poder crear otra imagen de esas mismas dimensiones, la cual nos servirá de base para generar los filtros de color (observa que creamos la imagen de tipo escala de grises ("L") y le damos un fondo, en este caso blanco ("white")

img_base = Image.new("L",(d_x,d_y),"white")

Lo más interesante del procedimiento es la obtención de los datos de los tres canales de color de la imagen y su conversión en una matriz mediante el método splitz(), así de sencillo:

col_R, col_G , col_B = img.split()

A partir de aquí, podremos aplicar el filtro de color (R, G, B) sobre la imagen original combinándola con la imagen de base que creamos en blanco (también podría ser en negro), siendo suficiente con introducir el canal de color deseado y mantener el original de la imagen de base ocupando el lugar de los otros dos, v.g. para el rojo...

img_R = Image.merge('RGB',(col_R, img_base, img_base))

Si utilizamos los tres canales, el resultado es la imagen original

img_R = Image.merge('RGB',(col_R,col_G,col_B))