C++ OpenCV Videoverarbeitung

Videoverarbeitung bezeichnet die Verarbeitung und Analyse jedes Frames einer Videosequenz.

OpenCV bietet leistungsstarke Werkzeuge für die Verarbeitung von Videodaten, darunter das Lesen von Videos, Frame-Verarbeitung, das Speichern von Videos und Echtzeit-Videoverarbeitung.

Anwendungsszenarien der Videoverarbeitung

Videoüberwachung:

  • Verwenden Sie die Hintergrundsubtraktion, um sich bewegende Objekte zu erkennen.

  • Verwenden Sie den optischen Fluss, um Bewegungstrajektorien von Objekten zu analysieren.

Videoanalyse:

  • Extrahieren Sie Schlüsselbilder aus Videos.

  • Analysieren Sie das Verhalten von Objekten in Videos.

Echtzeitverarbeitung:

  • Echtzeit-Videofilter (z. B. Kantenerkennung, Weichzeichnen usw.).

  • Echtzeit-Objekterkennung und -verfolgung.


Lesen und Anzeigen von Videos

Lesen von Videodateien (VideoCapture)

In OpenCV,VideoCapturewird die Klasse verwendet, um Video-Frames aus Videodateien oder Kameras zu lesen.

Um eine Videodatei zu lesen, erstellen Sie zuerst einVideoCaptureObjekt und geben Sie den Pfad zur Videodatei an.

Beispiel

#include <opencv2/opencv.hpp>
using namespace cv;

int main() {
    // Erstellen Sie ein VideoCapture-Objekt und öffnen Sie die Videodatei
    VideoCapture cap("example.mp4");

    // Überprüfen, ob das Video erfolgreich geöffnet wurde
    if (!cap.isOpened()) {
        std::cerr << "Fehler: Videodatei konnte nicht geöffnet werden." << std::endl;
        return -1;
    }

    // Der Code zum Lesen und Anzeigen von Videos wird unten vorgestellt
    return 0;
}

Anzeigen von Video-Frames

Nachdem Sie die Videodatei gelesen haben, können Sie das Video in einer Schleife Bild für Bild lesen und dieimshowFunktion verwenden, um jedes Einzelbild anzuzeigen.

Beispiel

Mat frame;
while (true) {
    // Das nächste Einzelbild lesen
    cap >> frame;

    // Wenn das Einzelbild leer ist, ist das Video beendet
    if (frame.empty()) {
        break;
    }

    // Das aktuelle Einzelbild anzeigen
    imshow("Video", frame);

    // 30 Millisekunden warten, ESC zum Beenden drücken
    if (waitKey(30) == 27) {
        break;
    }
}

// Das VideoCapture-Objekt freigeben
cap.release();
// Alle Fenster schließen
destroyAllWindows();

Videos speichern (VideoWriter)

Wenn Sie das verarbeitete Video in einer Datei speichern möchten, können Sie dieVideoWriterKlasse verwenden. Zuerst müssen Sie den Ausgabedateinamen, das Kodierungsformat, die Bildrate und die Bildgröße angeben.

Beispiel

// Bildrate und Bildgröße des Videos ermitteln
double fps = cap.get(CAP_PROP_FPS);
Size frameSize(cap.get(CAP_PROP_FRAME_WIDTH), cap.get(CAP_PROP_FRAME_HEIGHT));

// VideoWriter-Objekt erstellen
VideoWriter writer("output.avi", VideoWriter::fourcc('M', 'J', 'P', 'G'), fps, frameSize);

while (true) {
    cap >> frame;
    if (frame.empty()) {
        break;
    }

    // Frames in die Ausgabevideodatei schreiben
    writer.write(frame);

    imshow("Video", frame);
    if (waitKey(30) == 27) {
        break;
    }
}

// Die VideoCapture- und VideoWriter-Objekte freigeben
cap.release();
writer.release();
destroyAllWindows();

Verarbeitung von Video-Frames

Verarbeitung von Video-Frames Frame für Frame

In der Videoverarbeitung ist es normalerweise notwendig, bestimmte Verarbeitungsoperationen an jedem Frame durchzuführen. Zum Beispiel können Sie jeden Frame in Graustufen umwandeln, Kantenerkennung durchführen und so weiter.

Beispiel

while (true) {
    cap >> frame;
    if (frame.empty()) {
        break;
    }

    // Konvertiere den Frame in ein Graustufenbild
    Mat grayFrame;
    cvtColor(frame, grayFrame, COLOR_BGR2GRAY);

    // Den Graustufen-Frame anzeigen
    imshow("Gray Video", grayFrame);

    if (waitKey(30) == 27) {
        break;
    }
}

Echtzeitverarbeitung von Video-Frames

Bei der Verarbeitung von Video-Frames in Echtzeit ist es normalerweise notwendig, einige Echtzeit-Verarbeitungsalgorithmen auf jeden Frame anzuwenden. Zum Beispiel bewegte Objekte im Video in Echtzeit erkennen.

Beispiel

Mat prevFrame, nextFrame, diffFrame;
cap >> prevFrame;
cvtColor(prevFrame, prevFrame, COLOR_BGR2GRAY);

