Ajout d'une fonctionnalité de caméra contrôlée par l'utilisateur à notre horloge GUI Python

Dans notre tutoriel précédent, nous avons construit une horloge GUI personnalisable à l'aide de Python et Tkinter. Allons encore plus loin en ajoutant une fonction d'appareil photo qui permet aux utilisateurs de capturer et d'enregistrer des images à la demande. Ce projet vous familiarisera avec l'entrée de caméra en Python, améliorant ainsi vos compétences en développement d'interface graphique et en gestion de fichiers.

Configuration de l'environnement

Avant de commencer, assurez-vous que les bibliothèques nécessaires sont installées. Nous utiliserons OpenCV pour la gestion de la caméra. Installez-le en utilisant pip :

pip install opencv-python

Ensuite, nous allons installer Pillow en utilisant pip.

pip install Pillow

Maintenant que nous avons installé toutes les dépendances, nous pouvons ajouter la caméra. Nous allons créer deux types de caméras : une caméra ordinaire et une caméra cachée derrière des clics.

Reste avec moi.

    import cv2
    from PIL import Image, ImageTk
    import os
    from datetime import datetime

Création de la fonction caméra

Ajoutons une fonction pour gérer la capture de la caméra :

    def capture_image():
        # Initialize the camera
        cap = cv2.VideoCapture(0)

        if not cap.isOpened():
            print("Error: Could not open camera.")
            return

        # Capture a frame
        ret, frame = cap.read()

        if not ret:
            print("Error: Could not capture image.")
            cap.release()
            return

        # Create a directory to store images if it doesn't exist
        if not os.path.exists("captured_images"):
            os.makedirs("captured_images")

        # Generate a unique filename using timestamp
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"captured_images/image_{timestamp}.png"

        # Save the image
        cv2.imwrite(filename, frame)
        print(f"Image saved as {filename}")

        # Release the camera
        cap.release()

        # Display the captured image
        display_image(filename)

Décomposons la fonction capture_image() d'une manière facile à comprendre pour les débutants. Nous passerons en revue chaque partie étape par étape, en expliquant ce qui se passe et pourquoi.

`def capture_image()`

Cette ligne crée une nouvelle fonction appelée capture_image(). Considérez une fonction comme un ensemble d'instructions que nous pouvons utiliser chaque fois que nous voulons prendre une photo.

`cap = cv2.VideoCapture(0)`

Ici, nous installons notre caméra. Imaginez que vous allumez un appareil photo numérique :

• cv2 est un outil (bibliothèque) qui nous aide à travailler avec des caméras et des images en Python.
• VideoCapture(0) revient à appuyer sur le bouton d'alimentation de l'appareil photo. Le 0 signifie « utilisez la première caméra que vous trouvez » (généralement la webcam intégrée à un ordinateur portable).
• Nous appelons cette configuration de caméra cap (abréviation de capture), afin de pouvoir y faire référence plus tard.

    if not cap.isOpened():
        print("Error: Could not open camera.")
        return

Cette partie vérifie si la caméra s'est allumée correctement :

• sinon cap.isOpened() : demande : "La caméra n'a-t-elle pas réussi à s'allumer ?"
• En cas d'échec, nous imprimons un message d'erreur.

• retour signifie "arrêter ici et quitter la fonction" s'il y a un problème.

  ret, frame = cap.read()

Maintenant, nous prenons la vraie photo :

cap.read(), c'est comme appuyer sur le déclencheur d'un appareil photo.

Cela nous donne deux choses :

• ret : Une réponse oui/non à la question "La photo a-t-elle été prise avec succès ?"
• frame : La photo réelle, si elle a été prise.

    if not ret:
        print("Error: Could not capture image.")
        cap.release()
        return

Ceci vérifie si la photo a été prise avec succès :

