Procesando imágenes

Una de las características de la programación concurrente es que se puede realizar múltiples procesos al mismo tiempo. Para ello se describe un script escrito en python donde se procesan varias imágenes en las que se aplicará filtro de blanco y negro y serán guardado en otra ruta.

Requerimientos

pip install Pillow

Script

from concurrent.futures import ThreadPoolExecutor
from PIL import Image

def procesar_imagen(ruta_entrada, ruta_salida):
    # Cargar la imagen
    imagen = Image.open(ruta_entrada)

    # Aplicar un filtro de blanco y negro
    imagen_bn = imagen.convert("L")

    # Guardar la imagen resultante
    imagen_bn.save(ruta_salida)

def procesar_imagenes_concurrentemente(lista_imagenes):
    with ThreadPoolExecutor() as executor:
        futures = []

        for ruta_entrada in lista_imagenes:
            # Generar una ruta de salida basada en la entrada
            ruta_salida = f"bn_{ruta_entrada}"

            # Iniciar un hilo para procesar la imagen
            future = executor.submit(procesar_imagen, ruta_entrada, ruta_salida)
            futures.append(future)

        # Esperar a que todos los hilos terminen
        for future in futures:
            future.result()

if __name__ == "__main__":
    # Lista de imágenes de entrada
    lista_imagenes = ["imagen1.jpg", "imagen2.jpg", "imagen3.jpg"]

    # Procesar imágenes concurrentemente
    procesar_imagenes_concurrentemente(lista_imagenes)

    print("Procesamiento de imágenes completado.")

Explicación

Cada imagen se procesa en un hilo separado, lo que permite procesar varias imágenes al mismo tiempo sin tener que esperar a que una imagen termine de procesarse antes de comenzar con la siguiente. La cantidad de imágenes que puedes procesar simultáneamente depende en parte de la implementación específica de la biblioteca concurrente y de la capacidad de tu sistema para manejar hilos concurrentes.

Importar Librerías:

• concurrent.futures.ThreadPoolExecutor: Importa la clase ThreadPoolExecutor que permite ejecutar funciones en hilos de forma concurrente.
• PIL.Image: Importa la clase Image de la biblioteca Pillow (PIL), que se utiliza para cargar, procesar y guardar imágenes.

Definir la Función procesar_imagen:

• procesar_imagen: Una función que toma una ruta de entrada y una ruta de salida, carga una imagen, la convierte a blanco y negro y luego guarda la imagen resultante.

Definir la Función procesar_imagenes_concurrentemente:

• procesar_imagenes_concurrentemente: Una función que toma una lista de rutas de imágenes, crea un conjunto de hilos (ThreadPoolExecutor) y procesa cada imagen concurrentemente utilizando hilos.

Bloque Principal:

• El bloque principal verifica si el script se está ejecutando directamente (no importado como un módulo). Luego, crea una lista de imágenes y llama a la función procesar_imagenes_concurrentemente para procesar las imágenes en hilos concurrentes.

Cada imagen se carga, se convierte a blanco y negro y se guarda en un hilo separado. La lista de imágenes se procesa concurrentemente, lo que puede acelerar el procesamiento en comparación con un enfoque secuencial.

Si tienes una gran cantidad de imágenes para procesar y quieres aprovechar aún más la concurrencia, podrías explorar el uso de concurrent.futures.ProcessPoolExecutor, que utiliza procesos en lugar de hilos y puede ser más eficiente para ciertas operaciones intensivas en CPU. Ten en cuenta que el uso de procesos implica ciertas consideraciones, como la necesidad de compartir datos entre procesos.