Comment créer un collage d'images à l'aide de Python

Un collage est une belle façon de mettre en valeur des souvenirs et d’afficher des ensembles d’images. Les créateurs de collages en ligne peuvent avoir des problèmes de sécurité et les applications hors ligne peuvent coûter de l'argent et ne pas disposer des fonctionnalités dont vous avez besoin.

En créant votre propre créateur de collages d'images, vous pouvez éliminer ces problèmes et conserver un contrôle total. Alors, comment pouvez-vous en construire un ?

Le module Tkinter et PIL

Pour créer une application de collage d'images, vous avez besoin de Tkinter et du module PIL. Tkinter vous permet de créer des applications de bureau. Il propose une variété de widgets qui facilitent la tâche développer des interfaces graphiques.

La bibliothèque Pillow, une branche de la Python Imaging Library (PIL), fournit des capacités de traitement d'image qui facilitent l'édition, la création, conversion de formats de fichierset enregistrer des images.

Pour installer Tkinter et Pillow, ouvrez un terminal et exécutez :

pip install tk pillow

Configuration de l'interface graphique et manipulation d'images

Vous pouvez trouver le code source de ce projet dans son Dépôt GitHub.

Commencez par importer les modules requis. Créer une classe, ImageCollageApp, puis définissez le titre et les dimensions de la fenêtre. Définir un canevas en utilisant merci. Toile() et définissez son élément parent, sa largeur, sa hauteur et sa couleur d'arrière-plan.

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()

Créez deux boutons: Ajouter une image, et Créer un collage. Définissez l'élément parent, le texte à afficher, la commande à exécuter et les styles de police. Organisez les boutons en ajoutant un rembourrage approprié. Initialiser drag_data pour stocker des informations sur l’opération de glissement.

Initialiser image_positions pour stocker les positions des images sur la toile. Définissez trois gestionnaires d'événements pour répondre à la sélection, au glissement et à la libération des images.

 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)

Définir une méthode, sur_press. Récupérez l'élément de canevas le plus proche de l'emplacement où l'utilisateur clique avec la souris et stockez-le sous le article clé de la drag_data dictionnaire. Stockez les coordonnées x et y du clic de souris. Vous l'utiliserez pour calculer la distance sur laquelle l'utilisateur déplace la souris pendant le glissement.

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

Définir une méthode, on_drag. Calculez la distance horizontale et verticale à laquelle l'utilisateur a déplacé la souris pendant le glissement et mettez à jour la position de l'image en conséquence. Stockez les coordonnées mises à jour de l'image sous le X et oui clés du drag_data dictionnaire.

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

Définir une méthode, on_release. Effacez la référence à l’image que l’utilisateur faisait glisser ainsi que ses coordonnées. Appeler le update_image_positions pour mettre à jour les positions de toutes les images sur le canevas après que l'utilisateur les a glissées et relâchées.

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

Définir une méthode, update_image_positions. Effacer le image_positions lister et parcourir tous les éléments du canevas. Pour chaque élément, trouvez les coordonnées et ajoutez-les à la liste.

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

Définir une méthode, ajouter des images. Créez une boîte de dialogue qui invite l'utilisateur à saisir le nombre d'images pour le collage. Si l'utilisateur a fourni un numéro valide, ouvrez une boîte de dialogue de fichier qui permet uniquement à l'utilisateur de sélectionner des fichiers image. Une fois que l'utilisateur a sélectionné une ou plusieurs images, ouvrez chacune d'elles avec Pillow's Image.open() méthode.

Appeler le resize_image et créez un fichier compatible Tkinter PhotoImage. Ajoutez ceci au image_refs liste et appelez le mise à jour_canvas méthode.

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()

Définir une méthode, resize_image. Obtenez la largeur et la hauteur de l’image et calculez son rapport hauteur/largeur. S'il y en a plusieurs, définissez la nouvelle largeur sur la moitié de la largeur du collage. Calculez la nouvelle hauteur correspondante tout en conservant le rapport hauteur/largeur.

Si le rapport hauteur/largeur est inférieur à un, définissez la nouvelle hauteur sur la moitié de la hauteur du collage. De même, calculez la largeur correspondante. Utiliser des oreillers redimensionner méthode pour renvoyer une image redimensionnée en utilisant les paramètres calculés.

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

Définir une méthode, mise à jour_canvas. Effacez tous les éléments et demandez à l'utilisateur le nombre souhaité de lignes et de colonnes via une boîte de dialogue de fichier. Définissez la largeur et la hauteur du collage pour qu'elles prennent la moitié de la taille spécifiée du collage. Efface la liste des positions d’image. Initialiser X et oui offset à zéro, afin que vous puissiez suivre les décalages de position pour organiser les images en lignes et en colonnes.

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

Itérer sur le image_refs lister et créer une image sur le canevas en utilisant le décalage spécifié. Définissez l'ancre sur Nord-ouest afin de positionner le coin supérieur gauche de l'image aux coordonnées spécifiées. Ajoutez ces coordonnées au image_positions liste.

Mettre à jour le x_décalage pour ajouter la moitié de la largeur du collage, afin de préparer le placement de l'image suivante. Si le nombre d'images placées dans la ligne actuelle est un multiple du nombre de colonnes spécifié, définissez le x_décalage à zéro. Cela indique le début d'une nouvelle ligne. Ajoutez la moitié de la hauteur du collage pour définir la oui coordonner pour la rangée suivante.

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

Créer le collage et l'enregistrer

Définir une méthode, créer_collage. S'il n'y a aucune image sur le collage, affichez un avertissement. Collectez la largeur et la hauteur du collage. Créer un oreiller Image avec un fond blanc. Parcourez le images répertoriez et collez chaque image sur l’arrière-plan aux positions spécifiées.

Enregistrez le collage et affichez-le à l'aide de la visionneuse d'images par défaut.

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()

Créez une instance de Tkinter et Application ImageCollage classe. Le boucle principale() La fonction indique à Python d'exécuter la boucle d'événements Tkinter et d'écouter les événements jusqu'à ce que vous fermiez la fenêtre.

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

Test de différentes fonctionnalités du créateur de collages d'images

Lors de l'exécution du programme, une fenêtre apparaît avec deux boutons, Ajouter une image, et Créer un collage. En cliquant sur le Ajouter une image bouton, une boîte de dialogue demande le nombre d’images à coller. En entrant le nombre d'images comme cinq et en les sélectionnant, une autre boîte de dialogue apparaît. Il demande le nombre de lignes suivi du nombre de colonnes.

En entrant deux lignes et trois colonnes, la fenêtre organise les images dans une structure de grille.

L'aperçu donne la possibilité de faire glisser les images selon vos envies. En cliquant sur le Créer un collage bouton, le programme enregistre l'image.

En visualisant l'image, vous pouvez confirmer que le programme a créé le collage avec succès.

Amélioration des fonctionnalités du créateur de collages d'images

Au lieu d'un format tabulaire, vous pouvez fournir différents modèles par défaut parmi lesquels l'utilisateur peut choisir. Ajoutez des fonctionnalités permettant de modifier la couleur d'arrière-plan, d'ajouter du texte, d'appliquer des filtres aux images et d'insérer des autocollants depuis Internet.

Lors de l'ajout de ces fonctionnalités, facilitez la modification du collage avec une option permettant d'annuler ou de refaire. Laissez l'utilisateur recadrer, redimensionner et retourner les images à sa guise. Vous devez également ajouter une option pour enregistrer l'image dans le format souhaité.