• Si ret est "non" (ce qui signifie que l'image a échoué), nous :

• Imprimer un message d'erreur.

• cap.release() éteint la caméra.

• return quitte la fonction.
  

    if not os.path.exists("captured_images"):
        os.makedirs("captured_images")

Cette partie crée un dossier spécial pour stocker nos photos :

if not os.path.exists("captured_images"):` checks if a folder named "captured_images" already exists.

• S'il n'existe pas, os.makedirs("captured_images") crée ce dossier.
• C'est comme créer un nouvel album pour stocker vos photos.

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"captured_images/image_{timestamp}.png"

Ici, nous créons un nom unique pour notre photo :

datetime.now() obtient la date et l'heure actuelles.
.strftime("%Y%m%d_%H%M%S") formate cette fois dans une chaîne comme "20240628_152059" (Année-Mois-Jour_HourMinuteSecond).

• Nous l'utilisons pour créer un nom de fichier comme "captured_images/image_20240628_152059.png".
• Cela garantit que chaque photo a un nom unique en fonction du moment où elle a été prise.

    cv2.imwrite(filename, frame)
    print(f"Image saved as {filename}")

Maintenant, nous enregistrons la photo.

v2.imwrite(filename, frame) enregistre notre image (cadre) avec le nom de fichier que nous avons créé.
Nous imprimons ensuite un message indiquant où l'image a été enregistrée.

`cap.release()`

Cette ligne éteint l'appareil photo, comme si vous appuyiez à nouveau sur le bouton d'alimentation lorsque vous avez terminé.

`display_image(filename)`

Enfin, nous appelons une autre fonction pour afficher la photo que nous venons de prendre à l'écran.
En résumé, cette fonction effectue les opérations suivantes.

• Allume la caméra
• Vérifiez si la caméra fonctionne
• Prend une photo
• S'assure que la photo a été prise avec succès
• Crée un dossier pour stocker les images s'il n'existe pas
• Donne à l'image un nom unique basé sur l'heure actuelle
• Enregistre l'image dans le dossier
• Éteint la caméra

Chaque étape comporte des vérifications pour garantir que les choses fonctionnent correctement, et s'il y a un problème à tout moment, la fonction s'arrêtera et nous fera savoir ce qui ne va pas.

Affichage de l'image capturée

Ajouter une fonction pour afficher l'image capturée :

    def display_image(filename):
        # Open the image file
        img = Image.open(filename)

        # Resize the image to fit in the window
        img = img.resize((300, 200), Image.LANCZOS)

        # Convert the image for Tkinter
        photo = ImageTk.PhotoImage(img)

        # Update the image label
        image_label.config(image=photo)
        image_label.image = photo

Commençons par une explication conviviale des opérations sur les fichiers, puis plongeons-nous dans le code.

Opérations sur les fichiers pour les débutants :

1. Lire :

   • C'est comme ouvrir un livre et regarder son contenu.
   • En programmation, lire un fichier signifie accéder à son contenu sans le modifier.
   • Exemple : Ouvrir une image pour la visualiser.

2. Écrire :

   • This is like writing in a notebook.
   • In programming, writing means adding new content to a file or changing existing content.
   • Example: Saving a new image or modifying an existing one.

3. Execute:

   • This is like following a set of instructions.
   • In programming, executing usually refers to running a program or script.
   • For images, we don't typically "execute" them, but we can process or display them.

Now, let's focus on the display_image(filename) function:

`def display_image(filename)`

This line defines a function named display_image that takes a filename as input. This filename is the path to the image we want to display.

`img = Image.open(filename)`

Here's where we use the "read" operation:

• Image.open() is a function from the PIL (Python Imaging Library) that opens an image file.
• It's like telling the computer, "Please look at this picture for me."
• The opened image is stored in the variable img.

• This operation doesn't change the original file; it allows us to work with its contents.

  img = img.resize((300, 200), Image.LANCZOS)

This line resizes the image:

• img.resize() changes the size of the image.
• (300, 200) sets the new width to 300 pixels and height to 200 pixels.

• Image.LANCZOS is a high-quality resizing method that helps maintain image quality.

  photo = ImageTk.PhotoImage(img)

This line converts the image for use with Tkinter (the GUI library we're using):

• ImageTk.PhotoImage() takes our resized image and converts it into a format that Tkinter can display.
• This converted image is stored in the photo variable.

    image_label.config(image=photo)
    image_label.image = photo

These lines update the GUI to show the image:

• image_label is a Tkinter widget (like a container) that can display images.
• config(image=photo) tells this label to display our processed image.
• image_label.image = photo is a special line that prevents the image from being deleted by Python's garbage collector.

In summary, this function does the following:

1. Opens an image file (read operation).
2. Resize the image to fit nicely in our GUI window.
3. Converts the image to a format our GUI system (Tkinter) can understand.
4. Updates a label in our GUI to display this image.

This process doesn't involve writing to the file or executing it. We're simply reading the image, processing it in memory, and displaying it in our application.

Adding GUI Elements

Update your existing GUI to include a button for image capture and a label to display the image:

# Add this after your existing GUI elements
capture_button = tk.Button(window, text="Capture Image", command=capture_image)
capture_button.pack(anchor='center', pady=5)

image_label = tk.Label(window)
image_label.pack(anchor='center', pady=10)

• Adjusting the Window Size:

You may need to adjust the window size to accommodate the new elements:

window.geometry("350x400")  # Increase the height

• Complete Code:

Here's the complete code incorporating the new camera feature:

    import tkinter as tk
    from time import strftime
    import cv2
    from PIL import Image, ImageTk
    import os
    from datetime import datetime

    window = tk.Tk()
    window.title("Python GUI Clock with Camera")
    window.geometry("350x400")

    is_24_hour = True

    def update_time():
        global is_24_hour
        time_format = '%H:%M:%S' if is_24_hour else '%I:%M:%S %p'
        time_string = strftime(time_format)
        date_string = strftime('%B %d, %Y')
        time_label.config(text=time_string)
        date_label.config(text=date_string)
        time_label.after(1000, update_time)

    def change_color():
        colors = ['black', 'red', 'green', 'blue', 'yellow', 'purple', 'orange']
        current_bg = time_label.cget("background")
        next_color = colors[(colors.index(current_bg) + 1) % len(colors)]
        time_label.config(background=next_color)
        date_label.config(background=next_color)

    def toggle_format():
        global is_24_hour
        is_24_hour = not is_24_hour

    def capture_image():
        cap = cv2.VideoCapture(0)

        if not cap.isOpened():
            print("Error: Could not open camera.")
            return

        ret, frame = cap.read()

        if not ret:
            print("Error: Could not capture image.")
            cap.release()
            return

        if not os.path.exists("captured_images"):
            os.makedirs("captured_images")

        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"captured_images/image_{timestamp}.png"

        cv2.imwrite(filename, frame)
        print(f"Image saved as {filename}")

        cap.release()

        display_image(filename)

    def display_image(filename):
        img = Image.open(filename)
        img = img.resize((300, 200), Image.LANCZOS)
        photo = ImageTk.PhotoImage(img)
        image_label.config(image=photo)
        image_label.image = photo

    time_label = tk.Label(window, font=('calibri', 40, 'bold'), background='black', foreground='white')
    time_label.pack(anchor='center')

    date_label = tk.Label(window, font=('calibri', 24), background='black', foreground='white')
    date_label.pack(anchor='center')

    color_button = tk.Button(window, text="Change Color", command=change_color)
    color_button.pack(anchor='center', pady=5)

    format_button = tk.Button(window, text="Toggle 12/24 Hour", command=toggle_format)
    format_button.pack(anchor='center', pady=5)

    capture_button = tk.Button(window, text="Capture Image", command=capture_image)
    capture_button.pack(anchor='center', pady=5)

    image_label = tk.Label(window)
    image_label.pack(anchor='center', pady=10)

    update_time()
    window.mainloop()

Conclusion

You've now enhanced your GUI clock with a user-controlled camera feature. This addition demonstrates how to integrate hardware interactions into a Python GUI application, handle file operations, and dynamically update the interface.

Always respect user privacy and obtain the necessary permissions when working with camera features in your applications.

Resource

• How to Identify a Phishing Email in 2024
• Build Your First Password Cracker
• Python for Beginners

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!