Cómo hacer un collage de imágenes usando Python

Un collage es una hermosa manera de mostrar recuerdos y conjuntos de imágenes. Los creadores de collages en línea pueden tener problemas de seguridad y las aplicaciones fuera de línea pueden costar dinero y carecer de las funciones que necesita.

Al crear su propio creador de collages de imágenes, puede eliminar estas preocupaciones y conservar el control total. Entonces, ¿cómo se puede construir uno?

El módulo Tkinter y PIL

Para crear una aplicación de collage de imágenes, necesita Tkinter y el módulo PIL. Tkinter te permite crear aplicaciones de escritorio. Ofrece una variedad de widgets que lo hacen más fácil. desarrollar GUI.

La biblioteca Pillow, una bifurcación de Python Imaging Library (PIL), proporciona capacidades de procesamiento de imágenes que ayudan a editar, crear y convertir formatos de archivosy guardar imágenes.

Para instalar Tkinter y Pillow, abra una terminal y ejecute:

pip install tk pillow

Configuración de GUI y manipulación de imágenes

Puedes encontrar el código fuente de este proyecto en su repositorio de GitHub.

Empezar por importando los módulos requeridos. Crear una clase, Aplicación ImageCollagey establezca el título y las dimensiones de la ventana. Definir un lienzo usando tk. Lienzo() y establezca su elemento principal, ancho, alto y color de fondo.

import tkinter as tk
from tkinter import filedialog, simpledialog, messagebox
from PIL import Image, ImageTk
classImageCollageApp:
def__init__(self, root):
 self.root = root
 self.root.title("Image Collage Maker")
 self.images = []
 self.image_refs = []
 self.collage_size = (600, 500)
 self.collage_canvas = tk.Canvas(
 self.root,
 width=self.collage_size[0],
 height=self.collage_size[1],
 bg="white",
 )
 self.collage_canvas.pack()

Crea dos botones: Añadir imagen, y Crear collage. Defina el elemento principal, el texto que se mostrará, el comando que se ejecutará y los estilos de fuente. Organice los botones agregando el relleno adecuado. Inicializar arrastrar_datos para almacenar información sobre la operación de arrastre.

Inicializar posiciones_imagen para almacenar las posiciones de las imágenes en el lienzo. Defina tres controladores de eventos para responder a la selección, arrastre y liberación de imágenes.

 self.btn_add_image = tk.Button(
 self.root,
 text="Add Image",
 command=self.add_images,
 font=("Arial", 12, "bold"),
 )
 self.btn_add_image.pack(pady=10)
 self.btn_create_collage = tk.Button(
 self.root,
 text="Create Collage",
 command=self.create_collage,
 font=("Arial", 12, "bold"),
 )
 self.btn_create_collage.pack(pady=5)
 self.drag_data = {"x": 0, "y": 0, "item": None}
 self.image_positions = []
 self.collage_canvas.bind("", self.on_press)
 self.collage_canvas.bind("", self.on_drag)
 self.collage_canvas.bind("", self.on_release)

Definir un método, on_press. Recupere el elemento del lienzo más cercano a la ubicación donde el usuario hace clic con el mouse y guárdelo debajo del artículo clave de la arrastrar_datos diccionario. Almacene las coordenadas xey del clic del mouse. Utilizará esto para calcular la distancia que el usuario mueve el mouse durante el arrastre.

defon_press(self, event):
 self.drag_data["item"] = self.collage_canvas.find_closest(event.x, event.y)[0]
 self.drag_data["x"] = event.x
 self.drag_data["y"] = event.y

Definir un método, on_drag. Calcule la distancia horizontal y vertical en la que el usuario movió el mouse durante el arrastre y actualice la posición de la imagen en consecuencia. Guarde las coordenadas actualizadas de la imagen en el X y y llaves de la arrastrar_datos diccionario.

