Visualiseur d'images utilisant Python et Tkinter

Introduction

Dans ce projet, nous allons créer une application de visionneuse d'images utilisant Python et Tkinter. La visionneuse d'images vous permettra d'ouvrir un fichier image, de l'afficher et d'effectuer des actions telles que le grossissement, le rétrécissement et la rotation de l'image. Nous utiliserons la bibliothèque PIL (Python Imaging Library) pour gérer les opérations sur les images et Tkinter pour créer l'interface graphique utilisateur.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment créer une application GUI à l'aide de Tkinter.
• Comment gérer le chargement et l'affichage d'images à l'aide de PIL.
• Comment implémenter les fonctionnalités de grossissement, de rétrécissement et de rotation pour l'image affichée.

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Développer une application de visionneuse d'images fonctionnelle utilisant Python et Tkinter.
• Intégrer des capacités de traitement d'images à l'aide de la bibliothèque PIL.
• Implémenter des fonctionnalités de manipulation de base d'images telles que le grossissement et la rotation.

Créer les fichiers du projet

Tout d'abord, créez un nouveau fichier nommé ~/projet/visionneuse_images.py et ouvrez-le dans un éditeur de texte ou un environnement de développement intégré (IDE).

cd ~/projet
touch visionneuse_images.py

Importer les bibliothèques requises

Dans le fichier visionneuse_images.py, importez les bibliothèques nécessaires :

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

La bibliothèque tkinter fournit les fonctionnalités pour créer des éléments d'interface graphique utilisateur, filedialog nous permet d'ouvrir une boîte de dialogue de fichier pour sélectionner un fichier image, messagebox est utilisé pour afficher des messages à l'utilisateur, PIL est utilisé pour le traitement d'images, et os fournit des fonctions pour interagir avec le système d'exploitation.

Créer la classe ImageViewer

Définissez une nouvelle classe nommée ImageViewer qui gérera l'application de visionneuse d'images :

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

Dans la méthode __init__, nous initialisons la fenêtre racine avec un titre, une taille et une couleur d'arrière-plan. Ensuite, nous créons un étiquette pour afficher l'image et un cadre pour contenir les boutons de contrôle (Open, Quit, Zoom In, Zoom Out, Rotate). Nous définissons également des variables d'instance pour suivre le chemin du fichier image actuel et le niveau de zoom.

Implémenter la méthode open_image

Ajoutez la méthode open_image à la classe ImageViewer :

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

La méthode open_image ouvre une boîte de dialogue de fichier pour sélectionner un fichier image. Elle définit la variable current_image_path sur le chemin du fichier sélectionné et appelle la méthode load_image pour afficher l'image.

Implémenter la méthode load_image

Implémentez la méthode load_image :

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

        ## Redimensionner l'image pour l'affichage
        max_size = (600, 600)
        image.thumbnail(max_size)

        ## Enregistrer une référence à l'image d'origine (pour le zoom/la rotation)
        self.original_image = image

        ## Créer une image compatible Tkinter
        self.tk_image = ImageTk.PhotoImage(image)
        self.image_label.configure(image=self.tk_image)

        self.zoom_level = 1

La méthode load_image ouvre le fichier image sélectionné à l'aide de la méthode Image.open de PIL. Elle redimensionne l'image pour qu'elle rentre dans une taille maximale de 600x600 pixels à l'aide de la méthode thumbnail. Ensuite, elle enregistre une référence à l'image d'origine pour les fins de zoom et de rotation. Ensuite, elle crée une image compatible Tkinter à l'aide de ImageTk.PhotoImage et met à jour l'étiquette d'image pour afficher l'image chargée. Enfin, elle définit le niveau de zoom initial sur 1.

Implémenter la méthode zoom_in

Implémentez la méthode zoom_in :

    def zoom_in(self):
        if not self.current_image_path:  ## Aucune image chargée
            return
        self.zoom_level *= 1.1  ## Augmenter le niveau de zoom de 10%
        self.zoom_or_rotate_image()

La méthode zoom_in vérifie si une image est chargée. Si aucune image n'est chargée, elle renvoie. Sinon, elle augmente le niveau de zoom de 10% et appelle la méthode zoom_or_rotate_image pour mettre à jour l'image affichée.

Implémenter la méthode zoom_out

Implémentez la méthode zoom_out :

    def zoom_out(self):
        if not self.current_image_path:  ## Aucune image chargée
            return
        if self.zoom_level < 0.1:  ## Limiter le zoom vers l'extérieur
            return
        self.zoom_level *= 0.9  ## Diminuer le niveau de zoom de 10%
        self.zoom_or_rotate_image()

La méthode zoom_out vérifie si une image est chargée. Si aucune image n'est chargée, elle renvoie. Si le niveau de zoom est déjà inférieur à 0,1, ce qui signifie que l'image est zoomée au maximum, elle renvoie. Sinon, elle diminue le niveau de zoom de 10% et appelle la méthode zoom_or_rotate_image pour mettre à jour l'image affichée.

Implémenter la méthode rotate

Implémentez la méthode rotate :

    def rotate(self):
        if not self.current_image_path:  ## Aucune image chargée
            return
        self.original_image = self.original_image.rotate(-90)
        self.zoom_or_rotate_image()

La méthode rotate vérifie si une image est chargée. Si aucune image n'est chargée, elle renvoie. Sinon, elle fait tourner l'image d'origine de -90 degrés à l'aide de la méthode rotate de PIL et appelle la méthode zoom_or_rotate_image pour mettre à jour l'image affichée.

Implémenter la méthode zoom_or_rotate_image

Implémentez la méthode zoom_or_rotate_image :

    def zoom_or_rotate_image(self):
        ## Zoom et tourne l'image d'origine, convertit en image Tk et l'affiche
        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)

La méthode zoom_or_rotate_image redimensionne l'image d'origine en fonction du niveau de zoom actuel. Elle crée une nouvelle image avec la taille mise à jour à l'aide de la méthode resize de PIL. Ensuite, elle convertit la nouvelle image en une image compatible Tkinter à l'aide de ImageTk.PhotoImage et met à jour l'étiquette d'image pour afficher l'image mise à jour.

Créer la boucle principale de l'application

Ajoutez le code suivant à la fin du fichier image_viewer.py pour créer la boucle principale de l'application :

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

Ce code crée une fenêtre racine Tkinter, initialise une instance de la classe ImageViewer et démarre la boucle principale de l'application.

Accédez au bureau et exécutez le fichier image_viewer.py pour tester l'application. Vous devriez voir la fenêtre suivante :

python image_viewer.py

Sommaire

Félicitations ! Vous avez créé une application de visualisation d'images utilisant Python et Tkinter. L'application vous permet d'ouvrir un fichier image, de l'afficher et d'effectuer des actions telles que le zoom avant, le zoom arrière et la rotation de l'image. Vous avez appris à utiliser la bibliothèque PIL pour le traitement d'images et Tkinter pour créer l'interface graphique utilisateur. N'hésitez pas à personnaliser davantage l'application ou à explorer des fonctionnalités supplémentaires.