Procesamiento de imágenes con SciPy y NumPy en Python

En este tutorial, analizaremos el procesamiento de imágenes en Python utilizando los módulos científicos principales, como NumPy y SciPy. Las imágenes se componen de ndarrays NumPy para que podamos procesar y manipular imágenes y SciPy proporciona el submódulo scipy.ndimage que proporciona funciones que pueden operar en los arreglos NumPy.

 Discutiremos cómo abrir y escribir imágenes, y también cubriremos diferentes técnicas de manipulación y filtrado. Entonces, antes de comenzar, veamos cómo instalar ambos módulos.

Instalación

Numpy: para instalar numpy, escriba el siguiente comando en la terminal.

pip install numpy

SciPy: también puede usar el comando anterior para instalar SciPy.

pip install scipy

Abrir y escribir imágenes

El paquete misceláneo de SciPy viene con algunas imágenes precargadas. Usaremos esas imágenes para aprender sobre el procesamiento de imágenes. Una de esas imágenes es proporcionada por la función face(). La función face() obtendrá una imagen coloreada de la cara de un mapache.

Ejemplo: Guardar imagen usando SciPy

from scipy import misc
import imageio
import matplotlib.pyplot as plt
 
# reads a raccoon face
face = misc.face()
 
# save the image
imageio.imsave('raccoon.png', face)
 
plt.imshow(face)
plt.show()

Producción:

Ejemplo: crear una array NumPy a partir de la imagen

Aquí leeremos la imagen usando la función imread().

from scipy import misc
import imageio
import matplotlib.pyplot as plt
 
img = imageio.imread('raccoon.png')
 
print(img.shape)
print(img.dtype)
 
plt.imshow(img)
plt.show()

Producción:

(768, 1024, 3)
uint8

Crear archivo RAW

Un archivo RAW es un archivo que contiene datos mínimamente procesados ​​de un sensor de imagen. Podemos crear este archivo usando el método tofile() del paquete scipy.

Ejemplo: Crear un archivo RAW usando SciPy

from scipy import misc
import imageio
import matplotlib.pyplot as plt
 
# reads a raccoon face
face = misc.face()
 
face.tofile("raccoon.raw")

Esto creará un archivo .raw en nuestro directorio de trabajo actual.

Apertura de archivo RAW

Para abrir el archivo .raw, necesitaremos el módulo NumPy que usará el método fromfile(). Esta función es una forma eficiente de leer datos binarios con un tipo de datos conocido, así como de analizar texto con formato simple.

Ejemplo: lectura de un archivo RAW usando NumPy

import numpy as np
 
img = np.fromfile('raccoon.raw',
                  dtype=np.uint8)
 
print(img.shape)

Producción:

(2359296,)

Obtención de información estadística

Podemos usar las funciones max() y min() para obtener el máximo y el mínimo a lo largo del eje dado. Y para encontrar la media podemos usar la función mean().

Ejemplo: obtener valores mínimos, máximos y medios

from scipy import misc
 
img = misc.face()
 
print(img.max())
print(img.min())
print(img.mean())

Producción:

255
0
110.16274388631184

Imagen recortada

Como sabemos que las imágenes están representadas por números en una array, cambiar el valor de la array resultará en cambiar la imagen original. Veamos cómo usar esta idea para recortar la imagen.

Ejemplo: recortar la imagen

from scipy import misc
import matplotlib.pyplot as plt
 
# for grascaling the image
img = misc.face(gray = True)
 
 
x, y = img.shape
 