defon_drag(self, event):
 delta_x = event.x - self.drag_data["x"]
 delta_y = event.y - self.drag_data["y"]
 self.collage_canvas.move(self.drag_data["item"], delta_x, delta_y)
 self.drag_data["x"] = event.x
 self.drag_data["y"] = event.y

Definir un método, en lanzamiento. Borra la referencia a la imagen que el usuario estaba arrastrando junto con sus coordenadas. Llama a actualizar_posiciones_imagen para actualizar las posiciones de todas las imágenes en el lienzo después de que el usuario las arrastra y suelta.

defon_release(self, event):
 self.drag_data["item"] = None
 self.drag_data["x"] = 0
 self.drag_data["y"] = 0
 self.update_image_positions()

Definir un método, actualizar_posiciones_imagen. Limpiar el posiciones_imagen enumerar e iterar sobre todos los elementos del lienzo. Para cada elemento, busque las coordenadas y agréguelas a la lista.

defupdate_image_positions(self):
 self.image_positions.clear()
for item in self.collage_canvas.find_all():
 x, y = self.collage_canvas.coords(item)
 self.image_positions.append((x, y))

Definir un método, añadir imágenes. Cree un cuadro de diálogo que solicite al usuario que ingrese la cantidad de imágenes para el collage. Si el usuario proporcionó un número válido, abra un cuadro de diálogo de archivo que solo le permita seleccionar archivos de imagen. Una vez que el usuario haya seleccionado una o más imágenes, abra cada una con Pillow's Imagen.abierta() método.

Llama a cambiar el tamaño de la imagen método y crear un compatible con Tkinter FotoImagen. Añade esto al referencias_imagen lista y llama al lienzo_actualización método.

defadd_images(self):
 num_images = simpledialog.askinteger(
"Number of Images", "Enter the number of images:"
 )
if num_images isnotNone:
 file_paths = filedialog.askopenfilenames(
 filetypes=[("Image files", "*.png;*.jpg;*.jpeg;*.gif")]
 )
if file_paths:
for i in range(min(num_images, len(file_paths))):
 file_path = file_paths[i]
 image = Image.open(file_path)
 resized_image = self.resize_image(image)
 self.images.append(resized_image)
 self.image_refs.append(ImageTk.PhotoImage(resized_image))
 self.update_canvas()

Definir un método, cambiar el tamaño de la imagen. Obtenga el ancho y el alto de la imagen y calcule su relación de aspecto. Si es más de uno, establezca el nuevo ancho en la mitad del ancho del collage. Calcule la nueva altura correspondiente manteniendo la relación de aspecto.

Si la relación de aspecto es menor que uno, establezca la nueva altura en la mitad de la altura del collage. Del mismo modo, calcule el ancho correspondiente. Usa almohadas cambiar el tamaño método para devolver una imagen redimensionada utilizando los parámetros calculados.

defresize_image(self, image):
 img_width, img_height = image.size
 aspect_ratio = img_width / img_height
if aspect_ratio > 1:
 new_width = self.collage_size[0] // 2
 new_height = int(new_width / aspect_ratio)
else:
 new_height = self.collage_size[1] // 2
 new_width = int(new_height * aspect_ratio)
return image.resize((new_width, new_height))

Definir un método, lienzo_actualización. Borre todos los elementos y solicite al usuario el número deseado de filas y columnas a través de un cuadro de diálogo de archivo. Establezca el ancho y el alto del collage para que ocupe la mitad del tamaño del collage especificado. Borra la lista de posiciones de imágenes. Inicializar X y y desplazamiento a cero, para que pueda realizar un seguimiento de los desplazamientos de posición para organizar imágenes en filas y columnas.

defupdate_canvas(self):
 self.collage_canvas.delete("all")
 rows = simpledialog.askinteger("Number of Rows", "Enter the number of rows:")
 cols = simpledialog.askinteger(
"Number of Columns", "Enter the number of columns:"
 )
 collage_width = self.collage_size[0] * cols // 2
 collage_height = self.collage_size[1] * rows // 2
 self.collage_canvas.config(width=collage_width, height=collage_height)
 self.image_positions.clear()
 x_offset, y_offset = 0, 0

