Cum să faci un colaj de imagini folosind Python

Un colaj este o modalitate frumoasă de a prezenta amintiri și de a afișa seturi de imagini. Producătorii de colaje online pot avea probleme de securitate, iar aplicațiile offline pot costa bani și nu dispun de funcțiile de care aveți nevoie.

Prin construirea propriului dvs. creator de colaje de imagini, puteți elimina aceste preocupări și puteți păstra controlul complet. Deci, cum poți să construiești unul?

Modulul Tkinter și PIL

Pentru a construi o aplicație de colaj de imagini aveți nevoie de Tkinter și modulul PIL. Tkinter vă permite să creați aplicații desktop. Oferă o varietate de widget-uri care fac acest lucru mai ușor pentru a dezvolta GUI.

Biblioteca Pillow – o furcă a Bibliotecii de imagini Python (PIL) – oferă capabilități de procesare a imaginilor care ajută la editare, creare, conversia formatelor de fișiere, și salvarea imaginilor.

Pentru a instala Tkinter și Pillow, deschideți un terminal și rulați:

pip install tk pillow

Configurarea GUI și manipularea imaginilor

Puteți găsi codul sursă al acestui proiect în documentul său Depozitul GitHub.

Începe prin importul modulelor necesare. Creați o clasă, ImageCollageAppși setați titlul și dimensiunile ferestrei. Definiți o pânză folosind tk. Canvas() și setați elementul părinte, lățimea, înălțimea și culoarea de fundal.

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ți două butoane: Adauga imagine, și Creați un colaj. Definiți elementul părinte, textul de afișat, comanda de rulat și stilurile de font. Organizați butoanele adăugând umplutură adecvată. Inițializați drag_data pentru a stoca informații despre operația de glisare.

Inițializați poziții_imagine pentru a stoca pozițiile imaginilor pe pânză. Definiți trei handlere de evenimente pentru a răspunde la selecția, tragerea și eliberarea imaginilor.

 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)

Definiți o metodă, on_press. Preluați cel mai apropiat element de pânză din locația în care utilizatorul face clic pe mouse și stocați-l sub articol cheia de drag_data dicţionar. Stocați coordonatele x și y ale clicului mouse-ului. Veți folosi acest lucru pentru a calcula distanța la care utilizatorul mișcă mouse-ul în timpul tragerii.

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

Definiți o metodă, on_drag. Calculați distanța orizontală și verticală la care utilizatorul a mișcat mouse-ul în timpul tragerii și actualizați poziția imaginii în consecință. Stocați coordonatele actualizate ale imaginii sub X și y cheile de drag_data dicţionar.

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

Definiți o metodă, on_release. Ștergeți referința la imaginea pe care o tragea utilizatorul împreună cu coordonatele acesteia. Suna update_image_positions pentru a actualiza pozițiile tuturor imaginilor de pe pânză după ce utilizatorul o trage și o eliberează.

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

Definiți o metodă, update_image_positions. Ștergeți poziții_imagine enumerați și repetați peste toate elementele de pânză. Pentru fiecare articol, găsiți coordonatele și adăugați-le în listă.

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

Definiți o metodă, adauga_imagini. Creați o casetă de dialog care solicită utilizatorului să introducă numărul de imagini pentru colaj. Dacă utilizatorul a furnizat un număr valid, deschideți o casetă de dialog pentru fișiere care îi permite utilizatorului doar să selecteze fișiere imagine. Odată ce utilizatorul a selectat una sau mai multe imagini, deschideți fiecare cu Pillow's Image.open() metodă.

Suna redimensionare_imagine metoda și creați o metodă compatibilă cu Tkinter PhotoImage. Adăugați asta la imagine_refs enumerați și sunați la update_canvas metodă.

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

Definiți o metodă, redimensionare_imagine. Obțineți lățimea și înălțimea imaginii și calculați raportul de aspect al acesteia. Dacă este mai mult de unul, setați noua lățime să fie jumătate din lățimea colajului. Calculați noua înălțime corespunzătoare menținând în același timp raportul de aspect.

Dacă raportul de aspect este mai mic de unu, setați noua înălțime să fie jumătate din înălțimea colajului. În mod similar, calculați lățimea corespunzătoare. Folosiți perne redimensiona metodă de a returna o imagine redimensionată utilizând parametrii calculați.

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

Definiți o metodă, update_canvas. Ștergeți toate elementele și cereți utilizatorului numărul dorit de rânduri și coloane printr-o casetă de dialog pentru fișiere. Setați lățimea și înălțimea colajului pentru a lua jumătate din dimensiunea colajului specificată. Șterge lista de poziții ale imaginii. Inițializați X și y offset la zero, astfel încât să puteți ține evidența decalajelor de poziție pentru aranjarea imaginilor în rânduri și coloane.

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

Iterați peste imagine_refs listează și creează o imagine pe pânză folosind offset-ul specificat. Setați ancora la nord-vest, astfel încât să poziționați colțul din stânga sus al imaginii la coordonatele specificate. Adăugați aceste coordonate la poziții_imagine listă.

Actualizați x_offset pentru a adăuga jumătate din lățimea colajului, pentru a se pregăti pentru plasarea următoarei imagini. Dacă numărul de imagini plasate în rândul curent este un multiplu al numărului specificat de coloane, setați x_offset la zero. Aceasta indică începutul unui nou rând. Adăugați jumătate din înălțimea colajului pentru a seta y coordona pentru următorul rând.

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

Crearea colajului și salvarea lui

Definiți o metodă, create_colage. Dacă nu există imagini pe colaj, afișați un avertisment. Colectați lățimea și înălțimea colajului. Creați o pernă Imagine cu un fundal alb. Iterați prin imagini enumerați și lipiți fiecare imagine pe fundal în pozițiile specificate.

Salvați colajul și afișați-l folosind vizualizatorul de imagini implicit.

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ți o instanță a Tkinter și Aplicația ImageCollage clasă. The mainloop() funcția îi spune lui Python să ruleze bucla de evenimente Tkinter și să asculte evenimente până când închideți fereastra.

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

Testarea diferitelor caracteristici ale Image Collage Maker

La rularea programului, apare o fereastră cu două butoane, Adauga imagine, și Creați un colaj. Făcând clic pe Adauga imagine butonul, o casetă de dialog cere numărul de imagini de colaj. După introducerea numărului de imagini ca cinci și selectarea lor, apare o altă casetă de dialog. Acesta cere numărul de rânduri urmat de numărul de coloane.

La introducerea a două rânduri și trei coloane, fereastra organizează imaginile într-o structură de grilă.

Previzualizarea oferă posibilitatea de a trage imaginile după dorință. Făcând clic pe Creați un colaj butonul, programul salvează imaginea.

La vizualizarea imaginii, puteți confirma că programul a creat colajul cu succes.

Îmbunătățirea funcționalității Image Collage Maker

În loc de un format tabelar, puteți oferi diferite șabloane implicite pentru ca utilizatorul să aleagă. Adăugați funcții pentru schimbarea culorii de fundal, adăugarea de text, aplicarea filtrelor imaginilor și inserarea autocolantelor de pe internet.

În timp ce adăugați aceste funcții, faceți ușor editarea colajului cu o opțiune de anulare sau refacere. Lăsați utilizatorul să decupeze, să redimensioneze și să răstoarne imaginile după cum îi place. De asemenea, ar trebui să adăugați o opțiune pentru a salva imaginea în formatul dorit.