Sådan laver du en billedcollage ved hjælp af Python

En collage er en smuk måde at fremvise minder og vise sæt billeder. Online collageproducenter kan have sikkerhedsproblemer, og offline apps kan koste penge og mangle de funktioner, du har brug for.

Ved at bygge din egen billedcollageproducent kan du fjerne disse bekymringer og bevare fuld kontrol. Så hvordan kan du bygge en?

Tkinter- og PIL-modulet

For at bygge en billedcollage-applikation skal du bruge Tkinter og PIL-modulet. Tkinter giver dig mulighed for at oprette desktop-applikationer. Det tilbyder en række forskellige widgets, der gør det nemmere at udvikle GUI'er.

Pillow-biblioteket – en forgrening af Python Imaging Library (PIL) – giver billedbehandlingsfunktioner, der hjælper med at redigere, skabe, konvertering af filformaterog gemme billeder.

For at installere Tkinter og Pillow skal du åbne en terminal og køre:

pip install tk pillow

GUI-opsætning og billedmanipulation

Du kan finde dette projekts kildekode i dens GitHub-depot.

Begynd med importere de nødvendige moduler. Opret en klasse, ImageCollageApp, og indstil vinduets titel og dimensioner. Definer et lærred vha tk. Lærred() og indstil dets overordnede element, bredde, højde og baggrundsfarve.

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

Opret to knapper: Tilføj billede, og Opret collage. Definer det overordnede element, teksten der skal vises, kommandoen der skal køres og skrifttypestilene. Organiser knapperne ved at tilføje passende polstring. Initialiser træk_data for at gemme information om trækoperationen.

Initialiser billedpositioner for at gemme billedernes positioner på lærredet. Definer tre hændelseshandlere til at reagere på valg, træk og frigivelse af billeder.

 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)

Definer en metode, on_press. Hent det nærmeste lærredselement fra det sted, hvor brugeren klikker med musen, og gem det under vare nøglen til træk_data ordbog. Gem x- og y-koordinaterne for museklikket. Du vil bruge dette til at beregne afstanden, som brugeren bevæger musen under træk.

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

Definer en metode, on_drag. Beregn den vandrette og lodrette afstand, som brugeren bevægede musen under træk, og opdater billedets position i overensstemmelse hermed. Gem de opdaterede koordinater for billedet under x og y nøgler til træk_data ordbog.

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

Definer en metode, on_release. Ryd referencen til det billede, som brugeren trak sammen med dets koordinater. Ring til update_image_positions for at opdatere placeringen af ​​alle billeder på lærredet, efter at brugeren trækker og slipper det.

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

Definer en metode, update_image_positions. Ryd billedpositioner liste og gentag over alle lærredsgenstande. For hvert element skal du finde koordinaterne og tilføje dem til listen.

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

Definer en metode, tilføje_billeder. Opret en dialogboks, der beder brugeren om at indtaste antallet af billeder til collagen. Hvis brugeren har angivet et gyldigt nummer, skal du åbne en fildialogboks, der kun tillader brugeren at vælge billedfiler. Når brugeren har valgt et eller flere billeder, åbnes hvert enkelt med Pillow's Image.open() metode.

Ring til resize_image metode og opret en Tkinter-kompatibel PhotoImage. Tilføj dette til image_refs liste og ring til update_canvas metode.

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

Definer en metode, resize_image. Få billedets bredde og højde, og beregn dets billedformat. Hvis det er mere end én, skal du indstille den nye bredde til at være halvdelen af ​​collagens bredde. Beregn den tilsvarende nye højde, mens billedformatet bevares.

Hvis billedformatet er mindre end én, skal du indstille den nye højde til at være halvdelen af ​​collagens højde. På samme måde beregnes den tilsvarende bredde. Brug puder ændre størrelse metode til at returnere et ændret størrelse billede ved hjælp af de beregnede parametre.

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

Definer en metode, update_canvas. Ryd alle elementer og spørg brugeren om det ønskede antal rækker og kolonner via en fildialogboks. Indstil collagens bredde og højde til at tage halvdelen af ​​den angivne collagestørrelse. Rydder listen over billedpositioner. Initialiser x og y offset til nul, så du kan holde styr på positionsforskydningerne for at arrangere billeder i rækker og kolonner.

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

Gentag over image_refs liste og opret et billede på lærredet ved hjælp af den angivne offset. Indstil ankeret til Nordvest, så du placerer billedets øverste venstre hjørne ved de angivne koordinater. Føj disse koordinater til billedpositioner liste.

Opdater x_offset at tilføje halvdelen af ​​collagens bredde, for at forberede placeringen af ​​det næste billede. Hvis antallet af billeder placeret i den aktuelle række er et multiplum af det angivne antal kolonner, skal du indstille x_offset til nul. Dette angiver starten på en ny række. Tilføj halvdelen af ​​collagens højde for at indstille y koordinat til næste række.

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

Oprettelse af collagen og lagring af den

Definer en metode, skabe_collage. Vis en advarsel, hvis der ikke er nogen billeder på collagen. Saml collagens bredde og højde. Lav en pude Billede med hvid baggrund. Gentag gennem billeder liste og indsæt hvert billede på baggrunden på de angivne positioner.

Gem collagen og vis den ved hjælp af standard billedfremviser.

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

Opret en instans af Tkinter og ImageCollage app klasse. Det mainloop() funktion fortæller Python at køre Tkinter-hændelsesløkken og lytte efter hændelser, indtil du lukker vinduet.

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

Test af forskellige funktioner i Image Collage Maker

Når du kører programmet, vises et vindue med to knapper, Tilføj billede, og Opret collage. Ved at klikke på Tilføj billede knappen, spørger en dialogboks antallet af billeder til collage. Når du indtaster antallet af billeder som fem og vælger dem, vises en anden dialogboks. Den beder om antallet af rækker efterfulgt af antallet af kolonner.

Når du indtaster to rækker og tre kolonner, organiserer vinduet billederne i en gitterstruktur.

Forhåndsvisningen giver mulighed for at trække billederne efter ønske. Ved at klikke på Opret collage knappen, gemmer programmet billedet.

Når du ser billedet, kan du bekræfte, at programmet oprettede collagen med succes.

Forbedring af funktionaliteten af ​​Image Collage Maker

I stedet for et tabelformat kan du angive forskellige standardskabeloner, som brugeren kan vælge imellem. Tilføj funktioner til at ændre baggrundsfarven, tilføje tekst, anvende filtre på billeder og indsætte klistermærker fra internettet.

Mens du tilføjer disse funktioner, skal du gøre det nemt at redigere collagen med en mulighed for at fortryde eller gentage. Lad brugeren beskære, ændre størrelsen og vende billederne efter deres smag. Du bør også tilføje en mulighed for at gemme billedet i det ønskede format.