Bemerkung

Hallo, willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Community auf Facebook! Tauchen Sie mit anderen Enthusiasten tiefer in Raspberry Pi, Arduino und ESP32 ein.

Warum beitreten?

Expertenunterstützung: Lösen Sie Probleme nach dem Kauf und technische Herausforderungen mit Hilfe unserer Community und unseres Teams.
Lernen & Teilen: Tauschen Sie Tipps und Tutorials aus, um Ihre Fähigkeiten zu verbessern.
Exklusive Vorschauen: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und Sneak Peeks.
Sonderrabatte: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.
Festliche Aktionen und Gewinnspiele: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

👉 Bereit, mit uns zu entdecken und zu gestalten? Klicken Sie auf [here] und treten Sie noch heute bei!

2. Video abspielen

In diesem Kapitel lernen Sie, wie Sie Videostreams in OpenCV einlesen und abspielen und wie Sie die Wiedergabegeschwindigkeit durch Berechnung der Frame-Verarbeitungszeit steuern können.

1. Projektübersicht

In diesem Abschnitt erreichen wir folgende Ziele:

Verwenden von cv2.VideoCapture, um eine Videodatei zu öffnen
Lesen und Anzeigen des Videos Frame für Frame
Automatisches Neustarten des Videos nach dem Ende
Steuerung der Wiedergabebildrate durch Berechnung der Verarbeitungszeit
Drücken der Taste q, um die Wiedergabe zu beenden

Darstellung der Video-Wiedergabeoberfläche

2. Code ausführen

Wichtig

Stellen Sie vor dem Start sicher, dass:

das Pan-Tilt-Modul montiert ist
Sie Zugriff auf den Raspberry-Pi-Desktop haben
das Codepaket installiert ist
das Fusion HAT+ installiert und konfiguriert ist
OpenCV installiert ist

Detaillierte Anweisungen finden Sie unter 0. OpenCV einrichten.

Öffnen Sie das Terminal und geben Sie den folgenden Befehl ein:
```
cd ~/ai-lab-kit/opencv_python
python3 cv_2_video.py
```
Nach dem Start des Skripts öffnet OpenCV ein Fenster mit dem Titel Video und zeigt die Videoframes in Echtzeit an.

Wenn das Video das Ende erreicht, startet es automatisch wieder vom Anfang.

Um das Programm zu beenden, können Sie:
- q auf der Tastatur drücken, um die Wiedergabe zu beenden
- das Fenster über die Schaltfläche zum Schließen schließen
Sobald das Fenster geschlossen wird, werden alle OpenCV-Ressourcen freigegeben und das Programm beendet.

3. Vollständiger Code

import cv2

# Open the video file
cap = cv2.VideoCapture("sample2.mp4")

while True:
    # Read one frame from the video
    ret, frame = cap.read()

    # If the video ends, restart from the beginning
    if not ret:
        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
        continue

    # Resize the frame for better display performance
    frame = cv2.resize(frame, (640, 480))

    # Display the frame in a window named "Video"
    cv2.imshow("Video", frame)

    # Wait 30 ms between frames (~30 FPS)
    # This also processes GUI events (keyboard and window events)
    key = cv2.waitKey(30) & 0xFF

    # Press 'q' to exit the program
    if key == ord("q"):
        break

    # Exit if the user closes the window (click the close button)
    if cv2.getWindowProperty("Video", cv2.WND_PROP_VISIBLE) < 1:
        break

# Release the video capture object
cap.release()

# Close all OpenCV windows
cv2.destroyAllWindows()

4. Code-Erklärung

Videodatei öffnen:
```
cap = cv2.VideoCapture("sample2.mp4")
```
Dies öffnet die Videodatei und erstellt ein VideoCapture-Objekt zum Lesen der Frames.
Einen Frame aus dem Video lesen:
```
ret, frame = cap.read()
```
- ret ist True, wenn ein Frame erfolgreich gelesen wurde.
- ret wird False, wenn das Video endet oder das Lesen fehlschlägt.
- frame enthält die Bilddaten (ein NumPy-Array).
Video neu starten, wenn es endet:
```
if not ret:
    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
    continue
```
Wenn das Video endet, wird hier die Wiedergabeposition auf den ersten Frame zurückgesetzt, sodass das Video erneut gestartet wird.
Frame skalieren:
```
frame = cv2.resize(frame, (640, 480))
```
Dadurch wird jeder Frame auf 640×480 skaliert, was eine flüssigere Anzeige und geringere CPU-Auslastung auf dem Raspberry Pi ermöglicht.
Frame anzeigen:
```
cv2.imshow("Video", frame)
```
Dies zeigt den aktuellen Frame in einem Fenster mit dem Namen Video an.
Wiedergabegeschwindigkeit steuern und Tastatureingaben verarbeiten:
```
key = cv2.waitKey(30) & 0xFF
```
Dadurch wartet das Programm etwa 30 ms zwischen zwei Frames (ca. 30 FPS) und verarbeitet gleichzeitig GUI-Ereignisse.
Mit q beenden:
```
if key == ord("q"):
    break
```
Drücken Sie q, um das Programm zu stoppen.
Programm beenden, wenn das Fenster geschlossen wird:
```
if cv2.getWindowProperty("Video", cv2.WND_PROP_VISIBLE) < 1:
    break
```
Dadurch wird überprüft, ob das Fenster noch sichtbar ist. Wenn der Benutzer das Fenster schließt, beendet das Programm sicher die Ausführung.
VideoCapture-Objekt freigeben:
```
cap.release()
```
Dadurch wird die Videodatei-Ressource freigegeben.
Alle OpenCV-Fenster schließen:
```
cv2.destroyAllWindows()
```
Dadurch werden alle OpenCV-Fenster geschlossen und die GUI-Ressourcen freigegeben.

5. Weitere Übungen

Versuchen Sie, die Fenstergröße zu ändern, um zu sehen, wie sich dies auf die Bildklarheit auswirkt.
Ersetzen Sie die Videodatei durch andere Dateien, um die Kompatibilität zu testen.
Geben Sie die Verarbeitungszeit pro Frame aus, um die Beziehung zwischen FPS und Wiedergabeverzögerung besser zu verstehen.