Hvordan lage en bildekollasje ved hjelp av Python

En collage er en vakker måte å vise fram minner og vise sett med bilder. Online collage-produsenter kan ha sikkerhetsproblemer, og offline-apper kan koste penger og mangle funksjonene du trenger.

Ved å bygge din egen bildekollasjeprodusent kan du eliminere disse bekymringene og beholde full kontroll. Så hvordan kan du bygge en?

Tkinter- og PIL-modulen

For å bygge en bildekollasjeapplikasjon trenger du Tkinter og PIL-modulen. Tkinter lar deg lage skrivebordsapplikasjoner. Den tilbyr en rekke widgets som gjør det enklere å utvikle GUIer.

Pillow-biblioteket – en gaffel fra Python Imaging Library (PIL) – gir bildebehandlingsfunksjoner som hjelper til med redigering, opprettelse, konvertere filformaterog lagre bilder.

For å installere Tkinter og Pillow, åpne en terminal og kjør:

pip install tk pillow

GUI-oppsett og bildemanipulering

Du kan finne dette prosjektets kildekode i sin GitHub-depot.

Begynn med importere de nødvendige modulene

. Lag en klasse, ImageCollageApp, og angi tittelen og dimensjonene til vinduet. Definer et lerret ved hjelp av tk. Lerret() og angi dets overordnede element, bredde, høyde og bakgrunnsfarge.

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

Lag to knapper: Legg til bilde, og Lag collage. Definer det overordnede elementet, teksten som skal vises, kommandoen som skal kjøres og skriftstilene. Organiser knappene ved å legge til passende polstring. Initialiser dra_data for å lagre informasjon om draoperasjonen.

Initialiser bildeposisjoner for å lagre posisjonene til bildene på lerretet. Definer tre hendelsesbehandlere for å svare på valg, dra og frigjøring av bilder.

 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 lerretselementet fra stedet der brukeren klikker med musen og lagre det under punkt nøkkelen til dra_data ordbok. Lagre x- og y-koordinatene til museklikket. Du vil bruke dette til å beregne avstanden brukeren beveger musen under dra.

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 horisontale og vertikale avstanden brukeren flyttet musen under dra og oppdater posisjonen til bildet tilsvarende. Lagre de oppdaterte koordinatene til bildet under x og y nøklene til dra_data ordbok.

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. Fjern referansen til bildet brukeren dro sammen med koordinatene. Ring update_image_positions for å oppdatere posisjonene til alle bildene på lerretet etter at brukeren drar 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. Fjern bildeposisjoner liste og iterer over alle lerretselementer. For hvert element finner du koordinatene og legger dem til i 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, add_images. Lag en dialogboks som ber brukeren angi antall bilder for collagen. Hvis brukeren oppga et gyldig nummer, åpner du en fildialogboks som bare lar brukeren velge bildefiler. Når brukeren har valgt ett eller flere bilder, åpner du hvert enkelt med Pillow's Image.open() metode.

Ring endre størrelse_bilde metode og lage en Tkinter-kompatibel PhotoImage. Legg dette til image_refs liste og ring 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, endre størrelse_bilde. Få bredden og høyden på bildet og beregn størrelsesforholdet. Hvis det er mer enn én, setter du den nye bredden til å være halvparten av collagens bredde. Beregn den tilsvarende nye høyden mens du opprettholder sideforholdet.

Hvis sideforholdet er mindre enn én, setter du den nye høyden til halvparten av collagens høyde. På samme måte beregner du den tilsvarende bredden. Bruk Pillow's endre størrelse metode for å returnere et bilde med endret størrelse ved å bruke de beregnede parameterne.

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. Fjern alle elementene og be brukeren om ønsket antall rader og kolonner via en fildialogboks. Still inn collagens bredde og høyde for å ta halvparten av den angitte collagestørrelsen. Tømmer listen over bildeposisjoner. Initialiser x og y offset til null, slik at du kan holde styr på posisjonsforskyvningene for å ordne bilder i rader 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

Iterere over image_refs liste og lag et bilde på lerretet ved å bruke den angitte forskyvningen. Sett ankeret til Nordvest slik at du plasserer bildets øverste venstre hjørne ved de angitte koordinatene. Legg disse koordinatene til bildeposisjoner liste.

Oppdater x_offset for å legge til halvparten av collagens bredde, for å forberede plassering av neste bilde. Hvis antall bilder plassert i gjeldende rad er et multiplum av det angitte antallet kolonner, angi x_offset til null. Dette indikerer starten på en ny rad. Legg til halvparten av collagens høyde for å angi y koordinat for neste rad.

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

Lage collagen og lagre den

Definer en metode, create_collage. Vis en advarsel hvis det ikke er noen bilder på collagen. Samle collagens bredde og høyde. Lag en pute Bilde med hvit bakgrunn. Iterer gjennom Bilder liste og lim inn hvert bilde på bakgrunnen på de angitte posisjonene.

Lagre collagen og vis den ved hjelp av standard bildeviser.

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

Opprett en forekomst av Tkinter og ImageCollage-appen klasse. De mainloop() funksjonen forteller Python å kjøre Tkinter-hendelsesløkken og lytte etter hendelser til du lukker vinduet.

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

Tester ulike funksjoner i Image Collage Maker

Når du kjører programmet, vises et vindu med to knapper, Legg til bilde, og Lag collage. Ved å klikke på Legg til bilde -knappen, spør en dialogboks om antall bilder som skal collages. Når du skriver inn antall bilder som fem og velger dem, vises en annen dialogboks. Den spør etter antall rader etterfulgt av antall kolonner.

Når du går inn i to rader og tre kolonner, organiserer vinduet bildene i en rutenettstruktur.

Forhåndsvisningen gir muligheten til å dra bildene etter ønske. Ved å klikke på Lag collage knappen, lagrer programmet bildet.

Når du ser på bildet, kan du bekrefte at programmet opprettet collagen vellykket.

Forbedre funksjonaliteten til Image Collage Maker

I stedet for et tabellformat kan du gi forskjellige standardmaler som brukeren kan velge mellom. Legg til funksjoner for å endre bakgrunnsfargen, legge til tekst, bruke filtre på bilder og sette inn klistremerker fra internett.

Mens du legger til disse funksjonene, gjør det enkelt å redigere collagen med et alternativ for å angre eller gjøre om. La brukeren beskjære, endre størrelse og snu bildene etter eget ønske. Du bør også legge til et alternativ for å lagre bildet i ønsket format.