Kuidas Pythoni abil pildikollaaži teha

Kollaaž on ilus viis mälestuste esitlemiseks ja pildikomplektide kuvamiseks. Interneti-kollaažide tegijatel võib olla turvaprobleeme ja võrguühenduseta rakendused võivad maksta raha ja neil puuduvad vajalikud funktsioonid.

Oma pildikollaažide loomisega saate need probleemid kõrvaldada ja säilitada täieliku kontrolli. Niisiis, kuidas saate seda ehitada?

Tkinteri ja PIL-i moodul

Pildi kollaažirakenduse loomiseks vajate Tkinterit ja PIL-moodulit. Tkinter võimaldab teil luua töölauarakendusi. See pakub mitmesuguseid vidinaid, mis muudavad selle lihtsamaks GUIde väljatöötamiseks.

Pillow teek – Pythoni pildiraamatukogu (PIL) hark – pakub pilditöötlusvõimalusi, mis aitavad redigeerida, luua, failivormingute teisendamineja piltide salvestamine.

Tkinteri ja Padja installimiseks avage terminal ja käivitage:

pip install tk pillow

GUI seadistamine ja pildiga manipuleerimine

Selle projekti lähtekoodi leiate sellest GitHubi hoidla.

Alustada vajalike moodulite importimine. Loo klass, ImageCollageAppja määrake akna pealkiri ja mõõtmed. Määratlege lõuend kasutades tk. Lõuend () ja määrake selle põhielement, laius, kõrgus ja taustavärv.

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

Looge kaks nuppu: Lisa piltja Loo kollaaž. Määrake põhielement, kuvatav tekst, käivitatav käsk ja fondi stiilid. Korraldage nupud sobiva polsterduse lisamisega. Initsialiseeri drag_data lohistamistoimingu kohta teabe salvestamiseks.

Initsialiseeri pildi_positsioonid piltide positsioonide salvestamiseks lõuendil. Määrake kolm sündmuste käitlejat, mis reageerivad piltide valimisele, lohistamisele ja vabastamisele.

 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)

Määratlege meetod, on_press. Otsige lähim lõuendiüksus kohast, kus kasutaja hiirega klõpsab, ja salvestage see alla üksus võti drag_data sõnastik. Salvestage hiireklõpsu x ja y koordinaadid. Kasutate seda kauguse arvutamiseks, mille kasutaja hiirt lohistamise ajal liigutab.

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

Määratlege meetod, on_drag. Arvutage horisontaalne ja vertikaalne kaugus, mille kasutaja hiirt lohistamise ajal liigutas, ja värskendage vastavalt pildi asukohta. Salvestage pildi värskendatud koordinaadid all x ja y võtmed drag_data sõnastik.

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

Määratlege meetod, on_release. Kustutage viide pildile, mille kasutaja lohistas, koos selle koordinaatidega. Helistage update_image_positions et värskendada kõigi lõuendil olevate piltide asukohti pärast seda, kui kasutaja selle lohistab ja vabastab.

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

Määratlege meetod, update_image_positions. Tühjendage pildi_positsioonid loetlege ja korrake kõiki lõuendi üksusi. Leidke iga üksuse jaoks koordinaadid ja lisage need loendisse.

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

Määratlege meetod, lisa_pildid. Looge dialoogiboks, mis palub kasutajal sisestada kollaaži jaoks piltide arv. Kui kasutaja andis kehtiva numbri, avage faili dialoogiboks, mis võimaldab kasutajal valida ainult pildifaile. Kui kasutaja on valinud ühe või mitu pilti, avage igaüks Pillow's abil Image.open() meetod.

Helistage resize_image meetodit ja looge Tkinteriga ühilduv PhotoImage. Lisage see image_refs nimekirja ja helistage update_canvas meetod.

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

Määratlege meetod, resize_image. Hankige pildi laius ja kõrgus ning arvutage selle kuvasuhe. Kui seda on rohkem kui üks, määrake uueks laiuseks pool kollaaži laiusest. Arvutage vastav uus kõrgus, säilitades kuvasuhte.

Kui kuvasuhe on väiksem kui üks, määrake uueks kõrguseks pool kollaaži kõrgusest. Samamoodi arvutage vastav laius. Kasutage patja suurust muutma meetod muudetud suurusega pildi tagastamiseks arvutatud parameetrite abil.

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

Määratlege meetod, update_canvas. Tühjendage kõik üksused ja küsige failidialoogiboksis kasutajalt soovitud ridade ja veergude arvu. Määrake kollaaži laiuseks ja kõrguseks pool määratud kollaaži suurusest. Kustutab pildi asukohtade loendi. Initsialiseeri x ja y nihe nullini, et saaksite jälgida positsiooninihkeid piltide ridadesse ja veergudesse paigutamisel.

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

Korda üle image_refs loendit ja looge lõuendile pilt, kasutades määratud nihet. Seadke ankur Loode suunas, et asetaksite pildi vasakpoolsesse ülanurka määratud koordinaatidele. Lisage need koordinaadid pildi_positsioonid nimekirja.

Värskendage x_nihe lisada pool kollaaži laiusest, valmistuda järgmise pildi paigutamiseks. Kui praegusele reale paigutatud piltide arv on määratud veergude arvu kordne, määrake x_nihe nullini. See näitab uue rea algust. Määramiseks lisage pool kollaaži kõrgusest y järgmise rea koordinaadid.

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

Kollaaži loomine ja salvestamine

Määratlege meetod, loo_kollaaž. Kui kollaažil pole pilte, kuvage hoiatus. Koguge kollaaži laius ja kõrgus. Loo padi Pilt valge taustaga. Korda läbi pilte loetlege ja kleepige iga pilt taustale määratud kohtadesse.

Salvestage kollaaž ja kuvage see vaikepildivaaturi abil.

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

Looge Tkinteri eksemplar ja Rakendus ImageCollage klass. The mainloop() funktsioon käsib Pythonil käivitada Tkinteri sündmusetsükli ja kuulata sündmusi, kuni sulgete akna.

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

Pildikollaažitegija erinevate funktsioonide testimine

Programmi käivitamisel kuvatakse kahe nupuga aken, Lisa piltja Loo kollaaž. Klõpsates Lisa pilt nuppu, küsib dialoogiboks kollaažide arvu. Kui sisestate piltide arvuks viis ja valite need, kuvatakse teine ​​dialoogiboks. See küsib ridade arvu, millele järgneb veergude arv.

Kahe rea ja kolme veeru sisestamisel korraldab aken pildid ruudustiku struktuuris.

Eelvaade annab võimaluse pilte vastavalt soovile lohistada. Klõpsates Loo kollaaž nuppu, salvestab programm pildi.

Pilti vaadates saate kinnitada, et programm lõi kollaaži edukalt.

Pildikollaažitegija funktsionaalsuse täiustamine

Tabelivormingu asemel saate kasutajale valida erinevaid vaikemalle. Lisage funktsioone taustavärvi muutmiseks, teksti lisamiseks, piltidele filtrite rakendamiseks ja Internetist kleebiste sisestamiseks.

Nende funktsioonide lisamise ajal muutke kollaaži redigeerimine hõlpsaks tagasivõtmis- või uuestitegemisvõimalusega. Laske kasutajal pilte vastavalt oma maitsele kärpida, suurust muuta ja ümber pöörata. Samuti peaksite lisama võimaluse pildi soovitud vormingus salvestada.