Pratique de projet avec C++ OpenCV

La pratique de projet OpenCV est le processus d'application des connaissances théoriques à des problèmes du monde réel.

Grâce à la pratique de projet, vous pouvez consolider vos compétences OpenCV et résoudre des problèmes de vision par ordinateur du monde réel.

Voici les types courants de projets OpenCV :

  1. Projets de traitement d'images: tels que les filtres d'images, l'inpainting d'images, l'amélioration d'images, etc.

  2. Projets de détection et de suivi d'objets: tels que la détection de visages, la reconnaissance de plaques d'immatriculation, le suivi de cibles mobiles, etc.

  3. Projets d'apprentissage profond: tels que la classification d'images, la détection d'objets, la segmentation sémantique, etc.

  4. Projets de traitement vidéo: comme l'analyse vidéo, le traitement vidéo en temps réel, les effets vidéo, etc.


Projets simples

Application de filtres d'image

Les filtres d'image sont l'une des opérations de base du traitement d'image. En appliquant différents filtres, vous pouvez modifier l'apparence et le style d'une image.

OpenCV fournit de nombreuses fonctions pour implémenter divers effets de filtres d'image.

Filtre en niveaux de gris

Le filtre en niveaux de gris est le processus de conversion d'une image couleur en une image en niveaux de gris. Une image en niveaux de gris n'a qu'un seul canal, et la valeur de chaque pixel représente la luminosité.

Exemple

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat image = cv::imread("input.jpg");
    cv::Mat grayImage;
    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
    cv::imwrite("gray_output.jpg", grayImage);
    return 0;
}

Flou gaussien

Le flou gaussien est un filtre de flou couramment utilisé qui peut efficacement supprimer le bruit d'une image.

Exemple

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat image = cv::imread("input.jpg");
    cv::Mat blurredImage;
    cv::GaussianBlur(image, blurredImage, cv::Size(15, 15), 0);
    cv::imwrite("blurred_output.jpg", blurredImage);
    return 0;
}

L'exemple suivant implémente une application de filtre d'image qui prend en charge plusieurs effets de filtre (tels que niveaux de gris, flou, détection de contours, etc.).

Exemple

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

using namespace cv;
using namespace std;

int main() {
    // Lire l'image
    Mat image = imread("image.jpg");
    if (image.empty()) {
        cout << "Erreur : Impossible de charger l'image, veuillez vérifier si le chemin est correct." << endl;
        return -1;
    }

    // Convertir en niveaux de gris
    Mat gray;
    cvtColor(image, gray, COLOR_BGR2GRAY);

    // Flou gaussien
    Mat blurred;
    GaussianBlur(image, blurred, Size(15, 15), 0);

    // Détection de contours
    Mat edges;
    Canny(image, edges, 100, 200);

    // Afficher le résultat
    imshow("Image originale", image);
    imshow("Image en niveaux de gris", gray);
    imshow("Image floue", blurred);
    imshow("Contours", edges);

    // Enregistrer le résultat
    imwrite("gray_image.jpg", gray);
    imwrite("blurred_image.jpg", blurred);
    imwrite("edges.jpg", edges);

    waitKey(0);
    return 0;
}

Détection de visages en temps réel

La détection de visages en temps réel est une application importante en vision par ordinateur.

OpenCV fournit un classificateur en cascade Haar pré-entraîné qui peut être utilisé pour détecter des visages dans des images ou des vidéos.

Étapes d'implémentation :

  1. Charger le modèle de classificateur en cascade Haar.

  2. Ouvrir la caméra ou le fichier vidéo.

  3. Effectuer la détection de visage sur chaque image.

  4. Dessiner les résultats de détection et les afficher.

Exemple

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

using namespace cv;
using namespace std;

int main() {
    // Charger le classificateur en cascade Haar
    CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        cout << "Erreur : Impossible de charger le classificateur en cascade Haar !" << endl;
        return -1;
    }

    // Ouvrir la caméra
    VideoCapture cap(0);
    if (!cap.isOpened()) {
        cout << "Erreur : Impossible d'ouvrir la caméra !" << endl;
        return -1;
    }

    // Détecter les visages en temps réel
    Mat frame;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;

        // Convertir en image en niveaux de gris
        Mat gray;
        cvtColor(frame, gray, COLOR_BGR2GRAY);

        // Détecter les visages
        vector<Rect> faces;
        faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, Size(30, 30));

        // Dessiner les résultats de détection
        for (const auto& face : faces) {
            rectangle(frame, face, Scalar(0, 255, 0), 2);
        }

        // Afficher le résultat
        imshow("Détection de visages", frame);

        // Appuyer sur ESC pour quitter
        if (waitKey(30) == 27) break;
    }

    // Libérer les ressources
    cap.release();
    destroyAllWindows();

    return 0;
}

