Jak vytvořit obrázkovou koláž pomocí Pythonu

Koláž je krásný způsob, jak předvést vzpomínky a zobrazit sady obrázků. Tvůrci online koláží mohou mít obavy o bezpečnost a offline aplikace mohou stát peníze a postrádat funkce, které požadujete.

Sestavením vlastního tvůrce obrazových koláží můžete tyto obavy odstranit a zachovat si úplnou kontrolu. Jak si ho tedy můžete postavit?

Modul Tkinter a PIL

K vytvoření aplikace pro koláž obrázků potřebujete Tkinter a modul PIL. Tkinter vám umožňuje vytvářet desktopové aplikace. Nabízí celou řadu widgetů, které to usnadňují k vývoji GUI.

Knihovna Pillow – rozvětvení knihovny Python Imaging Library (PIL) – poskytuje možnosti zpracování obrázků, které pomáhají při úpravách, vytváření, převod formátů souborůa ukládání obrázků.

Chcete-li nainstalovat Tkinter a Pillow, otevřete terminál a spusťte:

pip install tk pillow

Nastavení GUI a manipulace s obrázky

Zdrojový kód tohoto projektu najdete v něm úložiště GitHub.

Začněte tím import požadovaných modulů. Vytvořte třídu, ImageCollageAppa nastavte nadpis a rozměry okna. Definujte plátno pomocí tk. Plátno() a nastavte jeho nadřazený prvek, šířku, výšku a barvu pozadí.

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

Vytvořte dvě tlačítka: Přidat obrázek, a Vytvořit koláž. Definujte nadřazený prvek, text, který se má zobrazit, příkaz ke spuštění a styly písma. Uspořádejte tlačítka přidáním vhodného odsazení. Inicializovat drag_data pro uložení informací o operaci přetažení.

Inicializovat image_positions pro uložení pozic obrázků na plátně. Definujte tři manipulátory událostí, které budou reagovat na výběr, přetažení a uvolnění obrázků.

 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)

Definujte metodu, on_press. Načtěte nejbližší položku plátna z místa, kde uživatel klikne myší, a uložte ji pod položka klíč od drag_data slovník. Uložte souřadnice x a y kliknutí myší. Toto použijete k výpočtu vzdálenosti, o kterou uživatel pohybuje myší během tažení.

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

Definujte metodu, on_drag. Vypočítejte vodorovnou a svislou vzdálenost, o kterou uživatel pohyboval myší během přetahování, a podle toho aktualizujte polohu obrázku. Uložte aktualizované souřadnice obrázku pod X a y klíče od drag_data slovník.

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

Definujte metodu, on_release. Vymažte odkaz na obrázek, který uživatel přetáhl, spolu s jeho souřadnicemi. Zavolej update_image_positions k aktualizaci pozic všech obrázků na plátně poté, co jej uživatel přetáhne a uvolní.

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

Definujte metodu, update_image_positions. Vyčistěte image_positions seznam a iteraci přes všechny položky plátna. U každé položky najděte souřadnice a přidejte je do seznamu.

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

Definujte metodu, přidat_obrázky. Vytvořte dialogové okno, které uživatele vyzve k zadání počtu obrázků pro koláž. Pokud uživatel zadal platné číslo, otevřete dialogové okno souboru, které uživateli umožňuje pouze vybrat obrazové soubory. Jakmile uživatel vybere jeden nebo více obrázků, otevřete každý z nich pomocí Pillow's Image.open() metoda.

Zavolej změnit velikost_obrázku a vytvořit Tkinter kompatibilní PhotoImage. Přidejte toto do image_refs seznam a zavolejte update_canvas metoda.

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

Definujte metodu, změnit velikost_obrázku. Získejte šířku a výšku obrázku a vypočítejte jeho poměr stran. Pokud je více než jedna, nastavte novou šířku na polovinu šířky koláže. Vypočítejte odpovídající novou výšku při zachování poměru stran.

Pokud je poměr stran menší než jedna, nastavte novou výšku na polovinu výšky koláže. Podobně vypočítejte odpovídající šířku. Použijte polštáře změnit velikost metoda pro vrácení obrázku se změněnou velikostí pomocí vypočítaných parametrů.

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

Definujte metodu, update_canvas. Vymažte všechny položky a požádejte uživatele o požadovaný počet řádků a sloupců prostřednictvím dialogového okna souboru. Nastavte šířku a výšku koláže tak, aby zabírala polovinu zadané velikosti koláže. Vymaže seznam pozic obrazu. Inicializovat X a y offset na nulu, takže můžete sledovat posuny pozic pro uspořádání obrázků do řádků a sloupců.

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

Iterujte přes image_refs seznam a vytvořte obraz na plátně pomocí zadaného odsazení. Nastavte kotvu na Severozápad, abyste umístili levý horní roh obrázku na určené souřadnice. Připojte tyto souřadnice k image_positions seznam.

Aktualizujte x_offset přidat polovinu šířky koláže, připravit se na umístění dalšího obrázku. Pokud je počet obrázků umístěných v aktuálním řádku násobkem zadaného počtu sloupců, nastavte x_offset na nulu. Označuje začátek nového řádku. Pro nastavení přidejte polovinu výšky koláže y souřadnice pro další řádek.

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

Vytvoření koláže a její uložení

Definujte metodu, vytvořit_koláž. Pokud na koláži nejsou žádné obrázky, zobrazte varování. Sbírejte šířku a výšku koláže. Vytvořte si polštář obraz s bílým pozadím. Iterujte přes snímky vypsat a vložit každý obrázek na pozadí na zadaná místa.

Uložte koláž a zobrazte ji pomocí výchozího prohlížeče obrázků.

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

Vytvořte instanci Tkinter a Aplikace ImageCollage třída. The mainloop() Funkce říká Pythonu, aby spustil smyčku událostí Tkinter a naslouchal událostem, dokud nezavřete okno.

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

Testování různých funkcí Image Collage Maker

Po spuštění programu se zobrazí okno se dvěma tlačítky, Přidat obrázek, a Vytvořit koláž. Po kliknutí na Přidat obrázek Zobrazí se dialogové okno s dotazem na počet obrázků ke koláži. Po zadání počtu snímků jako pět a jejich výběru se zobrazí další dialogové okno. Ptá se na počet řádků následovaný počtem sloupců.

Po zadání dvou řádků a tří sloupců okno uspořádá obrázky do mřížkové struktury.

Náhled dává možnost přetahovat obrázky podle potřeby. Po kliknutí na Vytvořit koláž tlačítko, program obrázek uloží.

Při prohlížení obrázku můžete potvrdit, že program úspěšně vytvořil koláž.

Vylepšení funkčnosti Image Collage Maker

Namísto tabulkového formátu můžete uživateli poskytnout různé výchozí šablony, ze kterých si může vybrat. Přidejte funkce pro změnu barvy pozadí, přidání textu, použití filtrů na obrázky a vkládání nálepek z internetu.

Při přidávání těchto funkcí usnadněte úpravy koláže s možností vrátit zpět nebo opakovat. Nechte uživatele oříznout, změnit velikost a převrátit obrázky podle svých představ. Měli byste také přidat možnost uložit obrázek v požadovaném formátu.