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:

  1. Bildverarbeitungsprojekte: wie Bildfilter, Bildinpainting, Bildverbesserung usw.

  2. Projekte zur Objekterkennung und -verfolgung: wie Gesichtserkennung, Kennzeichenerkennung, Verfolgung bewegter Ziele usw.

  3. Deep-Learning-Projekte: wie Bildklassifizierung, Objekterkennung, semantische Segmentierung usw.

  4. 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

#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;
}

Gaußscher Weichzeichner

Der Gaußsche Weichzeichner ist ein häufig verwendeter Weichzeichner, der Rauschen effektiv aus einem Bild entfernen kann.

Beispiel

#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;
}

Das folgende Beispiel implementiert eine Bildfilteranwendung, die mehrere Filtereffekte unterstützt (wie Graustufen, Weichzeichnen, Kantenerkennung usw.).

Beispiel

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

  1. Laden Sie das Haar-Cascade-Klassifikator-Modell.

  2. Öffne die Kamera oder die Videodatei.

  3. Führe in jedem Frame eine Gesichtsdetektion durch.

  4. Zeichne die Detektionsergebnisse und zeige sie an.

Beispiel

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

#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;
}

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

#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;
}

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

#include <opencv2/opencv.hpp>

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

  1. Laden Sie das YOLO-Modell und die Konfigurationsdatei.

  2. Laden Sie die Klassenbezeichnungen.

  3. Das Eingabebild vorverarbeiten.

  4. Führen Sie das Modell aus und werten Sie die Erkennungsergebnisse aus.

  5. Zeichnen Sie Bounding-Boxen und zeigen Sie die Ergebnisse an.

Beispiel

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

  1. Öffne die Kamera oder die Videodatei.

  2. Wenden Sie Effekte auf jedes Einzelbild an.

  3. Zeigen Sie das verarbeitete Video an.

Beispiel

#include <opencv2/opencv.hpp>
#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;
}
Andere Erweiterungen