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
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
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
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
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
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
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
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 <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 <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;
}