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

#include <opencv2/opencv.hpp>
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

Mat frame;
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

// Obtenir la fréquence d'images et la taille de l'image de la vidéo
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

while (true) {
    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

Mat prevFrame, nextFrame, diffFrame;
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

VideoCapture cap(0);

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

while (true) {
    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 <opencv2/opencv.hpp>
#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 <opencv2/opencv.hpp>
#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;
}
Autres extensions