Reconnaissance de plaques d'immatriculation

La reconnaissance des plaques d'immatriculation est l'une des technologies clés des systèmes de transport intelligents.

OpenCV peut être utilisé pour la détection des plaques d'immatriculation et la reconnaissance de caractères.

Exemple

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat image = cv::imread("car.jpg");
    cv::Mat grayImage;
    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);

    cv::CascadeClassifier plateCascade;
    plateCascade.load("haarcascade_russian_plate_number.xml");

    std::vector<cv::Rect> plates;
    plateCascade.detectMultiScale(grayImage, plates, 1.1, 2, 0 | cv::CASCADE_SCALE_IMAGE, cv::Size(30, 30));

    for (const auto& plate : plates) {
        cv::rectangle(image, plate, cv::Scalar(0, 255, 0), 2);
    }

    cv::imwrite("plate_output.jpg", image);
    return 0;
}

Projets complexes

Application de réalité augmentée basée sur OpenCV

La réalité augmentée (RA) est une technologie qui superpose des informations virtuelles au monde réel.

OpenCV peut être utilisé pour implémenter des applications de réalité augmentée simples, telles que la superposition d'objets virtuels sur des images.

Exemple

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat image = cv::imread("background.jpg");
    cv::Mat overlay = cv::imread("overlay.png", cv::IMREAD_UNCHANGED);

    cv::resize(overlay, overlay, cv::Size(100, 100));

    cv::Mat roi = image(cv::Rect(50, 50, overlay.cols, overlay.rows));
    overlay.copyTo(roi, overlay);

    cv::imwrite("ar_output.jpg", image);
    return 0;
}

Vidéosurveillance et détection de mouvement

La vidéosurveillance et la détection de mouvement sont des fonctions importantes dans les systèmes de surveillance de sécurité. OpenCV peut être utilisé pour détecter des objets en mouvement dans des vidéos.

Exemple

#include <opencv2/opencv.hpp>

int main() {
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "Error opening video stream" << std::endl;
        return -1;
    }

    cv::Mat frame, prevFrame, diffFrame;
    cap >> prevFrame;
    cv::cvtColor(prevFrame, prevFrame, cv::COLOR_BGR2GRAY);

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

        cv::Mat grayFrame;
        cv::cvtColor(frame, grayFrame, cv::COLOR_BGR2GRAY);

        cv::absdiff(grayFrame, prevFrame, diffFrame);
        cv::threshold(diffFrame, diffFrame, 30, 255, cv::THRESH_BINARY);

        cv::imshow("Détection de mouvement", diffFrame);
        if (cv::waitKey(1) == 27) break; // Touche ESC pour quitter

        prevFrame = grayFrame.clone();
    }

    cap.release();
    cv::destroyAllWindows();
    return 0;
}

Suivi multi-objets

Le suivi multi-objets est un problème complexe en vision par ordinateur, impliquant le suivi simultané de plusieurs objets dans une vidéo. OpenCV fournit plusieurs algorithmes de suivi, tels que KCF, MIL et CSRT.

Exemple

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

int main() {
    cv::VideoCapture cap("video.mp4");
    if (!cap.isOpened()) {
        std::cerr << "Error opening video stream" << std::endl;
        return -1;
    }

    cv::Ptr<cv::MultiTracker> multiTracker = cv::MultiTracker::create();

    cv::Mat frame;
    cap >> frame;

    std::vector<cv::Rect> bboxes;
    cv::selectROIs("Suivi", frame, bboxes);

    for (const auto& bbox : bboxes) {
        multiTracker->add(cv::TrackerKCF::create(), frame, bbox);
    }

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

        multiTracker->update(frame);

        for (const auto& bbox : multiTracker->getObjects()) {
            cv::rectangle(frame, bbox, cv::Scalar(255, 0, 0), 2);
        }

        cv::imshow("Suivi multi-objets", frame);
        if (cv::waitKey(1) == 27) break; // Touche ESC pour quitter
    }

    cap.release();
    cv::destroyAllWindows();
    return 0;
}

