Come creare un collage di immagini utilizzando Python

Un collage è un modo bellissimo per mostrare ricordi e visualizzare serie di immagini. I creatori di collage online potrebbero avere problemi di sicurezza e le app offline potrebbero costare denaro e non avere le funzionalità richieste.

Costruendo il tuo creatore di collage di immagini puoi eliminare queste preoccupazioni e mantenere il controllo completo. Quindi, come puoi costruirne uno?

Il modulo Tkinter e PIL

Per creare un'applicazione di collage di immagini sono necessari Tkinter e il modulo PIL. Tkinter ti consente di creare applicazioni desktop. Offre una varietà di widget che lo rendono più semplice per sviluppare GUI.

La libreria Pillow, un fork della Python Imaging Library (PIL), fornisce funzionalità di elaborazione delle immagini che aiutano a modificare, creare, conversione dei formati di filee salvare le immagini.

Per installare Tkinter e Pillow, apri un terminale ed esegui:

pip install tk pillow

Configurazione della GUI e manipolazione delle immagini

Puoi trovare il codice sorgente di questo progetto nel suo file Repositorio GitHub.

Inizia da importando i moduli richiesti. Crea una classe, Collage di immaginiAppe imposta il titolo e le dimensioni della finestra. Definisci una tela utilizzando ok. Tela() e impostarne l'elemento principale, la larghezza, l'altezza e il colore di sfondo.

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 due pulsanti: Aggiungi immagine, E Crea collage. Definire l'elemento genitore, il testo da visualizzare, il comando da eseguire e gli stili dei caratteri. Organizza i pulsanti aggiungendo l'imbottitura appropriata. Inizializzare drag_data per memorizzare informazioni sull'operazione di trascinamento.

Inizializzare posizioni_immagine per memorizzare le posizioni delle immagini sulla tela. Definire tre gestori di eventi per rispondere alla selezione, al trascinamento e al rilascio delle immagini.

 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)

Definire un metodo, on_press. Recupera l'elemento canvas più vicino dalla posizione in cui l'utente fa clic con il mouse e memorizzalo sotto il file articolo chiave del drag_data dizionario. Memorizza le coordinate xey del clic del mouse. Lo utilizzerai per calcolare la distanza alla quale l'utente sposta il mouse durante il trascinamento.

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

Definire un metodo, on_drag. Calcola la distanza orizzontale e verticale alla quale l'utente ha spostato il mouse durante il trascinamento e aggiorna di conseguenza la posizione dell'immagine. Memorizza le coordinate aggiornate dell'immagine sotto il file X E sì le chiavi del drag_data dizionario.

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

Definire un metodo, on_release. Cancella il riferimento all'immagine che l'utente stava trascinando insieme alle sue coordinate. Chiama il aggiornamento_immagine_posizioni per aggiornare le posizioni di tutte le immagini sull'area di disegno dopo che l'utente le ha trascinate e rilasciate.

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

Definire un metodo, aggiornamento_immagine_posizioni. Cancella il posizioni_immagine elencare ed eseguire l'iterazione su tutti gli elementi del canvas. Per ogni elemento, trova le coordinate e aggiungile all'elenco.

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

Definire un metodo, aggiungi_immagini. Crea una finestra di dialogo che richiede all'utente di inserire il numero di immagini per il collage. Se l'utente ha fornito un numero valido, apre una finestra di dialogo file che consente all'utente solo di selezionare file di immagine. Una volta che l'utente ha selezionato una o più immagini, aprile ciascuna con Pillow's Immagine.open() metodo.

Chiama il ridimensiona_immagine metodo e creare un file compatibile con Tkinter FotoImmagine. Aggiungi questo al riferimenti_immagine elenco e chiamare il aggiornamento_tela metodo.

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

Definire un metodo, ridimensiona_immagine. Ottieni la larghezza e l'altezza dell'immagine e calcola le sue proporzioni. Se è più di uno, imposta la nuova larghezza su metà della larghezza del collage. Calcola la nuova altezza corrispondente mantenendo le proporzioni.

Se le proporzioni sono inferiori a uno, imposta la nuova altezza su metà dell'altezza del collage. Allo stesso modo, calcola la larghezza corrispondente. Usa quello del cuscino ridimensionare metodo per restituire un'immagine ridimensionata utilizzando i parametri calcolati.

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

Definire un metodo, aggiornamento_tela. Cancella tutti gli elementi e chiedi all'utente il numero desiderato di righe e colonne tramite una finestra di dialogo file. Imposta la larghezza e l'altezza del collage in modo che occupino la metà della dimensione del collage specificata. Cancella l'elenco delle posizioni delle immagini. Inizializzare X E sì offset a zero, in modo da poter tenere traccia degli offset di posizione per organizzare le immagini in righe e colonne.

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

Iterare su riferimenti_immagine list e crea un'immagine sulla tela utilizzando l'offset specificato. Imposta l'ancoraggio su Nord-ovest in modo da posizionare l'angolo superiore sinistro dell'immagine sulle coordinate specificate. Aggiungi queste coordinate a posizioni_immagine elenco.

Aggiorna il x_offset per aggiungere metà della larghezza del collage, per prepararsi a posizionare l'immagine successiva. Se il numero di immagini inserite nella riga corrente è un multiplo del numero di colonne specificato, impostare il file x_offset a zero. Questo indica l'inizio di una nuova riga. Aggiungi metà dell'altezza del collage per impostare il sì coordinata per la riga successiva.

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

Creare il collage e salvarlo

Definire un metodo, crea_collage. Se nel collage non sono presenti immagini, viene visualizzato un avviso. Raccogli la larghezza e l'altezza del collage. Crea un cuscino Immagine con uno sfondo bianco. Scorrere il file immagini elenca e incolla ciascuna immagine sullo sfondo nelle posizioni specificate.

Salva il collage e visualizzalo utilizzando il visualizzatore di immagini predefinito.

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 un'istanza di Tkinter e Applicazione Collage di immagini classe. IL ciclo principale() La funzione dice a Python di eseguire il ciclo di eventi di Tkinter e di ascoltare gli eventi finché non chiudi la finestra.

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

Testare diverse funzionalità di Image Collage Maker

Durante l'esecuzione del programma, appare una finestra con due pulsanti, Aggiungi immagine, E Crea collage. Facendo clic su Aggiungi immagine pulsante, una finestra di dialogo chiede il numero di immagini da collage. Inserendo il numero di immagini come cinque e selezionandole, appare un'altra finestra di dialogo. Richiede il numero di righe seguito dal numero di colonne.

Inserendo due righe e tre colonne, la finestra organizza le immagini in una struttura a griglia.

L'anteprima dà la possibilità di trascinare le immagini come desiderato. Facendo clic su Crea collage pulsante, il programma salva l'immagine.

Visualizzando l'immagine, puoi confermare che il programma ha creato correttamente il collage.

Miglioramento della funzionalità di Image Collage Maker

Invece di un formato tabellare, puoi fornire diversi modelli predefiniti tra cui l'utente può scegliere. Aggiungi funzionalità per cambiare il colore di sfondo, aggiungere testo, applicare filtri alle immagini e inserire adesivi da Internet.

Mentre aggiungi queste funzionalità, semplifica la modifica del collage con un'opzione per annullare o ripetere. Consenti all'utente di ritagliare, ridimensionare e capovolgere le immagini in base alle proprie preferenze. Dovresti anche aggiungere un'opzione per salvare l'immagine nel formato desiderato.