Hur man bygger en färgapplikation med Python

Ett enkelt målarverktyg är en av de vanligaste apparna du kan hitta på de flesta datorer. Det låter konstnären göra misstag utan rädsla, välja vilken färg som helst med ett knapptryck och ändra storleken på sina penseldrag direkt. Du kan använda den för att skapa varumärkeslogotyper, konceptualisera användargränssnitt och kommentera diagram.

Så, hur kan du bygga en färgapplikation?

Tkinter och kuddmodulen

För att bygga en färgapplikation behöver du modulerna Tkinter och Pillow. Tkinter är en av de top Python-ramverk som du kan använda för att anpassa ditt GUI. Det är den vanliga Python GUI-modulen för att skapa skrivbordsapplikationer. Tkinter kommer med en mängd olika widgets som etikett, inmatning, canvas och knapp.

Pillow, en gaffel från Python Imaging Library (PIL), är en bildbehandlingsmodul för Python. Med Pillow kan du öppna, ändra storlek, vända och beskära bilder. Du kan konvertera filformat, bygga ett receptsökarprogram och hämta slumpmässiga bilder.

För att installera dessa moduler, kör:

pip install tk pillow

Definiera färgapplikationens struktur

Du kan hitta hela källkoden för detta projekt i denna GitHub-förråd.

Börja med att importera de nödvändiga modulerna. Definiera en klass, DrawApp. Ställ in titeln, pekarens färg och radergummifärgen. Gör applikationen öppen i helskärm. Ring setup_widgets metod.

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

Definiera en metod som kallas setup_widgets. Definiera en etikett som visar en rubrik. Ställ in det överordnade elementet, texten du vill visa, typsnittsstilen, bakgrundsfärgen och textfärgen. Definiera en ram för färgpaletten. Ställ in det överordnade elementet, texten det ska visa, teckensnittsstilarna och kantbredden. Ställ in gränsen så att den får ett åsliknande utseende och bakgrundsfärgen som vit.

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)

Definiera en uppsättning färger för färgpaletten i en lista. Iterera över det och skapa en knapp för var och en av dem. Ställ in det överordnade elementet, bakgrundsfärgen, kantbredden och utseendet. Ställ även in bredden och kommandot varje knapp ska köras när du klickar på den. Ordna alla element med lämplig stoppning och färgerna i set om två.

 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

På samma sätt definierar du en knapp för radergummit, en för att rensa skärmen och en för att spara bilden.

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

Definiera en skalningswidget för att öka eller minska storleken på pekaren eller radergummit. Ställ in det överordnade elementet, orienteringen, intervallet och längden i pixlar. Definiera en arbetsyta och ställ in det överordnade elementet, bakgrundsfärgen och kantbredden. Ställ också in reliefen så att den får ett spårutseende tillsammans med dess höjd och bredd.

Placera duken med lämpliga koordinater och placera ankaret mot nordväst (överst till vänster). Bind den B1-Motion till färgfunktionen. B1 hänvisar till vänster musknapp som hålls nere och Rörelse syftar på rörelsen. Sammantaget använder du den för att spåra musrörelser medan du trycker på vänster knapp.

 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)

Definiera funktionerna för färgapplikationen

Definiera en metod, måla. För att måla kommer appen kontinuerligt att rita minutovaler. Subtrahera 2 från x och y koordinaterna för mushändelsen för att bestämma det övre vänstra hörnet av ovalen. Lägg till 2 för att bestämma det nedre högra hörnet av ovalen. Skapa en oval med dessa avgränsande koordinater.

Ställ in fyllningsfärg, konturfärg och bredd enligt valet av pekaren.

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

Definiera tre funktioner, välj_färg, suddgummi, och, rensa skärmen. De välj_färg metoden tar en färg och ställer in pekaren därefter. De suddgummi metoden ställer in pekaren för att ha en radergummiliknande effekt och gör att den ritar genomskinliga linjer. De rensa skärmen metoden tar bort alla objekt på arbetsytan.

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

Definiera en metod, canvas_color. Öppna en färgväljare med alla olika färger. Lämna tillbaka en tuppel som innehåller färgen RGB format och hexadecimalt format. Om användaren väljer en färg, använd konfigurera metod för att ställa in bakgrundsfärgen. Ställ in färgen på radergummit till samma som bakgrundsfärgen.

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

Definiera en metod, spara som. Öppna en fildialogruta och ber användaren att välja filnamn och sökväg. Om användaren väljer en sökväg, använd Pillow's ImageGrab klass för att fånga hela skärmen. Beskär bilden med hjälp av de angivna koordinaterna för att få arbetsytan. Experimentera med koordinaterna för att ta tag i den önskade delen.

Spara detta resultat till önskad filsökväg. Visa en meddelanderuta som informerar användaren om att programmet har sparat färgen som en bild. I händelse av något fel visar den motsvarande fel.

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

Skapa en instans av Tk och den DrawApp 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 = DrawApp(root)
 root.mainloop()

Testar olika målningsfunktioner med Python

När du kör målarprogrammet ser du en app med en färgpalett, fyra knappar, ett skjutreglage och en duk att måla på:

Klicka på valfri färg för att välja den. Du kan sedan rita på duken i den färgen med vänster musknapp:

När du klickar på Suddgummi och dra reglaget vertikalt uppåt, väljer du radergummit och ökar dess storlek. Testa radergummit genom att dra det över din ritning för att radera strecken.

När du klickar på Rensa skärmen knappen rensar programmet din tidigare ritning. Klicka på Bakgrund knappen för att öppna en färgpalett och använda den för att ändra bakgrundsfärgen.

När du klickar på Spara ritning knappen öppnas en fildialogruta. Välj en sökväg och ett namn för filen, så sparar programmet den.

Förbättra färgapplikationen

Du kan förbättra färgapplikationens funktionalitet genom att lägga till ett alternativ för att lägga till former. Du kan ge ett alternativ för att välja borsttyp och opacitet. Lägg till ett alternativ för att lägga till text och klistermärken. Lägg till ett alternativ för att ångra, göra om, ändra storlek och vända bilder. Detta kommer att göra ritprocessen mycket smidigare.

För att skapa former kan du använda metoder som create_rectangle, create_oval, create_line och create_polygon. För att lägga till text och bilder, använd metoden create_text och create_image. För att ändra storlek och vända bilder kan du använda Pillows storleksändrings- och transponeringsmetoder.