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 :
Projets de traitement d'images: tels que les filtres d'images, l'inpainting d'images, l'amélioration d'images, etc.
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.
Projets d'apprentissage profond: tels que la classification d'images, la détection d'objets, la segmentation sémantique, etc.
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
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
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 <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 :
Charger le modèle de classificateur en cascade Haar.
Ouvrir la caméra ou le fichier vidéo.
Effectuer la détection de visage sur chaque image.
Dessiner les résultats de détection et les afficher.
Exemple
#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
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
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
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/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 :
Chargez le modèle YOLO et le fichier de configuration.
Chargez les étiquettes de classe.
Prétraitez l'image d'entrée.
Exécutez le modèle et analysez les résultats de détection.
Dessinez des boîtes englobantes et affichez les résultats.
Exemple
#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 :
Ouvrir la caméra ou le fichier vidéo.
Appliquez des effets à chaque image.
Affichez la vidéo traitée.
Exemple
#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;
}