Bildbetrachter mit Python und Tkinter

Einführung

In diesem Projekt werden wir eine Bildbetrachteranwendung mit Python und Tkinter erstellen. Der Bildbetrachter ermöglicht es Ihnen, eine Bilddatei zu öffnen, anzuzeigen und Aktionen wie das Vergrößern, Verkleinern und Drehen des Bilds auszuführen. Wir werden die PIL (Python Imaging Library)-Bibliothek verwenden, um Bildoperationen zu verarbeiten, und Tkinter, um die grafische Benutzeroberfläche zu erstellen.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt lernen Sie:

• Wie man eine GUI-Anwendung mit Tkinter erstellt.
• Wie man das Laden und Anzeigen von Bildern mit PIL behandelt.
• Wie man die Funktionalität zum Vergrößern, Verkleinern und Drehen des angezeigten Bilds implementiert.

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

• Eine funktionierende Bildbetrachteranwendung mit Python und Tkinter zu entwickeln.
• Die Fähigkeiten der Bildverarbeitung mit der PIL-Bibliothek zu integrieren.
• Grundlegende Bildmanipulationsfunktionen wie das Vergrößern und Drehen umzusetzen.

Erstellen der Projekt-Dateien

Erstellen Sie zunächst eine neue Datei mit dem Namen ~/project/image_viewer.py und öffnen Sie sie in einem Texteditor oder einer integrierten Entwicklungsumgebung (IDE).

cd ~/project
touch image_viewer.py

Importieren der erforderlichen Bibliotheken

In der Datei image_viewer.py importieren Sie die erforderlichen Bibliotheken:

import tkinter as tk
from tkinter import filedialog
from tkinter import messagebox
from PIL import Image, ImageTk
import os

Die tkinter-Bibliothek bietet die Funktionalität zum Erstellen von GUI-Elementen, filedialog ermöglicht es uns, einen Dateidialog zum Auswählen einer Bilddatei zu öffnen, messagebox wird verwendet, um Nachrichten an den Benutzer anzuzeigen, PIL wird für die Bildverarbeitung verwendet und os liefert Funktionen zum Interagieren mit dem Betriebssystem.

Erstellen der ImageViewer-Klasse

Definieren Sie eine neue Klasse namens ImageViewer, die die Bildbetrachteranwendung verwalten wird:

class ImageViewer:
    def __init__(self, root):
        self.root = root
        self.root.title('LabEx Image Viewer')
        self.root.geometry('800x600')
        self.root.configure(background='white')

        self.image_label = tk.Label(self.root)
        self.image_label.pack()

        self.control_frame = tk.Frame(self.root)
        self.control_frame.pack()

        self.open_button = tk.Button(self.control_frame, text='Open', command=self.open_image)
        self.open_button.pack(side='left')

        self.close_button = tk.Button(self.control_frame, text='Quit', command=self.root.quit)
        self.close_button.pack(side='left')

        self.zoom_in_button = tk.Button(self.control_frame, text='Zoom In', command=self.zoom_in)
        self.zoom_in_button.pack(side='left')

        self.zoom_out_button = tk.Button(self.control_frame, text='Zoom Out', command=self.zoom_out)
        self.zoom_out_button.pack(side='left')

        self.rotate_button = tk.Button(self.control_frame, text='Rotate', command=self.rotate)
        self.rotate_button.pack(side='left')

        self.current_image_path = ''
        self.zoom_level = 1

In der __init__-Methode initialisieren wir das Hauptfenster mit einem Titel, einer Größe und einer Hintergrundfarbe. Anschließend erstellen wir ein Label, um das Bild anzuzeigen, und einen Rahmen, um die Steuertasten (Open, Quit, Zoom In, Zoom Out, Rotate) zu halten. Wir definieren auch Instanzvariablen, um den aktuellen Bildpfad und das Zoomlevel zu verfolgen.

Implementieren der open_image-Methode

Fügen Sie die open_image-Methode zur ImageViewer-Klasse hinzu:

    def open_image(self):
        self.current_image_path = filedialog.askopenfilename(defaultextension=".jpg",
            filetypes=[("All Files", "*.*"), ("JPEG", ".jpg"), ("PNG", ".png"), ("GIF", ".gif")])
        if self.current_image_path:
            self.load_image()

Die open_image-Methode öffnet einen Dateidialog zum Auswählen einer Bilddatei. Sie setzt die Variable current_image_path auf den ausgewählten Dateipfad und ruft die load_image-Methode auf, um das Bild anzuzeigen.

Implementieren der load_image-Methode

Implementieren Sie die load_image-Methode:

    def load_image(self):
        image = Image.open(self.current_image_path)

        ## Resize image for display
        max_size = (600, 600)
        image.thumbnail(max_size)

        ## Save a reference to the original image (for zooming/rotating)
        self.original_image = image

        ## Create a Tkinter-compatible image
        self.tk_image = ImageTk.PhotoImage(image)
        self.image_label.configure(image=self.tk_image)

        self.zoom_level = 1

