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. Ele oferece uma variedade de widgets que facilitam o desenvolvimento de GUIs.
A biblioteca Pillow – uma bifurcação da Python Imaging Library (PIL) – fornece recursos de processamento de imagens que ajudam na edição, criação, conversão de formatos de arquivo e salvamento de 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
Comece 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.Canvas() 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, ImageTkclass ImageCollageApp:
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 imageme 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("<ButtonPress-1>", self.on_press)
self.collage_canvas.bind("<B1-Motion>", self.on_drag)
self.collage_canvas.bind("<ButtonRelease-1>", 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.
def on_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.
def on_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.
def on_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.
def update_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.
def add_images(self):
num_images = simpledialog.askinteger(
"Number of Images", "Enter the number of images:"
) if num_images is not None:
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.
def resize_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.
def update_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.
def create_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 imageme 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.