C++ OpenCV Projektpraxis
OpenCV-Projektpraxis ist der Prozess, theoretisches Wissen auf reale Probleme anzuwenden.
Durch Projektpraxis können Sie Ihre OpenCV-Fähigkeiten festigen und reale Computer-Vision-Probleme lösen.
Im Folgenden finden Sie gängige Arten von OpenCV-Projekten:
Bildverarbeitungsprojekte: wie Bildfilter, Bildinpainting, Bildverbesserung usw.
Projekte zur Objekterkennung und -verfolgung: wie Gesichtserkennung, Kennzeichenerkennung, Verfolgung bewegter Ziele usw.
Deep-Learning-Projekte: wie Bildklassifizierung, Objekterkennung, semantische Segmentierung usw.
Videoverarbeitungsprojekte: wie z. B. Videoanalyse, Echtzeit-Videoverarbeitung, Videoeffekte usw.
Einfache Projekte
Bildfilteranwendung
Bildfilter gehören zu den grundlegenden Operationen der Bildverarbeitung. Durch das Anwenden verschiedener Filter können Sie das Aussehen und den Stil eines Bildes ändern.
OpenCV bietet umfangreiche Funktionen zur Implementierung verschiedener Bildfiltereffekte.
Graustufenfilter
Der Graustufenfilter ist der Prozess der Umwandlung eines Farbbilds in ein Graustufenbild. Ein Graustufenbild hat nur einen Kanal, und der Wert jedes Pixels repräsentiert die Helligkeit.
Beispiel
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;
}
Gaußscher Weichzeichner
Der Gaußsche Weichzeichner ist ein häufig verwendeter Weichzeichner, der Rauschen effektiv aus einem Bild entfernen kann.
Beispiel
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;
}
Das folgende Beispiel implementiert eine Bildfilteranwendung, die mehrere Filtereffekte unterstützt (wie Graustufen, Weichzeichnen, Kantenerkennung usw.).
Beispiel
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Bild einlesen
Mat image = imread("image.jpg");
if (image.empty()) {
cout << "Fehler: Bild kann nicht geladen werden, bitte überprüfen Sie, ob der Pfad korrekt ist." << endl;
return -1;
}
// In Graustufen umwandeln
Mat gray;
cvtColor(image, gray, COLOR_BGR2GRAY);
// Gaußscher Weichzeichner
Mat blurred;
GaussianBlur(image, blurred, Size(15, 15), 0);
// Kantenerkennung
Mat edges;
Canny(image, edges, 100, 200);
// Ergebnis anzeigen
imshow("Originalbild", image);
imshow("Graues Bild", gray);
imshow("Verschwommenes Bild", blurred);
imshow("Kanten", edges);
// Ergebnis speichern
imwrite("gray_image.jpg", gray);
imwrite("blurred_image.jpg", blurred);
imwrite("edges.jpg", edges);
waitKey(0);
return 0;
}
Echtzeit-Gesichtserkennung
Echtzeit-Gesichtserkennung ist eine wichtige Anwendung in der Computer Vision.
OpenCV bietet einen vortrainierten Haar-Cascade-Klassifikator, der zur Erkennung von Gesichtern in Bildern oder Videos verwendet werden kann.
Implementierungsschritte:
Laden Sie das Haar-Cascade-Klassifikator-Modell.
Öffne die Kamera oder die Videodatei.
Führe in jedem Frame eine Gesichtsdetektion durch.
Zeichne die Detektionsergebnisse und zeige sie an.
Beispiel
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Haar-Cascade-Klassifikator laden
CascadeClassifier faceCascade;
if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
cout << "Fehler: Haar-Cascade-Klassifikator konnte nicht geladen werden!" << endl;
return -1;
}
// Kamera öffnen
VideoCapture cap(0);
if (!cap.isOpened()) {
cout << "Fehler: Kamera konnte nicht geöffnet werden!" << endl;
return -1;
}
// Gesichter in Echtzeit erkennen
Mat frame;
while (true) {
cap >> frame;
if (frame.empty()) break;
// In Graustufenbild konvertieren
Mat gray;
cvtColor(frame, gray, COLOR_BGR2GRAY);
// Gesichter erkennen
vector<Rect> faces;
faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, Size(30, 30));
// Erkennungsergebnisse zeichnen
for (const auto& face : faces) {
rectangle(frame, face, Scalar(0, 255, 0), 2);
}
// Ergebnis anzeigen
imshow("Gesichtserkennung", frame);
// ESC zum Beenden drücken
if (waitKey(30) == 27) break;
}
// Ressourcen freigeben
cap.release();
destroyAllWindows();
return 0;
}
Kennzeichenerkennung
Die Kennzeichenerkennung ist eine der Schlüsseltechnologien in intelligenten Verkehrssystemen.
OpenCV kann zur Erkennung von Kennzeichen und zur Zeichenerkennung eingesetzt werden.
Beispiel
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;
}
Komplexe Projekte
OpenCV-basierte AR-Anwendung
Augmented Reality (AR) ist eine Technologie, die virtuelle Informationen in die reale Welt einblendet.
OpenCV kann verwendet werden, um einfache AR-Anwendungen zu implementieren, beispielsweise das Überlagern virtueller Objekte auf Bilder.
Beispiel
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;
}
Videoüberwachung und Bewegungserkennung
Videoüberwachung und Bewegungserkennung sind wichtige Funktionen in Sicherheitsüberwachungssystemen. OpenCV kann verwendet werden, um sich bewegende Objekte in Videos zu erkennen.
Beispiel
int main() {
cv::VideoCapture cap(0);
if (!cap.isOpened()) {
std::cerr << "Fehler beim Öffnen des Videostreams" << 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("Bewegungserkennung", diffFrame);
if (cv::waitKey(1) == 27) break; // ESC-Taste zum Beenden
prevFrame = grayFrame.clone();
}
cap.release();
cv::destroyAllWindows();
return 0;
}
Multi-Objekt-Tracking
Multi-Objekt-Tracking ist ein komplexes Problem in der Computer Vision, das die gleichzeitige Verfolgung mehrerer Objekte in einem Video beinhaltet. OpenCV bietet mehrere Tracking-Algorithmen wie KCF, MIL und CSRT.
Beispiel
#include <opencv2/tracking.hpp>
int main() {
cv::VideoCapture cap("video.mp4");
if (!cap.isOpened()) {
std::cerr << "Fehler beim Öffnen des Videostreams" << std::endl;
return -1;
}
cv::Ptr<cv::MultiTracker> multiTracker = cv::MultiTracker::create();
cv::Mat frame;
cap >> frame;
std::vector<cv::Rect> bboxes;
cv::selectROIs("Tracking", 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("Multi-Objekt-Tracking", frame);
if (cv::waitKey(1) == 27) break; // ESC-Taste zum Beenden
}
cap.release();
cv::destroyAllWindows();
return 0;
}
Deep-Learning-Projekte: Objekterkennung (YOLO)
Verwenden Sie das YOLO-Modell, um die Objekterkennung zu implementieren.
Implementierungsschritte:
Laden Sie das YOLO-Modell und die Konfigurationsdatei.
Laden Sie die Klassenbezeichnungen.
Das Eingabebild vorverarbeiten.
Führen Sie das Modell aus und werten Sie die Erkennungsergebnisse aus.
Zeichnen Sie Bounding-Boxen und zeigen Sie die Ergebnisse an.
Beispiel
#include <opencv2/dnn.hpp>
#include <iostream>
using namespace cv;
using namespace dnn;
using namespace std;
int main() {
// YOLO-Modell laden
Net net = readNet("yolov3.weights", "yolov3.cfg");
if (net.empty()) {
cout << "Fehler: YOLO-Modell konnte nicht geladen werden!" << endl;
return -1;
}
// Klassenlabels laden
ifstream classNamesFile("coco.names");
vector<string> classNames;
string className;
while (getline(classNamesFile, className)) {
classNames.push_back(className);
}
// Bild laden
Mat image = imread("image.jpg");
if (image.empty()) {
cout << "Fehler: Bild kann nicht geladen werden, bitte überprüfen Sie, ob der Pfad korrekt ist." << endl;
return -1;
}
// Bild vorverarbeiten
Mat blob = blobFromImage(image, 1 / 255.0, Size(416, 416), Scalar(0, 0, 0), true, false);
net.setInput(blob);
// Vorwärtsdurchlauf
vector<Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
// Detektionsergebnisse parsen
float confThreshold = 0.5; // Konfidenzschwelle
vector<int> classIds;
vector<float> confidences;
vector<Rect> boxes;
for (const auto& output : outs) {
for (int i = 0; i < output.rows; 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.rows);
int width = static_cast<int>(output.at<float>(i, 2) * image.cols);
int height = static_cast<int>(output.at<float>(i, 3) * image.rows);
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));
}
}
}
// Nicht-Maximum-Unterdrückung
float nmsThreshold = 0.4; // NMS-Schwellenwert
vector<int> indices;
NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
// Erkennungsergebnisse zeichnen
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);
}
// Ergebnis anzeigen
imshow("Objekterkennung", image);
waitKey(0);
return 0;
}
Videoverarbeitungsprojekte: Echtzeit-Videoeffekte
Implementieren Sie eine Echtzeit-Anwendung für Videoeffekte, die mehrere Effekte unterstützt (wie Kantenerkennung, Unschärfe, Farbinversion usw.).
Implementierungsschritte:
Öffne die Kamera oder die Videodatei.
Wenden Sie Effekte auf jedes Einzelbild an.
Zeigen Sie das verarbeitete Video an.
Beispiel
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Kamera öffnen
VideoCapture cap(0);
if (!cap.isOpened()) {
cout << "Fehler: Kamera konnte nicht geöffnet werden!" << endl;
return -1;
}
// Video-Frames in Echtzeit verarbeiten
Mat frame, edges;
while (true) {
cap >> frame;
if (frame.empty()) break;
// Kantenerkennung
Canny(frame, edges, 100, 200);
// Ergebnis anzeigen
imshow("Originalbild", frame);
imshow("Kanten", edges);
// ESC zum Beenden drücken
if (waitKey(30) == 27) break;
}
// Ressourcen freigeben
cap.release();
destroyAllWindows();
return 0;
}