Die load_image-Methode öffnet die ausgewählte Bilddatei mit der Image.open-Methode von PIL. Sie verkleinert das Bild, um es in eine maximale Größe von 600x600 Pixeln zu passen, indem sie die thumbnail-Methode verwendet. Anschließend speichert sie einen Verweis auf das ursprüngliche Bild für das Zoomen und Rotieren. Danach erstellt sie ein mit Tkinter kompatibles Bild mit ImageTk.PhotoImage und aktualisiert das Bildlabel, um das geladene Bild anzuzeigen. Schließlich setzt sie das Anfangs-Zoomlevel auf 1.

Implementieren der zoom_in-Methode

Implementieren Sie die zoom_in-Methode:

    def zoom_in(self):
        if not self.current_image_path:  ## No image loaded
            return
        self.zoom_level *= 1.1  ## Increase zoom level by 10%
        self.zoom_or_rotate_image()

Die zoom_in-Methode überprüft, ob ein Bild geladen ist. Wenn kein Bild geladen ist, wird sie beendet. Andernfalls erhöht sie das Zoomlevel um 10% und ruft die zoom_or_rotate_image-Methode auf, um das angezeigte Bild zu aktualisieren.

Implementieren der zoom_out-Methode

Implementieren Sie die zoom_out-Methode:

    def zoom_out(self):
        if not self.current_image_path:  ## No image loaded
            return
        if self.zoom_level < 0.1:  ## Limit outwards zoom
            return
        self.zoom_level *= 0.9  ## Decrease zoom level by 10%
        self.zoom_or_rotate_image()

Die zoom_out-Methode überprüft, ob ein Bild geladen ist. Wenn kein Bild geladen ist, wird sie beendet. Wenn das Zoomlevel bereits unter 0,1 liegt, was bedeutet, dass das Bild bis zum Limit ausgedünnt ist, wird sie beendet. Andernfalls verringert sie das Zoomlevel um 10% und ruft die zoom_or_rotate_image-Methode auf, um das angezeigte Bild zu aktualisieren.

Implementieren der rotate-Methode

Implementieren Sie die rotate-Methode:

    def rotate(self):
        if not self.current_image_path:  ## No image loaded
            return
        self.original_image = self.original_image.rotate(-90)
        self.zoom_or_rotate_image()

Die rotate-Methode überprüft, ob ein Bild geladen ist. Wenn kein Bild geladen ist, wird sie beendet. Andernfalls rotiert sie das ursprüngliche Bild um -90 Grad mit der rotate-Methode von PIL und ruft die zoom_or_rotate_image-Methode auf, um das angezeigte Bild zu aktualisieren.

Implementieren der zoom_or_rotate_image-Methode

Implementieren Sie die zoom_or_rotate_image-Methode:

    def zoom_or_rotate_image(self):
        ## Zoom and rotate original image, convert to Tk image, and display
        new_image = self.original_image.resize((int(self.original_image.width * self.zoom_level),
                                                int(self.original_image.height * self.zoom_level)))
        self.tk_image = ImageTk.PhotoImage(new_image)
        self.image_label.configure(image=self.tk_image)

Die zoom_or_rotate_image-Methode verkleinert oder vergrößert das ursprüngliche Bild basierend auf dem aktuellen Zoomlevel. Sie erstellt ein neues Bild mit der aktualisierten Größe mit der resize-Methode von PIL. Anschließend konvertiert sie das neue Bild in ein mit Tkinter kompatibles Bild mit ImageTk.PhotoImage und aktualisiert das Bildlabel, um das aktualisierte Bild anzuzeigen.

Erstellen der Hauptanwendungsschleife

Fügen Sie den folgenden Code am Ende der Datei image_viewer.py hinzu, um die Hauptanwendungsschleife zu erstellen:

if __name__ == '__main__':
    root = tk.Tk()
    app = ImageViewer(root)
    root.mainloop()

Dieser Code erstellt ein Tkinter-Hauptfenster, initialisiert eine Instanz der Klasse ImageViewer und startet die Hauptanwendungsschleife.

Wechseln Sie zum Desktop und führen Sie die Datei image_viewer.py aus, um die Anwendung zu testen. Sie sollten das folgende Fenster sehen:

python image_viewer.py

Zusammenfassung

Herzlichen Glückwunsch! Sie haben eine Bildbetrachtungsanwendung mit Python und Tkinter erstellt. Die Anwendung ermöglicht es Ihnen, eine Bilddatei zu öffnen, anzuzeigen und Aktionen wie das Zoomen in, das Zoomen aus und das Rotieren des Bilds auszuführen. Sie haben gelernt, wie die PIL-Bibliothek für die Bildverarbeitung und Tkinter für die Erstellung der grafischen Benutzeroberfläche verwendet werden. Sie können die Anwendung gerne weiter anpassen oder zusätzliche Funktionen erkunden.