Iterar sobre el referencias_imagen liste y cree una imagen en el lienzo utilizando el desplazamiento especificado. Establezca el ancla en Noroeste para colocar la esquina superior izquierda de la imagen en las coordenadas especificadas. Añade estas coordenadas a la posiciones_imagen lista.

Actualizar el x_compensación para agregar la mitad del ancho del collage, para preparar la colocación de la siguiente imagen. Si el número de imágenes colocadas en la fila actual es un múltiplo del número de columnas especificado, configure el x_compensación a cero. Esto indica el comienzo de una nueva fila. Añade la mitad de la altura del collage para establecer el y coordinar para la siguiente fila.

for i, image_ref in enumerate(self.image_refs):
 self.collage_canvas.create_image(
 x_offset, y_offset, anchor=tk.NW, image=image_ref
 )
 self.image_positions.append((x_offset, y_offset))
 x_offset += self.collage_size[0] // 2
if (i + 1) % cols == 0:
 x_offset = 0
 y_offset += self.collage_size[1] // 2

Crear el collage y guardarlo

Definir un método, crear_collage. Si no hay imágenes en el collage, muestra una advertencia. Recoge el ancho y el alto del collage. crear una almohada Imagen con un fondo blanco. Iterar a través del imágenes enumere y pegue cada imagen en el fondo en las posiciones especificadas.

Guarde el collage y muéstrelo usando el visor de imágenes predeterminado.

defcreate_collage(self):
if len(self.images) == 0:
 messagebox.showwarning("Warning", "Please add images first!")
return
 collage_width = self.collage_canvas.winfo_width()
 collage_height = self.collage_canvas.winfo_height()
 background = Image.new("RGB", (collage_width, collage_height), "white")
for idx, image in enumerate(self.images):
 x_offset, y_offset = self.image_positions[idx]
 x_offset, y_offset = int(x_offset), int(y_offset)
 paste_box = (
 x_offset,
 y_offset,
 x_offset + image.width,
 y_offset + image.height,
 )
 background.paste(image, paste_box)
 background.save("collage_with_white_background.jpg")
 background.show()

Crea una instancia de Tkinter y Aplicación Collage de imágenes clase. El bucle principal() La función le dice a Python que ejecute el bucle de eventos de Tkinter y escuche los eventos hasta que cierre la ventana.

if __name__ == "__main__":
 root = tk.Tk()
 app = ImageCollageApp(root)
 root.mainloop()

Probando diferentes funciones del Image Collage Maker

Al ejecutar el programa, aparece una ventana con dos botones, Añadir imagen, y Crear collage. Al hacer clic en el Añadir imagen, un cuadro de diálogo pregunta la cantidad de imágenes que se van a combinar. Al ingresar el número de imágenes como cinco y seleccionarlas, aparece otro cuadro de diálogo. Pregunta el número de filas seguido del número de columnas.

Al ingresar dos filas y tres columnas, la ventana organiza las imágenes en una estructura de cuadrícula.

La vista previa ofrece la posibilidad de arrastrar las imágenes según lo desee. Al hacer clic en el Crear collage, el programa guarda la imagen.

Al ver la imagen, puede confirmar que el programa creó el collage correctamente.

Mejora de la funcionalidad del creador de collages de imágenes

En lugar de un formato tabular, puede proporcionar diferentes plantillas predeterminadas para que el usuario elija. Agregue funciones para cambiar el color de fondo, agregar texto, aplicar filtros a las imágenes e insertar pegatinas de Internet.

Mientras agrega estas funciones, facilite la edición del collage con una opción para deshacer o rehacer. Permita que el usuario recorte, cambie el tamaño y voltee las imágenes según su gusto. También debes agregar una opción para guardar la imagen en el formato deseado.