Como fazer uma colagem de imagens usando Python

Uma colagem é uma bela maneira de mostrar memórias e conjuntos de imagens. Os criadores de colagens online podem ter preocupações de segurança e os aplicativos offline podem custar dinheiro e não ter os recursos necessários.

Ao construir seu próprio criador de colagens de imagens, você pode eliminar essas preocupações e manter o controle total. Então, como você pode construir um?

O Módulo Tkinter e PIL

Para construir um aplicativo de colagem de imagens você precisa do módulo Tkinter e PIL. Tkinter permite criar aplicativos de desktop. Oferece uma variedade de widgets que facilitam para desenvolver GUIs.

A biblioteca Pillow - um fork da Python Imaging Library (PIL) - fornece recursos de processamento de imagens que ajudam na edição, criação, convertendo formatos de arquivoe salvando imagens.

Para instalar o Tkinter e o Pillow, abra um terminal e execute:

pip install tk pillow

Configuração de GUI e manipulação de imagens

Você pode encontrar o código fonte deste projeto em seu Repositório GitHub.

Comece por importando os módulos necessários. Crie uma aula, ImageCollageAppe defina o título e as dimensões da janela. Defina uma tela usando tk. Tela() e defina seu elemento pai, largura, altura e cor de fundo.

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

Crie dois botões: Adicionar imagem, e Criar colagem. Defina o elemento pai, o texto a ser exibido, o comando a ser executado e os estilos de fonte. Organize os botões adicionando o preenchimento apropriado. Inicializar arrastar_dados para armazenar informações sobre a operação de arrastar.

Inicializar posições_imagem para armazenar as posições das imagens na tela. Defina três manipuladores de eventos para responder à seleção, arrastar e liberar imagens.

 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)

Defina um método, on_press. Recuperar o item de tela mais próximo do local onde o usuário clica com o mouse e armazená-lo sob o item chave do arrastar_dados dicionário. Armazene as coordenadas xey do clique do mouse. Você usará isso para calcular a distância que o usuário move o mouse durante o arrasto.

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

Defina um método, on_drag. Calcule a distância horizontal e vertical em que o usuário moveu o mouse durante o arrasto e atualize a posição da imagem de acordo. Armazene as coordenadas atualizadas da imagem sob o x e sim chaves do arrastar_dados dicionário.

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

Defina um método, on_release. Limpe a referência à imagem que o usuário estava arrastando junto com suas coordenadas. Ligar para update_image_positions para atualizar as posições de todas as imagens na tela após o usuário arrastá-las e soltá-las.

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

Defina um método, update_image_positions. Limpar o posições_imagem liste e itere sobre todos os itens da tela. Para cada item, encontre as coordenadas e adicione-as à lista.

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

Defina um método, Adicione imagens. Crie uma caixa de diálogo que solicita ao usuário que insira o número de imagens para a colagem. Se o usuário forneceu um número válido, abra uma caixa de diálogo de arquivo que permite apenas ao usuário selecionar arquivos de imagem. Depois que o usuário tiver selecionado uma ou mais imagens, abra cada uma delas com o Pillow's Imagem.open() método.

Ligar para Redimensionar imagem método e crie um compatível com Tkinter FotoImagem. Adicione isso ao imagem_refs liste e ligue para atualização_canvas método.

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

Defina um método, Redimensionar imagem. Obtenha a largura e a altura da imagem e calcule sua proporção. Se for mais de um, defina a nova largura como metade da largura da colagem. Calcule a nova altura correspondente, mantendo a proporção.

Se a proporção for menor que um, defina a nova altura como metade da altura da colagem. Da mesma forma, calcule a largura correspondente. Use travesseiros redimensionar método para retornar uma imagem redimensionada usando os parâmetros calculados.

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

Defina um método, atualização_canvas. Limpe todos os itens e peça ao usuário o número desejado de linhas e colunas por meio de uma caixa de diálogo de arquivo. Defina a largura e a altura da colagem para ocupar metade do tamanho especificado da colagem. Limpa a lista de posições de imagem. Inicializar x e sim deslocamento para zero, para que você possa acompanhar os deslocamentos de posição para organizar imagens em linhas e colunas.

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

Iterar sobre o imagem_refs list e crie uma imagem na tela usando o deslocamento especificado. Defina a âncora como Noroeste para posicionar o canto superior esquerdo da imagem nas coordenadas especificadas. Anexe essas coordenadas ao posições_imagem lista.

Atualize o x_offset para adicionar metade da largura da colagem, para preparar a colocação da próxima imagem. Se o número de imagens colocadas na linha atual for um múltiplo do número especificado de colunas, defina o x_offset para zero. Isso indica o início de uma nova linha. Adicione metade da altura da colagem para definir o sim coordenada para a próxima linha.

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

Criando a colagem e salvando-a

Defina um método, criar_colagem. Se não houver imagens na colagem, exiba um aviso. Colete a largura e a altura da colagem. Crie um travesseiro Imagem com fundo branco. Iterar através do imagens liste e cole cada imagem no fundo nas posições especificadas.

Salve a colagem e exiba-a usando o visualizador de imagens padrão.

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

Crie uma instância do Tkinter e Aplicativo ImageCollage aula. O loop principal() função diz ao Python para executar o loop de eventos Tkinter e ouvir eventos até você fechar a janela.

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

Testando diferentes recursos do Image Collage Maker

Ao executar o programa, aparece uma janela com dois botões, Adicionar imagem, e Criar colagem. Ao clicar no Adicionar imagem botão, uma caixa de diálogo pergunta o número de imagens a serem coladas. Ao inserir o número de imagens como cinco e selecioná-las, outra caixa de diálogo aparece. Ele pede o número de linhas seguido pelo número de colunas.

Ao inserir duas linhas e três colunas, a janela organiza as imagens em uma estrutura de grade.

A visualização permite arrastar as imagens conforme desejado. Ao clicar no Criar colagem botão, o programa salva a imagem.

Ao visualizar a imagem, você pode confirmar que o programa criou a colagem com sucesso.

Aprimorando a funcionalidade do Image Collage Maker

Em vez de um formato tabular, você pode fornecer diferentes modelos padrão para o usuário escolher. Adicione recursos para alterar a cor de fundo, adicionar texto, aplicar filtros em imagens e inserir adesivos da internet.

Ao adicionar esses recursos, facilite a edição da colagem com a opção de desfazer ou refazer. Deixe o usuário cortar, redimensionar e virar as imagens de acordo com sua preferência. Você também deve adicionar uma opção para salvar a imagem no formato desejado.