Lär dig allt om bildhantering i Python med detta enkla men användbara verktyg som du kan bygga själv.

Ett collage är ett vackert sätt att visa upp minnen och visa uppsättningar av bilder. Onlinekollagetillverkare kan ha säkerhetsproblem och offlineappar kan kosta pengar och sakna de funktioner du behöver.

Genom att bygga din egen bildkollagetillverkare kan du eliminera dessa problem och behålla fullständig kontroll. Så, hur kan du bygga en?

Tkinter och PIL-modulen

För att bygga ett bildkollageprogram behöver du Tkinter och PIL-modulen. Tkinter låter dig skapa skrivbordsapplikationer. Den erbjuder en mängd olika widgets som gör det enklare att utveckla GUI.

Pillow-biblioteket – en gaffel från Python Imaging Library (PIL) – tillhandahåller bildbehandlingsfunktioner som hjälper till att redigera, skapa, konvertera filformatoch spara bilder.

För att installera Tkinter och Pillow, öppna en terminal och kör:

pip install tk pillow

GUI-inställning och bildbehandling

Du kan hitta detta projekts källkod i dess GitHub-förråd.

instagram viewer

Börja med importera de nödvändiga modulerna. Skapa en klass, ImageCollageApp, och ställ in fönstrets titel och mått. Definiera en duk med hjälp av tk. Duk() och ställ in dess överordnade element, bredd, höjd och bakgrundsfärg.

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

Skapa två knappar: Lägg till bild, och Skapa collage. Definiera det överordnade elementet, texten som ska visas, kommandot som ska köras och teckensnittsstilarna. Organisera knapparna genom att lägga till lämplig stoppning. Initiera dra_data för att lagra information om dragoperationen.

Initiera bildpositioner för att lagra bildernas positioner på duken. Definiera tre händelsehanterare för att svara på val, dragning och frisläppande 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)

Definiera en metod, on_press. Hämta det närmaste dukobjektet från den plats där användaren klickar med musen och lagra det under Artikel nyckeln till dra_data lexikon. Lagra x- och y-koordinaterna för musklicket. Du kommer att använda detta för att beräkna avståndet som användaren flyttar musen under att 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

Definiera en metod, on_drag. Beräkna det horisontella och vertikala avståndet som användaren flyttade musen under dragningen och uppdatera bildens position därefter. Lagra de uppdaterade koordinaterna för bilden under x och y nycklar till dra_data lexikon.

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

Definiera en metod, on_release. Rensa referensen till bilden som användaren drog tillsammans med dess koordinater. Ring update_image_positions för att uppdatera positionerna för alla bilder på duken efter att användaren har dragit och släppt den.

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

Definiera en metod, update_image_positions. Rensa bildpositioner lista och iterera över alla canvasobjekt. Hitta koordinaterna för varje objekt och lägg till dem i listan.

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

Definiera en metod, add_images. Skapa en dialogruta som uppmanar användaren att ange antalet bilder för kollaget. Om användaren har angett ett giltigt nummer, öppna en fildialogruta som endast låter användaren välja bildfiler. När användaren har valt en eller flera bilder, öppna var och en med Pillow's Image.open() metod.

Ring resize_image metod och skapa en Tkinter-kompatibel PhotoImage. Lägg till detta till image_refs lista och ring 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()

Definiera en metod, resize_image. Få bildens bredd och höjd och beräkna dess bildförhållande. Om det är mer än en, ställ in den nya bredden till hälften av collagets bredd. Beräkna motsvarande nya höjd med bibehållen bildförhållande.

Om bildförhållandet är mindre än ett ställer du in den nya höjden på hälften av collagets höjd. Beräkna på samma sätt motsvarande bredd. Använd kuddar ändra storlek metod för att returnera en storleksändrad bild med de beräknade parametrarna.

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

Definiera en metod, update_canvas. Rensa alla objekt och be användaren om önskat antal rader och kolumner via en fildialogruta. Ställ in collagets bredd och höjd för att ta hälften av den angivna collagestorleken. Rensar listan över bildpositioner. Initiera x och y offset till noll, så att du kan hålla reda på positionsoffseten för att ordna bilder i rader och kolumner.

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

Iterera över image_refs lista och skapa en bild på duken med den angivna offseten. Ställ in ankaret på nordväst så att du placerar bildens övre vänstra hörn vid de angivna koordinaterna. Lägg till dessa koordinater till bildpositioner lista.

Uppdatera x_offset för att lägga till hälften av collagets bredd, för att förbereda för att placera nästa bild. Om antalet bilder som placeras i den aktuella raden är en multipel av det angivna antalet kolumner, ställ in x_offset till noll. Detta indikerar början på en ny rad. Lägg till hälften av collagets höjd för att ställa in y koordinat för nästa 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

Skapa kollaget och spara det

Definiera en metod, skapa_kollage. Visa en varning om det inte finns några bilder på collaget. Samla kollagets bredd och höjd. Skapa en kudde Bild med vit bakgrund. Iterera genom bilder lista och klistra in varje bild på bakgrunden på de angivna platserna.

Spara kollaget och visa det med standardbildvisaren.

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

Skapa en instans av Tkinter och Appen ImageCollage klass. De mainloop() funktionen säger åt Python att köra Tkinter-händelsslingan och lyssna efter händelser tills du stänger fönstret.

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

Testar olika funktioner i Image Collage Maker

När programmet körs visas ett fönster med två knappar, Lägg till bild, och Skapa collage. När du klickar på Lägg till bild knappen, frågar en dialogruta hur många bilder som ska kollages. När du anger antalet bilder som fem och väljer dem, visas en annan dialogruta. Den frågar efter antalet rader följt av antalet kolumner.

När du går in i två rader och tre kolumner, organiserar fönstret bilderna i en rutnätsstruktur.

Förhandsgranskningen ger möjlighet att dra bilderna efter önskemål. När du klickar på Skapa collage knappen sparar programmet bilden.

När du tittar på bilden kan du bekräfta att programmet skapade collaget framgångsrikt.

Förbättra funktionaliteten hos Image Collage Maker

Istället för ett tabellformat kan du tillhandahålla olika standardmallar som användaren kan välja mellan. Lägg till funktioner för att ändra bakgrundsfärg, lägga till text, tillämpa filter på bilder och infoga klistermärken från internet.

När du lägger till dessa funktioner, gör det enkelt att redigera kollaget med ett alternativ att ångra eller göra om. Låt användaren beskära, ändra storlek och vända bilderna efter eget tycke. Du bör också lägga till ett alternativ för att spara bilden i önskat format.