Traitement vidéo avec C++ OpenCV
Le traitement vidéo consiste à traiter et analyser chaque image d'une séquence vidéo.
OpenCV fournit des outils puissants pour le traitement des données vidéo, notamment la lecture vidéo, le traitement des images, l'enregistrement vidéo et le traitement vidéo en temps réel.
Scénarios d'application du traitement vidéo
Surveillance vidéo :
Utiliser la soustraction d'arrière-plan pour détecter les objets en mouvement.
Utiliser le flux optique pour analyser les trajectoires de mouvement des objets.
Analyse vidéo :
Extraire les images clés des vidéos.
Analyser le comportement des objets dans les vidéos.
Traitement en temps réel :
Filtres vidéo en temps réel (par exemple, détection de contours, flou, etc.).
Détection et suivi d'objets en temps réel.
Lecture et affichage de vidéos
Lecture de fichiers vidéo (VideoCapture)
Dans OpenCV,VideoCapturela classe est utilisée pour lire des trames vidéo à partir de fichiers vidéo ou de caméras.
Pour lire un fichier vidéo, créez d'abord unVideoCaptureobjet, puis spécifiez le chemin d'accès au fichier vidéo.
Exemple
using namespace cv;
int main() {
// Créer un objet VideoCapture et ouvrir le fichier vidéo
VideoCapture cap("example.mp4");
// Vérifier si la vidéo a été ouverte avec succès
if (!cap.isOpened()) {
std::cerr << "Erreur : Impossible d'ouvrir le fichier vidéo." << std::endl;
return -1;
}
// Le code de lecture et d'affichage de la vidéo sera présenté ci-dessous
return 0;
}
Affichage des images vidéo
Après avoir lu le fichier vidéo, vous pouvez lire la vidéo image par image dans une boucle, et utiliser laimshowfonction pour afficher chaque image.
Exemple
while (true) {
// Lire l'image suivante
cap >> frame;
// Si l'image est vide, la vidéo est terminée
if (frame.empty()) {
break;
}
// Afficher l'image actuelle
imshow("Video", frame);
// Attendre 30 millisecondes, appuyez sur ESC pour quitter
if (waitKey(30) == 27) {
break;
}
}
// Libérer l'objet VideoCapture
cap.release();
// Fermer toutes les fenêtres
destroyAllWindows();
Enregistrement de vidéos (VideoWriter)
Si vous souhaitez enregistrer la vidéo traitée dans un fichier, vous pouvez utiliser laVideoWriterclasse. Tout d'abord, vous devez spécifier le nom du fichier de sortie, le format d'encodage, la fréquence d'images et la taille de l'image.
Exemple
double fps = cap.get(CAP_PROP_FPS);
Size frameSize(cap.get(CAP_PROP_FRAME_WIDTH), cap.get(CAP_PROP_FRAME_HEIGHT));
// Créer un objet VideoWriter
VideoWriter writer("output.avi", VideoWriter::fourcc('M', 'J', 'P', 'G'), fps, frameSize);
while (true) {
cap >> frame;
if (frame.empty()) {
break;
}
// Écrire les images dans le fichier vidéo de sortie
writer.write(frame);
imshow("Video", frame);
if (waitKey(30) == 27) {
break;
}
}
// Libérer les objets VideoCapture et VideoWriter
cap.release();
writer.release();
destroyAllWindows();
Traitement des images vidéo
Traitement vidéo image par image
Dans le traitement vidéo, il est généralement nécessaire d'effectuer des opérations de traitement spécifiques sur chaque image. Par exemple, vous pouvez convertir chaque image en niveaux de gris, effectuer une détection de contours, etc.
Exemple
cap >> frame;
if (frame.empty()) {
break;
}
// Convertir l'image en niveaux de gris
Mat grayFrame;
cvtColor(frame, grayFrame, COLOR_BGR2GRAY);
// Afficher l'image en niveaux de gris
imshow("Gray Video", grayFrame);
if (waitKey(30) == 27) {
break;
}
}
Traitement en temps réel des images vidéo
Lors du traitement des images vidéo en temps réel, il est généralement nécessaire d'appliquer des algorithmes de traitement en temps réel à chaque image. Par exemple, détecter des objets en mouvement dans la vidéo en temps réel.
Exemple
cap >> prevFrame;
cvtColor(prevFrame, prevFrame, COLOR_BGR2GRAY);
while (true) {
cap >> nextFrame;
if (nextFrame.empty()) {
break;
}
cvtColor(nextFrame, nextFrame, COLOR_BGR2GRAY);
// Calculer la différence entre les images
absdiff(prevFrame, nextFrame, diffFrame);
// Afficher l'image de différence
imshow("Détection de mouvement", diffFrame);
// Mettre à jour l'image précédente
prevFrame = nextFrame.clone();
if (waitKey(30) == 27) {
break;
}
}
Traitement de la caméra en temps réel
Ouverture de la caméra
En utilisant laVideoCaptureclasse, vous pouvez non seulement lire des fichiers vidéo, mais aussi ouvrir la caméra pour le traitement de flux vidéo en temps réel. Pour ouvrir la caméra, il suffit de définir leVideoCaptureparamètre à 0 (ce qui indique la caméra par défaut).
Exemple
if (!cap.isOpened()) {
std::cerr << "Erreur : Impossible d'ouvrir la caméra." << std::endl;
return -1;
}
Traitement des flux vidéo en temps réel
Après avoir ouvert la caméra, vous pouvez traiter le flux vidéo en temps réel image par image, comme pour le traitement d'un fichier vidéo. Par exemple, vous pouvez appliquer un algorithme de détection de contours au flux vidéo en temps réel.
Exemple
cap >> frame;
if (frame.empty()) {
break;
}
// Appliquer la détection de contours Canny
Mat edges;
Canny(frame, edges, 100, 200);
// Afficher le résultat de la détection de contours
imshow("Contours", edges);
if (waitKey(30) == 27) {
break;
}
}
cap.release();
destroyAllWindows();
Techniques avancées de traitement vidéo
Soustraction de l'arrière-plan vidéo
La soustraction d'arrière-plan est utilisée pour extraire les objets au premier plan d'une vidéo.
Exemple
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Ouvrir un fichier vidéo ou une caméra
VideoCapture cap("video.mp4");
if (!cap.isOpened()) {
cout << "Erreur : Impossible d'ouvrir le fichier vidéo ou la caméra !" << endl;
return -1;
}
// Créer un soustracteur d'arrière-plan
Ptr<BackgroundSubtractor> bgSubtractor = createBackgroundSubtractorMOG2();
// Traiter les images de la vidéo
Mat frame, fgMask;
while (true) {
cap >> frame;
if (frame.empty()) break;
// Appliquer la soustraction d'arrière-plan
bgSubtractor->apply(frame, fgMask);
// Afficher le résultat
imshow("Image", frame);
imshow("Masque de premier plan", fgMask);
// Appuyer sur ESC pour quitter
if (waitKey(30) == 27) break;
}
// Libérer les ressources
cap.release();
destroyAllWindows();
return 0;
}
Calcul du flux optique
Le flux optique est utilisé pour calculer le mouvement des objets dans les images vidéo.
Flux optique épars (méthode Lucas-Kanade) :
Exemple
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Ouvrir un fichier vidéo ou une caméra
VideoCapture cap("video.mp4");
if (!cap.isOpened()) {
cout << "Erreur : Impossible d'ouvrir le fichier vidéo ou la caméra !" << endl;
return -1;
}
// Lire la première image
Mat oldFrame, oldGray;
cap >> oldFrame;
cvtColor(oldFrame, oldGray, COLOR_BGR2GRAY);
// Sélectionner les points caractéristiques
vector<Point2f> oldPoints;
goodFeaturesToTrack(oldGray, oldPoints, 100, 0.3, 7);
// Traiter les images de la vidéo
Mat frame, gray;
while (true) {
cap >> frame;
if (frame.empty()) break;
// Convertir en image en niveaux de gris
cvtColor(frame, gray, COLOR_BGR2GRAY);
// Calculer le flux optique
vector<Point2f> newPoints;
vector<uchar> status;
vector<float> err;
calcOpticalFlowPyrLK(oldGray, gray, oldPoints, newPoints, status, err);
// Tracer les trajectoires du flux optique
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);
}
}
// Mettre à jour les images et les points caractéristiques
oldGray = gray.clone();
oldPoints = newPoints;
// Afficher le résultat
imshow("Flux optique", frame);
// Appuyer sur ESC pour quitter
if (waitKey(30) == 27) break;
}
// Libérer les ressources
cap.release();
destroyAllWindows();
return 0;
}