Como construir um aplicativo Paint usando Python

Uma ferramenta de pintura simples é um dos aplicativos mais comuns que você pode encontrar na maioria dos computadores. Ele permite que o artista cometa erros sem medo, escolha qualquer cor com o clique de um botão e altere o tamanho das pinceladas instantaneamente. Você pode usá-lo para criar logotipos de marcas, conceituar interfaces de usuário e fazer anotações em diagramas.

Então, como você pode criar um aplicativo de pintura?

O Módulo Tkinter e Travesseiro

Para construir uma aplicação de pintura, você precisará dos módulos Tkinter e Pillow. Tkinter é um dos principais estruturas Python que você pode usar para personalizar sua GUI. É o módulo GUI padrão do Python para a criação de aplicativos de desktop. Tkinter vem com uma variedade de widgets como rótulo, entrada, tela e botão.

Pillow, um fork da Python Imaging Library (PIL), é um módulo de processamento de imagens para Python. Com o Pillow, você pode abrir, redimensionar, virar e cortar imagens. Você pode

converter formatos de arquivo, crie um aplicativo localizador de receitas e buscar imagens aleatórias.

Para instalar esses módulos, execute:

pip install tk pillow

Defina a estrutura da aplicação Paint

Você pode encontrar todo o código-fonte deste projeto neste Repositório GitHub.

Comece importando os módulos necessários. Defina uma classe, DrawApp. Defina o título, a cor do ponteiro e a cor da borracha. Faça o aplicativo abrir em tela cheia. Ligar para setup_widgets método.

import tkinter as tk
from tkinter.ttk import Scale
from tkinter import colorchooser, filedialog, messagebox
import PIL.ImageGrab as ImageGrab
classDrawApp:
def__init__(self, root):
 self.root = root
 self.root.title("Kids' Paint App")
 self.root.attributes("-fullscreen", True)
 self.pointer = "black"
 self.erase = "white"
 self.setup_widgets()

Defina um método chamado setup_widgets. Defina um rótulo que exiba um título. Defina o elemento pai, o texto que deseja exibir, o estilo da fonte, a cor de fundo e a cor do texto. Defina uma moldura para a paleta de cores. Defina o elemento pai, o texto que ele deve exibir, os estilos de fonte e a largura da borda. Defina a borda para ter uma aparência de crista e a cor de fundo como branca.

defsetup_widgets(self):
 self.title_label = tk.Label(
 self.root,
 text="Kids' Paint App",
 font=("Comic Sans MS", 30),
 bg="lightblue",
 fg="purple",
 )
 self.title_label.pack(fill=tk.X, pady=10)
 self.color_frame = tk.LabelFrame(
 self.root,
 text="Colors",
 font=("Comic Sans MS", 15),
 bd=5,
 relief=tk.RIDGE,
 bg="white",
 )
 self.color_frame.place(x=10, y=80, width=90, height=180)

Defina um conjunto de cores para a paleta de cores em uma lista. Itere sobre ele e crie um botão para cada um deles. Defina o elemento pai, a cor de fundo, a largura da borda e a aparência. Defina também a largura e o comando que cada botão deve executar quando clicado. Organize todos os elementos com preenchimento adequado e as cores em conjuntos de dois.

 colors = [
"blue",
"red",
"green",
"orange",
"violet",
"black",
"yellow",
"purple",
"pink",
"gold",
"brown",
"indigo",
 ]
 i, j = 0, 0
for color in colors:
 tk.Button(
 self.color_frame,
 bg=color,
 bd=2,
 relief=tk.RIDGE,
 width=3,
 command=lambda col=color: self.select_color(col),
 ).grid(row=i, column=j, padx=2, pady=2)
 i += 1
if i == 4:
 i = 0
 j = 1

Da mesma forma, defina um botão para a borracha, um para limpar a tela e outro para salvar a imagem.

 self.eraser_btn = tk.Button(
 self.root,
 text="Eraser",
 bd=4,
 bg="white",
 command=self.eraser,
 width=9,
 relief=tk.RIDGE,
 font=("Comic Sans MS", 12),
 )
 self.eraser_btn.place(x=10, y=310)
 self.clear_screen_btn = tk.Button(
 self.root,
 text="Clear Screen",
 bd=4,
 bg="white",
 command=self.clear_screen,
 width=12,
 relief=tk.RIDGE,
 font=("Comic Sans MS", 12),
 )
 self.clear_screen_btn.place(x=10, y=370)
 self.save_as_btn = tk.Button(
 self.root,
 text="Save Drawing",
 bd=4,
 bg="white",
 command=self.save_as,
 width=12,
 relief=tk.RIDGE,
 font=("Comic Sans MS", 12),
 )
 self.save_as_btn.place(x=10, y=430)
 self.bg_btn = tk.Button(
 self.root,
 text="Background",
 bd=4,
 bg="white",
 command=self.canvas_color,
 width=12,
 relief=tk.RIDGE,
 font=("Comic Sans MS", 12),
 )
 self.bg_btn.place(x=10, y=490)
 self.pointer_frame = tk.LabelFrame(
 self.root,
 text="Size",
 bd=5,
 bg="white",
 font=("Comic Sans MS", 15, "bold"),
 relief=tk.RIDGE,
 )

Defina um widget de escala para aumentar ou diminuir o tamanho do ponteiro ou borracha. Defina o elemento pai, a orientação, o intervalo e o comprimento em pixels. Defina uma tela e defina o elemento pai, a cor de fundo e a largura da borda. Além disso, defina o relevo para ter uma aparência de ranhura junto com sua altura e largura.

