Hinzufügen einer benutzergesteuerten Kamerafunktion zu unserer Python-GUI-Uhr

In unserem vorherigen Tutorial haben wir mit Python und Tkinter eine anpassbare GUI-Uhr erstellt. Gehen wir noch einen Schritt weiter und fügen eine Kamerafunktion hinzu, mit der Benutzer Bilder bei Bedarf aufnehmen und speichern können. Dieses Projekt führt Sie in die Arbeit mit Kameraeingaben in Python ein und erweitert Ihre Fähigkeiten in der GUI-Entwicklung und Dateiverwaltung.

Einrichten der Umgebung

Bevor wir beginnen, stellen Sie sicher, dass Sie die erforderlichen Bibliotheken installiert haben. Wir werden OpenCV für die Kameraverwaltung verwenden. Installieren Sie es mit pip:

pip install opencv-python

Als nächstes installieren wir Pillow mit pip.

pip install Pillow

Da wir nun alle Abhängigkeiten installiert haben, können wir die Kamera hinzufügen. Wir werden zwei Arten von Kameras erstellen: eine normale Kamera und eine hinter Klicks versteckte Kamera.

Bleib bei mir.

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

Erstellen der Kamerafunktion

Fügen wir eine Funktion für die Kameraaufnahme hinzu:

    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)

Lassen Sie uns die Funktion „capture_image()“ so aufschlüsseln, dass sie für Anfänger leicht verständlich ist. Wir gehen jeden Teil Schritt für Schritt durch und erklären, was passiert und warum.

`def capture_image()`

Diese Zeile erstellt eine neue Funktion namens „capture_image()“. Stellen Sie sich eine Funktion als eine Reihe von Anweisungen vor, die wir verwenden können, wann immer wir ein Bild aufnehmen möchten.

`cap = cv2.VideoCapture(0)`

Hier richten wir unsere Kamera ein. Stellen Sie sich vor, Sie schalten eine Digitalkamera ein:

• cv2 ist ein Tool (Bibliothek), das uns bei der Arbeit mit Kameras und Bildern in Python hilft.
• VideoCapture(0) ist so, als würde man den Netzschalter der Kamera drücken. Die 0 bedeutet „Verwenden Sie die erste Kamera, die Sie finden“ (normalerweise die integrierte Webcam eines Laptops).
• Wir nennen dieses Kamera-Setup Cap (Abkürzung für Capture), damit wir später darauf zurückgreifen können.

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

Dieser Teil prüft, ob die Kamera richtig eingeschaltet ist:

• Wenn nicht, cap.isOpened(): fragt: „Konnte die Kamera nicht eingeschaltet werden?“
• Wenn es fehlschlägt, geben wir eine Fehlermeldung aus.

• Zurück bedeutet „hier anhalten und die Funktion verlassen“, wenn ein Problem auftritt.

  ret, frame = cap.read()

Jetzt machen wir das eigentliche Bild:

cap.read() ist wie das Drücken des Auslösers einer Kamera.

Es gibt uns zwei Dinge:

• ret: Eine Ja/Nein-Antwort auf „Wurde das Bild erfolgreich aufgenommen?“
• Rahmen: Das tatsächliche Bild, sofern es aufgenommen wurde.

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

Hiermit wird überprüft, ob das Bild erfolgreich aufgenommen wurde:

• Wenn ret „nein“ ist (was bedeutet, dass das Bild fehlgeschlagen ist), gehen wir wie folgt vor:

• Eine Fehlermeldung drucken.

• cap.release() schaltet die Kamera aus.

• Return beendet die Funktion.
  

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

Dieser Teil erstellt einen speziellen Ordner zum Speichern unserer Bilder:

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

• Wenn es nicht existiert, erstellt os.makedirs("captured_images") diesen Ordner.
• Es ist, als ob Sie ein neues Album erstellen würden, um Ihre Fotos zu speichern.

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

Hier erstellen wir einen eindeutigen Namen für unser Bild:

datetime.now() ruft das aktuelle Datum und die aktuelle Uhrzeit ab.
.strftime("%Y%m%d_%H%M%S") formatiert diese Zeit in eine Zeichenfolge wie „20240628_152059“ (Jahr-Monat-Tag_StundeMinuteSekunde).

• Wir verwenden dies, um einen Dateinamen wie „captured_images/image_20240628_152059.png“ zu erstellen.
• Dadurch wird sichergestellt, dass jedes Bild einen eindeutigen Namen hat, der auf dem Aufnahmezeitpunkt basiert.

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

Jetzt speichern wir das Bild.

v2.imwrite(Dateiname, Rahmen) speichert unser Bild (Rahmen) unter dem von uns erstellten Dateinamen.
Anschließend drucken wir eine Meldung aus, in der angegeben wird, wo das Bild gespeichert wurde.

`cap.release()`

Diese Zeile schaltet die Kamera aus, als würde man den Ein-/Ausschalter erneut drücken, wenn man fertig ist.

`display_image(filename)`

Zuletzt rufen wir eine weitere Funktion auf, um das gerade aufgenommene Bild auf dem Bildschirm anzuzeigen.
Zusammenfassend führt diese Funktion Folgendes aus.

• Schaltet die Kamera ein
• Überprüfen Sie, ob die Kamera funktioniert
• Macht ein Foto
• Stellt sicher, dass das Bild erfolgreich aufgenommen wurde
• Erstellt einen Ordner zum Speichern von Bildern, falls dieser nicht vorhanden ist
• Gibt dem Bild einen eindeutigen Namen basierend auf der aktuellen Uhrzeit
• Speichert das Bild im Ordner
• Schaltet die Kamera aus

Jeder Schritt wird überprüft, um sicherzustellen, dass alles ordnungsgemäß funktioniert. Wenn zu irgendeinem Zeitpunkt ein Problem auftritt, stoppt die Funktion und teilt uns mit, was schief gelaufen ist.

Anzeigen des aufgenommenen Bildes

Fügen Sie eine Funktion hinzu, um das aufgenommene Bild anzuzeigen:

    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

Beginnen wir mit einer anfängerfreundlichen Erklärung der Dateioperationen und tauchen wir dann in den Code ein.

Dateioperationen für Anfänger:

1. Lesen Sie:

   • Das ist, als würde man ein Buch öffnen und seinen Inhalt betrachten.
   • Beim Programmieren bedeutet das Lesen einer Datei, auf ihren Inhalt zuzugreifen, ohne ihn zu ändern.
   • Beispiel: Öffnen eines Bildes, um es anzuzeigen.

2. Schreiben Sie:

   • 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

Das obige ist der detaillierte Inhalt vonHinzufügen einer benutzergesteuerten Kamerafunktion zu unserer Python-GUI-Uhr. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!