while (true) {
    cap >> nextFrame;
    if (nextFrame.empty()) {
        break;
    }

    cvtColor(nextFrame, nextFrame, COLOR_BGR2GRAY);

    // Berechne die Differenz zwischen den Frames
    absdiff(prevFrame, nextFrame, diffFrame);

    // Differenzbild anzeigen
    imshow("Bewegungserkennung", diffFrame);

    // Das vorherige Frame aktualisieren
    prevFrame = nextFrame.clone();

    if (waitKey(30) == 27) {
        break;
    }
}

Echtzeit-Kameraverarbeitung

Öffnen der Kamera

Mit derVideoCaptureKlasse, können Sie nicht nur Videodateien lesen, sondern auch die Kamera für Echtzeit-Videostreamverarbeitung öffnen. Um die Kamera zu öffnen, setzen Sie einfach denVideoCaptureParameter auf 0 (was die Standardkamera angibt).

Beispiel

VideoCapture cap(0);

if (!cap.isOpened()) {
    std::cerr << "Fehler: Kamera konnte nicht geöffnet werden." << std::endl;
    return -1;
}

Verarbeitung von Echtzeit-Videostreams

Nach dem Öffnen der Kamera können Sie den Echtzeit-Videostream Bild für Bild verarbeiten, genau wie beim Verarbeiten einer Videodatei. Zum Beispiel können Sie einen Kantenerkennungsalgorithmus auf den Echtzeit-Videostream anwenden.

Beispiel

while (true) {
    cap >> frame;
    if (frame.empty()) {
        break;
    }

    // Canny-Kantenerkennung anwenden
    Mat edges;
    Canny(frame, edges, 100, 200);

    // Ergebnis der Kantenerkennung anzeigen
    imshow("Kanten", edges);

    if (waitKey(30) == 27) {
        break;
    }
}

cap.release();
destroyAllWindows();

Fortgeschrittene Videoverarbeitungstechniken

Video-Hintergrundsubtraktion

Die Hintergrundsubtraktion wird verwendet, um Vordergrundobjekte aus einem Video zu extrahieren.

Beispiel

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    // Eine Videodatei oder Kamera öffnen
    VideoCapture cap("video.mp4");
    if (!cap.isOpened()) {
        cout << "Fehler: Videodatei oder Kamera kann nicht geöffnet werden!" << endl;
        return -1;
    }

    // Hintergrundsubtrahierer erstellen
    Ptr<BackgroundSubtractor> bgSubtractor = createBackgroundSubtractorMOG2();

    // Videoframes verarbeiten
    Mat frame, fgMask;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;

        // Hintergrundsubtraktion anwenden
        bgSubtractor->apply(frame, fgMask);

        // Ergebnis anzeigen
        imshow("Einzelbild", frame);
        imshow("Vordergrundmaske", fgMask);

        // ESC zum Beenden drücken
        if (waitKey(30) == 27) break;
    }

    // Ressourcen freigeben
    cap.release();
    destroyAllWindows();

    return 0;
}

Berechnung des optischen Flusses

Optischer Fluss wird verwendet, um die Bewegung von Objekten in Videoframes zu berechnen.

Dünnbesetzter optischer Fluss (Lucas-Kanade-Methode):

Beispiel

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    // Eine Videodatei oder Kamera öffnen
    VideoCapture cap("video.mp4");
    if (!cap.isOpened()) {
        cout << "Fehler: Videodatei oder Kamera kann nicht geöffnet werden!" << endl;
        return -1;
    }

    // Erstes Einzelbild lesen
    Mat oldFrame, oldGray;
    cap >> oldFrame;
    cvtColor(oldFrame, oldGray, COLOR_BGR2GRAY);

    // Merkmalspunkte auswählen
    vector<Point2f> oldPoints;
    goodFeaturesToTrack(oldGray, oldPoints, 100, 0.3, 7);

    // Videoframes verarbeiten
    Mat frame, gray;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;

        // In Graustufenbild konvertieren
        cvtColor(frame, gray, COLOR_BGR2GRAY);

        // Optischen Fluss berechnen
        vector<Point2f> newPoints;
        vector<uchar> status;
        vector<float> err;
        calcOpticalFlowPyrLK(oldGray, gray, oldPoints, newPoints, status, err);

        // Trajektorien des optischen Flusses zeichnen
        for (size_t i = 0; i < oldPoints.size(); i++) {
            if (status[i]) {
                line(frame, oldPoints[i], newPoints[i], Scalar(0, 255, 0), 2);
                circle(frame, newPoints[i], 3, Scalar(0, 0, 255), -1);
            }
        }

        // Frames und Merkmalspunkte aktualisieren
        oldGray = gray.clone();
        oldPoints = newPoints;

        // Ergebnis anzeigen
        imshow("Optischer Fluss", frame);

        // ESC zum Beenden drücken
        if (waitKey(30) == 27) break;
    }

    // Ressourcen freigeben
    cap.release();
    destroyAllWindows();

    return 0;
}
Andere Erweiterungen