Posicione a tela com as coordenadas apropriadas e defina a âncora para Noroeste (canto superior esquerdo). Vincule o B1-Movimento para a função de pintura. B1 refere-se ao botão esquerdo do mouse pressionado e Movimento refere-se ao movimento. No geral, você o usa para rastrear o movimento do mouse enquanto pressiona o botão esquerdo.

 self.pointer_frame.place(x=10, y=580, height=150, width=70)
 self.pointer_size = Scale(
 self.pointer_frame, orient=tk.VERTICAL, from_=48, to=1, length=120
 )
 self.pointer_size.set(1)
 self.pointer_size.grid(row=0, column=1, padx=15)
 self.canvas = tk.Canvas(
 self.root, bg="white", bd=5, relief=tk.GROOVE, height=650, width=1300
 )
 self.canvas.place(x=160, y=120, anchor="nw")
 self.canvas.bind("", self.paint)

Defina os recursos do aplicativo Paint

Defina um método, pintar. Para pintar, o aplicativo desenhará continuamente formas ovais minúsculas. Subtraia 2 do x e sim coordenadas do evento do mouse para determinar o canto superior esquerdo do oval. Adicione 2 para determinar o canto inferior direito do oval. Crie uma forma oval usando essas coordenadas delimitadoras.

Defina a cor de preenchimento, a cor do contorno e a largura de acordo com a seleção do ponteiro.

defpaint(self, event):
 x1, y1 = (event.x - 2), (event.y - 2)
 x2, y2 = (event.x + 2), (event.y + 2)
 self.canvas.create_oval(
 x1,
 y1,
 x2,
 y2,
 fill=self.pointer,
 outline=self.pointer,
 width=self.pointer_size.get(),
 )

Defina três funções, selecione a cor, apagador, e, limpar tela. O selecione a cor O método pega uma cor e define o ponteiro de acordo. O apagador O método define o ponteiro para ter um efeito semelhante ao de uma borracha e faz com que ele desenhe linhas transparentes. O limpar tela método exclui todos os itens da tela.

defselect_color(self, col):
 self.pointer = col
deferaser(self):
 self.pointer = self.erase
defclear_screen(self):
 self.canvas.delete("all")

Defina um método, cor da tela. Abra um seletor de cores com todas as cores diferentes. Retorna uma tupla contendo a cor em RGB formato e formato hexadecimal. Se o usuário escolher uma cor, use o configurar método para definir a cor de fundo. Defina a cor da borracha igual à cor de fundo.

defcanvas_color(self):
 color = colorchooser.askcolor()
if color:
 self.canvas.configure(background=color[1])
 self.erase = color[1]

Defina um método, salvar como. Abra uma caixa de diálogo de arquivo solicitando ao usuário que escolha o nome e o caminho do arquivo. Se o usuário selecionar um caminho, use o Pillow's ImageGrab class para capturar a tela inteira. Corte a imagem usando as coordenadas especificadas para obter a região da tela. Experimente as coordenadas para pegar a parte desejada.

Salve este resultado no caminho de arquivo desejado. Exibe uma caixa de mensagem informando ao usuário que o programa salvou com sucesso a pintura como uma imagem. Em caso de algum erro, exibe o erro correspondente.

defsave_as(self):
 file_path = filedialog.asksaveasfilename(
 defaultextension=".jpg", filetypes=[("Image files", "*.jpg")]
 )
if file_path:
try:
 y = 148
 x = 200
 y1 = 978
 x1 = 1840
 ImageGrab.grab().crop((x, y, x1, y1)).save(file_path)
 messagebox.showinfo("Save Drawing", "Image file saved successfully!")
except Exception as e:
 messagebox.showerror("Error", f"Failed to save the image file: {e}")

Crie uma instância do Tk e a DrawApp 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 = DrawApp(root)
 root.mainloop()

Testando diferentes recursos de pintura usando Python

Ao executar o programa de pintura, você verá um aplicativo com uma paleta de cores, quatro botões, um controle deslizante e uma tela para pintar:

Clique em qualquer cor para selecioná-la. Você pode então desenhar na tela nessa cor com o botão esquerdo do mouse:

Ao clicar no Apagador botão e arrastando o controle deslizante verticalmente para cima, você selecionará a borracha e aumentará seu tamanho. Teste a borracha arrastando-a sobre o desenho para apagar os traços.

Quando você clica no Limpar tela botão, o programa limpa seu desenho anterior. Clique no Fundo botão para abrir uma paleta de cores e usá-lo para alterar a cor de fundo.

Ao clicar no Salvar desenho botão, uma caixa de diálogo de arquivo é aberta. Escolha um caminho e um nome para o arquivo e o programa o salvará.

Aprimorando a aplicação de tinta

Você pode aprimorar a funcionalidade do aplicativo de pintura adicionando uma opção para adicionar formas. Você pode dar a opção de selecionar o tipo de pincel e a opacidade. Adicione uma opção para adicionar texto e adesivos. Adicione uma opção para desfazer, refazer, redimensionar e inverter imagens. Isso tornará o processo de desenho muito mais suave.

Para criar formas, você pode usar métodos como create_rectangle, create_oval, create_line e create_polygon. Para adicionar texto e imagens, use os métodos create_text e create_image. Para redimensionar e inverter imagens, você pode usar os métodos de redimensionamento e transposição do Pillow.