Projets de Deep Learning : Détection d'objets (YOLO)

Utilisez le modèle YOLO pour implémenter la détection d'objets.

Étapes d'implémentation :

  1. Chargez le modèle YOLO et le fichier de configuration.

  2. Chargez les étiquettes de classe.

  3. Prétraitez l'image d'entrée.

  4. Exécutez le modèle et analysez les résultats de détection.

  5. Dessinez des boîtes englobantes et affichez les résultats.

Exemple

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

using namespace cv;
using namespace dnn;
using namespace std;

int main() {
    // Charger le modèle YOLO
    Net net = readNet("yolov3.weights", "yolov3.cfg");
    if (net.empty()) {
        cout << "Erreur : impossible de charger le modèle YOLO !" << endl;
        return -1;
    }

    // Charger les étiquettes de classe
    ifstream classNamesFile("coco.names");
    vector<string> classNames;
    string className;
    while (getline(classNamesFile, className)) {
        classNames.push_back(className);
    }

    // Charger l'image
    Mat image = imread("image.jpg");
    if (image.empty()) {
        cout << "Erreur : Impossible de charger l'image, veuillez vérifier si le chemin est correct." << endl;
        return -1;
    }

    // Prétraiter l'image
    Mat blob = blobFromImage(image, 1 / 255.0, Size(416, 416), Scalar(0, 0, 0), true, false);
    net.setInput(blob);

    // Passe avant
    vector<Mat> outs;
    net.forward(outs, net.getUnconnectedOutLayersNames']());

    // Analyser les résultats de détection
    float confThreshold = 0.5; // Seuil de confiance
    vector<int> classIds;
    vector<float> confidences;
    vector<Rect> boxes;
    for (const auto& output : outs) {
        for (int i = 0; i < output.lignes; i++) {
            Mat scores = output.row(i).colRange(5, output.cols);
            Point classIdPoint;
            double confidence;
            minMaxLoc(scores, nullptr, &confidence, nullptr, &classIdPoint);
            if (confidence > confThreshold) {
                int centerX = static_cast<int>(output.at<float>(i, 0) * image.cols);
                int centerY = static_cast<int>(output.at<float>(i, 1) * image.lignes);
                int width = static_cast<int>(output.at<float>(i, 2) * image.cols);
                int height = static_cast<int>(output.at<float>(i, 3) * image.lignes);
                int left = centerX - width / 2;
                int top = centerY - height / 2;

                classIds.push_back(classIdPoint.x);
                confidences.push_back(static_cast<float>(confidence));
                boxes.push_back(Rect(left, top, width, height));
            }
        }
    }

    // Suppression des non-maxima
    float nmsThreshold = 0.4; // Seuil NMS
    vector<int> indices;
    NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);

    // Dessiner les résultats de détection
    for (int idx : indices) {
        Rect box = boxes[idx];
        rectangle(image, box, Scalar(0, 255, 0), 2);
        string label = format("%s: %.2f", classNames[classIds[idx]].c_str(), confidences[idx]);
        putText(image, label, Point(box.x, box.y - 10), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 2);
    }

    // Afficher le résultat
    imshow("Détection d'objets", image);
    waitKey(0);

    return 0;
}

Projets de traitement vidéo : effets vidéo en temps réel

Implémentez une application d'effets vidéo en temps réel qui prend en charge plusieurs effets (tels que la détection de contours, le flou, l'inversion des couleurs, etc.).

Étapes d'implémentation :

  1. Ouvrir la caméra ou le fichier vidéo.

  2. Appliquez des effets à chaque image.

  3. Affichez la vidéo traitée.

Exemple

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

using namespace cv;
using namespace std;

int main() {
    // Ouvrir la caméra
    VideoCapture cap(0);
    if (!cap.isOpened()) {
        cout << "Erreur : Impossible d'ouvrir la caméra !" << endl;
        return -1;
    }

    // Traiter les images vidéo en temps réel
    Mat frame, edges;
    while (true) {
        cap >> frame;
        if (frame.empty()) break;

        // Détection de contours
        Canny(frame, edges, 100, 200);

        // Afficher le résultat
        imshow("Image originale", frame);
        imshow("Contours", edges);

        // Appuyer sur ESC pour quitter
        if (waitKey(30) == 27) break;
    }

    // Libérer les ressources
    cap.release();
    destroyAllWindows();

    return 0;
}
Autres extensions