Hur man bygger en målarapplikation 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 en knapptryckning 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.
På vilket sätt kan man konstruera ett målarprogram?
Tkinter- och Pillow-modulen
För att kunna utveckla ett målningsprogram med Python måste både Tkinter- och Pillow-modulerna vara installerade i systemet. Tkinter-ramverket är ett av de mest populära valen när det gäller att utforma grafiska användargränssnitt (GUI) för Python-baserade skrivbordsapplikationer. Ramverket innehåller ett brett utbud av inbyggda widgetar som etiketter, textrutor, dukar och knappar som gör det möjligt för utvecklare att snabbt och enkelt skapa visuellt tilltalande och interaktiva gränssnitt.
Pillow, ett derivat av det anrika Python Imaging Library (PIL), fungerar som en mångsidig verktygslåda för bildbehandling i Python-applikationer. Med hjälp av dess funktioner kan användarna enkelt utföra olika operationer på digitala visuella media, t.ex. öppna, ändra storlek, rotera och beskära bilder. Dessutom underlättar detta bibliotek formatkonvertering, möjliggör utveckling av komplexa algoritmer som receptrekommendationssystem och ger funktionalitet för att slumpmässigt hämta bilder från en databas.
För att installera dessa moduler, kör:
pip install tk pillow
Definiera strukturen för Paint-applikationen
Den fullständiga källkoden för detta projekt finns tillgänglig i vårtGitHub-arkiv, som du kan nå genom att navigera till den ovan nämnda URL-adressen.
För att komma igång kommer vi att importera de nödvändiga modulerna. Därefter skapar vi en instans av klassen DrawApp och ställer in dess egenskaper, t.ex. fönstrets titel, pekarens färg och suddgummiets färg. Vi kommer också att se till att programmet öppnas i helskärmsläge genom att anropa metoden setup_widgets() .
import tkinter as tk
from tkinter.ttk import Scale
from tkinter import colorchooser, filedialog, messagebox
import PIL.ImageGrab as ImageGrab
class DrawApp:
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()
För att skapa ett gränssnitt med widgets skapar du en funktion med namnet setup_widgets . Inom denna funktion genererar du en märkt komponent som visar en titel genom att ange dess föräldraförhållande, meddelandet som ska visas, typsnittskonfigurationen, bakgrundsskärmen och textinnehållets nyans. Dessutom kan du skapa ett ramverk kring en färgvalspanel genom att tilldela ansvarsområden som att definiera föräldraelementet, inskriptionen som ska visas, typsnittsinställningarna och kantdimensionerna.Slutligen konfigurerar du gränsen med en serie böljningar och ställer in bakgrundstonen till att vara vit.
def setup_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)
Skapa en lista för att definiera en uppsättning färger för färgpaletten. Använd iteration för att generera en knapp för varje nyans, med hänsyn till dess motsvarande RGB-värde. Ange överordnad behållare, bakgrundsnyans, kanttjocklek, stilegenskaper och bredd för varje knapp. Ange också vilken åtgärd som ska utföras när du klickar på varje knapp. Arrangera alla komponenter med lämpliga marginaler och organisera färgerna i par.
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å liknande sätt kan vi avgränsa knappar för suddgummit, en för att rengöra displayen och en annan för att bevara illustrationen.
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,
)
För att skapa en anpassad Scale-widget som kan justera storleken på både pekaren och suddgummit inom ett angivet intervall och pixellängd, är det nödvändigt att definiera en Scale-widget. Denna widget bör ges ett överordnat element, en orientering och ett intervall i pixlar, samt en längd för skjutreglaget. Dessutom skulle det vara bra att inkludera ett Canvas-element med en egen förälder, bakgrundsfärg, kantbredd och en räfflad relief med specifika mått.
Placera Canvas vid lämpliga koordinater och konfigurera dess förankring i det nordvästra hörnet (den övre vänstra kanten). Koppla därefter händelsehanteraren B1-Motion till den utvalda målningsfunktionen. I detta sammanhang betyder “B1” att vänster musknapp är nedtryckt, medan “Motion” betyder den efterföljande rörelsen som följer av användarens inmatning. Genom att använda denna konfiguration kan man övervaka musrörelser när den vänstra knappen trycks ned kontinuerligt.
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("<B1-Motion>", self.paint)
Definiera funktionerna i Paint-applikationen
För att utföra målningsprocessen i vår applikation har vi implementerat en metod som heter “paint”. Denna metod innebär kontinuerlig ritning av små elliptiska former på skärmen. För att uppnå detta beräknar vi det övre vänstra hörnet av varje ellips genom att subtrahera två från både X- och Y-koordinaterna för den senaste mushändelsen. Omvänt bestäms det nedre högra hörnet genom att lägga till två till respektive värden för X och Y. I slutändan definierar dessa gränser formen på den ellips som kommer att skapas för varje efterföljande bildruta tills vidare.
Justera fyllnadsfärg, konturfärg och linjetjocklek enligt användarens val för markören.
def paint(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(),
)
select_color , eraser , och clear_screen .Var och en av dessa metoder har sitt eget unika syfte när det gäller att manipulera utseendet och innehållet i duken. select_color funktionen accepterar ett enda argument som representerar ett specifikt färgvärde, som sedan används för att ställa in den aktuella färgen som pekaren ritar. Detta gör det enkelt att välja olika färger efter behov.pythondef select_color(self, color):self.selected_color = colorNäst har vi funktionen eraser , som också bara kräver en inmatningsparameter. Den är ansvarig för att skapa en “suddgummi”-effekt när du ritar på duken, vilket resulterar i halvgenomskinliga linjer som blandas
def select_color(self, col):
self.pointer = col
def eraser(self):
self.pointer = self.erase
def clear_screen(self):
self.canvas.delete("all")
Införliva funktionaliteten som tillhandahålls av metoden canvas_color i klassen TurtleScreen så att den öppnar en färgväljare som visar olika nyanser för val av användaren. När ett val har gjorts använder du metoden configure för att fastställa bakgrundsfärgen på duken och därefter tillämpa denna färg på suddgummiets utseende.
def canvas_color(self):
color = colorchooser.askcolor()
if color:
self.canvas.configure(background=color[1])
self.erase = color[1]
Inkorporera de angivna stegen i ett elegant engelskt svar:“Definiera en metod som heter ‘save\_as’, som uppmanar användaren att välja ett filnamn och en plats för att spara den tagna skärmdumpen. Använd Pillows ImageGrab-klass för att fånga hela skärmen genom att presentera en fildialogruta. Använd beskärningstekniker med hjälp av de angivna koordinaterna för att få önskad canvasregion. Justera koordinaterna iterativt efter behov för att uppnå det specifika intresseområdet.
Visst! Här är mitt försök att omformulera din kod till ett mer formellt språk:pythondef save_image(filepath):try:p = PILImage.create(filename=filepath)if isinstance(p, ImageGrab.InvalidGrab):raise Exception(“Det gick inte att ladda bilden”)# Spara bilden och visa ett bekräftelsemeddelande boxp.save(str(filepath))tkinter.messagebox.showinfo(‘Success’, ‘Bilden har sparats’)except Exception as e:# Hantera undantag och visa ett felmeddelande boxtkinter.messagebox.showerror(‘Error’, str(e))
def save_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}")
Utnyttja funktionerna i modulen Tkinter genom att instansiera instanser av både klasserna Tk och DrawApp, samtidigt som du utnyttjar funktionerna i metoden mainloop för att starta händelseslingan i Tkinter och kontinuerligt övervaka användarnas interaktion med det grafiska gränssnittet tills det stängs.
if __name__ == "__main__":
root = tk.Tk()
app = DrawApp(root)
root.mainloop()
Testa olika målningsfunktioner med Python
När Paint-programmet körs visas ett grafiskt användargränssnitt med ett verktyg för färgval, fyra funktionstangenter, en skjutbar justeringskontroll och en tom dukyta där användaren kan skapa konstverk:
Välj en nyans genom att klicka på den och använd sedan musens vänsterklick för att skapa konstverk i den valda nyansen på dukytan:
Genom att klicka på alternativet “Eraser” och skjuta det vertikala reglaget uppåt kan man välja att förstora suddgummiverktyget. För att testa funktionen kan du rita med den valda penseln och sedan använda radergummit för att ta bort linjerna från ditt konstverk.
När du klickar på alternativet “Clear Screen” kommer programmet att radera alla tidigare utförda konstverk. För att ändra färgen på bakgrunden klickar du på fliken “Bakgrund”, som visar ett spektrum av färger som du kan välja mellan.
När du väljer alternativet “Spara ritning” visas ett fönster där du kan välja en önskad plats och tilldela en titel till den sparade filen. Programvaran lagrar sedan filen automatiskt i den angivna katalogen.
Förbättra målningsprogrammet
För att göra målningsprogrammet mer mångsidigt rekommenderas att en funktion implementeras som gör det möjligt för användare att införliva geometriska former i sina konstverk. Om man dessutom tillhandahöll alternativ för att välja penselstil och transparensinställningar skulle programmets kapacitet utökas ytterligare. Att integrera en funktion som gör det möjligt att infoga text och grafiska klistermärken kan dessutom visa sig fördelaktigt för att utöka omfattningen av potentiella skapelser. Slutligen skulle inkorporering av funktioner som möjligheten att ångra, göra om, skala eller rotera bilder avsevärt effektivisera den övergripande ritprocessen.
För att generera olika visuella element är det möjligt att använda en mängd olika tekniker med hjälp av metoderna create\_rectangle, create\_oval, create\_line och create\_polygon. För att integrera skriftligt innehåll eller bilder kan man dessutom använda funktionerna create\_text och create\_image. Om så önskas kan Pillows funktioner resize och transpose användas för att ändra bildernas storlek och orientering.