# Cropping the image
crop = img[x//3: - x//8, y//3: - y//8]
 
plt.imshow(crop)
plt.show()

Producción:

Voltear imágenes

Podemos usar la función flipud() del módulo numpy para voltear esa imagen. Esta función voltea la array (entradas en cada columna) en dirección arriba-abajo, conservando la forma.

Ejemplo: Voltear imagen usando Scipy

from scipy import misc
import numpy as np
import matplotlib.pyplot as plt
 
img = misc.face()
 
flip = np.flipud(img)
 
plt.imshow(flip)
plt.show()

Producción:

Imágenes giratorias

Para rotar las imágenes podemos usar la función ndarray.rotate(). Esta función gira la imagen en un ángulo específico.

Ejemplo: Rotar imagen usando SciPy y NumPy

from scipy import misc,ndimage
import matplotlib.pyplot as plt
 
 
img = misc.face()
 
rotate = ndimage.rotate(face, 30)
 
plt.imshow(rotate)
plt.show()

Producción:

Filtrado de imágenes

En términos más simples, el filtrado de imágenes es un proceso para mejorar o modificar una imagen en el que podemos aumentar la nitidez, mejorar los bordes o desenfocar la imagen. En el filtrado de imágenes, se aplica algún algoritmo al valor de píxel de la imagen dada y ese algoritmo determina el valor de la imagen de salida. Veamos algunas operaciones de filtrado de imágenes que se pueden realizar con NumPy y SciPy.

Imágenes borrosas

Desenfocar una imagen es un proceso de reducción del nivel de ruido en la imagen. Para esto, podemos usar un filtro gaussiano o un filtro unicornio.

Ejemplo: desenfocar imágenes usando SciPy y NumPy

from scipy import misc,ndimage
import matplotlib.pyplot as plt
 
img = misc.face()
 
blur_G = ndimage.gaussian_filter(img,sigma=7)
 
plt.imshow(blur_G)
plt.show()

Producción:

Afilado de imágenes

La nitidez se refiere a aumentar el contraste entre las regiones claras y oscuras y hacer que la imagen sea más definida y resalte las características de la imagen. Hay tres razones principales para mejorar la nitidez de la imagen: superar la borrosidad introducida por el equipo de la cámara, llamar la atención sobre ciertas áreas y aumentar la legibilidad. Si hay texto borroso en la imagen, se vuelve fácil de leer.

Ejemplo: Afilado de imágenes usando NumPy y SciPy

from scipy import misc, ndimage
import matplotlib.pyplot as plt
 
img = misc.face(gray=True).astype(float)
blur = ndimage.gaussian_filter(img, 5)
 
# Showing Blur Image
plt.imshow(blur)
plt.show()
 
blur_G = ndimage.gaussian_filter(blur, 1)
alpha = 30
sharp = blur+alpha*(blur-blur_G)
 
# showing sharp images
plt.imshow(sharp)
plt.show()

Producción:

Imágenes de eliminación de ruido

La eliminación de ruido de una imagen se refiere al proceso de reconstrucción de una señal a partir de imágenes ruidosas. La eliminación de ruido se realiza para eliminar el ruido no deseado de la imagen para analizarla mejor. Al principio, vamos a crear una imagen ruidosa: 

Ejemplo 1: Creación de una imagen ruidosa

from scipy import misc,ndimage
import matplotlib.pyplot as plt
import numpy as np
 
img=misc.face(gray=True).astype(float)
img=img[40:100,30:100]
 
noise_img=img+0.9*img.std()*np.random.random(img.shape)
 
plt.imshow(noise_img)
plt.show()

Producción:

Para suavizar los bordes y el ruido usamos el filtro Gaussiano.

denoised = ndimage.gaussian_filter(noise_img, 2.2)
 
plt.imshow(denoised)
plt.show()

Producción:

También podemos conservar los bordes utilizando el filtro mediano.

denoised = ndimage.median_filter(noise_img, 4)
 
plt.imshow(denoised)
plt.show()

Producción:

Detección de bordes

El proceso de detección de imágenes implica la detección de bordes en la imagen. Funciona detectando discontinuidades en el brillo. Para variaciones de alta intensidad, podemos usar Sobel, un operador de gradiente.

Ejemplo: Detección de bordes usando SciPy y NumPy

from scipy import misc, ndimage
import matplotlib.pyplot as plt
import numpy as np
 
img = np.zeros((300, 300))
img[64:-64, 64:-64] = 1
img = ndimage.rotate(im, 30, mode='constant')
img = ndimage.gaussian_filter(im, 7)
 
# Original image
plt.imshow(im)
plt.show()
 
# edge detection
x = ndimage.sobel(im, axis=0, mode='constant')
y = ndimage.sobel(im, axis=1, mode='constant')
Sobel = np.hypot(x, y)
 
plt.imshow(sob)
plt.show()

Producción: