Merkmalserkennung und -beschreibung mit C++ OpenCV

Merkmalserkennung und -beschreibung ist eine Kerntechnologie im Bereich Computer Vision, die verwendet wird, um Schlüsselpunkte aus Bildern zu extrahieren und ihre Deskriptoren zu berechnen. Diese Schlüsselpunkte und Deskriptoren können für Aufgaben wie Bildabgleich, Objekterkennung und 3D-Rekonstruktion verwendet werden.

Hauptschritte

  • Merkmalserkennung: Erkennt Schlüsselpunkte in einem Bild (wie Ecken, Kanten usw.).

  • Merkmalsbeschreibung: Berechnet einen Deskriptor für jeden Schlüsselpunkt, um die lokalen Merkmale um den Schlüsselpunkt herum darzustellen.

  • Merkmalsabgleich: Findet ähnliche Schlüsselpunkte in verschiedenen Bildern durch Vergleich von Deskriptoren.

  • Merkmalserkennung und -beschreibung: Findet ähnliche Schlüsselpunkte in zwei Bildern durch Merkmalsabgleich, verwendet für Bildzusammenfügung, Panoramaerstellung usw.
  • Objekterkennung: Extrahiert Merkmale aus dem Zielbild, gleicht sie mit Merkmalen in der Datenbank ab und erreicht die Objekterkennung.
  • 3D-Rekonstruktion: Berechnet die Kamerapose und rekonstruiert eine 3D-Szene durch Abgleich von Merkmalspunkten in Multi-View-Bildern.
  • Echtzeit-Tracking: Erkennt und verfolgt Merkmalspunkte in Videosequenzen, verwendet in Anwendungen wie SLAM (Simultaneous Localization and Mapping).

Gängige Algorithmen zur Merkmalserkennung und -beschreibung

OpenCV bietet eine Vielzahl von Algorithmen zur Merkmalserkennung und -beschreibung. Im Folgenden sind einige gängige aufgeführt:

AlgorithmusEigenschaftenGeeignete Szenarien
SIFTScale-Invariant Feature Transform, robust gegenüber Rotation, Skalierung und Helligkeitsänderungen.Bild-Matching, Objekterkennung
SURFBeschleunigte Version von SIFT, schnellere Berechnung, aber etwas weniger robust gegenüber Rotations- und Skalierungsänderungen.Echtzeit-Bildabgleich
ORBBasiert auf FAST-Schlüsselpunkterkennung und BRIEF-Deskriptoren, schnell und für Echtzeitanwendungen geeignet.Echtzeit-Bildabgleich, SLAM
FASTSchneller Algorithmus zur Eckenerkennung, erkennt nur Schlüsselpunkte, generiert keine Deskriptoren.Echtzeit-Eckenerkennung
BRIEFBinärer Deskriptor, schnelle Berechnung, aber weniger robust gegenüber Rotation und Skalierung.Echtzeit-Bildabgleich
AKAZEAlgorithmus zur Merkmalserkennung und -beschreibung basierend auf nichtlinearem Skalenraum, robust gegenüber Rotation und Skalierung.Bild-Matching, Objekterkennung

Eckenerkennung

Ecken sind Punkte in einem Bild, an denen sich die Helligkeit stark ändert, und befinden sich normalerweise an Objektkanten oder texturreichen Bereichen. Die Eckenerkennung ist die Grundlage der Merkmalserkennung. Häufige Eckenerkennungsalgorithmen sind die Harris-Eckenerkennung und die Shi-Tomasi-Eckenerkennung.

Harris-Eckenerkennung

Die Harris-Eckenerkennung ist ein klassischer Eckenerkennungsalgorithmus. Sie bestimmt, ob ein Pixel eine Ecke ist, indem sie die Autokorrelationsmatrix für jedes Pixel im Bild berechnet. Die Eigenwerte der Autokorrelationsmatrix spiegeln die lokale Struktur des Pixels wider: Sind beide Eigenwerte groß, ist das Pixel wahrscheinlich eine Ecke; ist ein Eigenwert groß und der andere klein, könnte das Pixel eine Kante sein; sind beide Eigenwerte klein, könnte sich das Pixel in einem flachen Bereich befinden.

In OpenCV können Sie diecv::cornerHarrisFunktion zur Implementierung der Harris-Eckenerkennung verwenden:

Beispiel

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat dst, dst_norm;

    // Harris-Eckenerkennung
    cv::cornerHarris(src, dst, 2, 3, 0.04);

    // Ergebnis normalisieren und anzeigen
    cv::normalize(dst, dst_norm, 0, 255, cv::NORM_MINMAX, CV_32FC1, cv::Mat());
    cv::imshow("Harris-Ecken", dst_norm);
    cv::waitKey(0);

    return 0;
}

Shi-Tomasi-Eckenerkennung

Die Shi-Tomasi-Eckenerkennung ist eine Verbesserung gegenüber der Harris-Eckenerkennung. Sie bestimmt, ob ein Pixel eine Ecke ist, indem sie den minimalen Eigenwert für jedes Pixel im Bild berechnet. Im Vergleich zur Harris-Eckenerkennung ist die Shi-Tomasi-Eckenerkennung stabiler und erfordert weniger Berechnungen.

In OpenCV können Sie diecv::goodFeaturesToTrackFunktion zur Implementierung der Shi-Tomasi-Eckenerkennung:

Beispiel

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::Point2f> corners;

    // Shi-Tomasi-Eckenerkennung
    cv::goodFeaturesToTrack(src, corners, 100, 0.01, 10);

    // Ecken zeichnen
    for (size_t i = 0; i < corners.size(); i++) {
        cv::circle(src, corners[i], 5, cv::Skalar(0, 0, 255), 2);
    }

    cv::imshow("Shi-Tomasi-Ecken", src);
    cv::waitKey(0);

    return 0;
}

Merkmalspunkterkennung

Die Merkmalspunkterkennung ist die Extraktion von Punkten mit charakteristischen Eigenschaften in einem Bild. Diese Punkte sind üblicherweise invariant gegenüber Rotation, Skalierung und Beleuchtung. Gängige Algorithmen zur Merkmalspunkterkennung umfassen SIFT, SURF und ORB.

SIFT-Algorithmus

SIFT (Scale-Invariant Feature Transform) ist ein Algorithmus zur Merkmalspunkterkennung basierend auf dem Skalenraum. Er ist invariant gegenüber Bildrotation, Skalierung und Helligkeitsänderungen. Der SIFT-Algorithmus erkennt Extrempunkte in einem Bild und berechnet Gradientenorientierungshistogramme für diese Punkte, um Merkmalsdeskriptoren zu erzeugen.

In OpenCV können Sie diecv::xfeatures2d::SIFTKlasse zur Implementierung der SIFT-Merkmalspunkterkennung:

Beispiel

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

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints;
    cv::Mat descriptors;

    // SIFT-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SIFT> sift = cv::xfeatures2d::SIFT::create();
    sift->detectAndCompute(src, cv::noArray(), keypoints, descriptors);

    // Merkmalspunkte zeichnen
    cv::Mat output;
    cv::drawKeypoints(src, keypoints, output);
    cv::imshow("SIFT-Merkmalspunkte", output);
    cv::waitKey(0);

    return 0;
}

SURF-Algorithmus

SURF (Speeded-Up Robust Features) ist eine Verbesserung gegenüber dem SIFT-Algorithmus. Es verwendet Integralbilder und die Hesse-Matrix, um den Prozess der Merkmalspunkterkennung zu beschleunigen. Der SURF-Algorithmus verbessert die Rechengeschwindigkeit erheblich und behält dabei eine hohe Erkennungsgenauigkeit bei.

In OpenCV können Sie diecv::xfeatures2d::SURFKlasse zur Implementierung der SURF-Merkmalspunkterkennung:

Beispiel

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

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints;
    cv::Mat descriptors;

    // SURF-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SURF> surf = cv::xfeatures2d::SURF::create();
    surf->detectAndCompute(src, cv::noArray(), keypoints, descriptors);

    // Merkmalspunkte zeichnen
    cv::Mat output;
    cv::drawKeypoints(src, keypoints, output);
    cv::imshow("SURF-Schlüsselpunkte", output);
    cv::waitKey(0);

    return 0;
}

ORB-Algorithmus

ORB (Oriented FAST and Rotated BRIEF) ist ein Merkmalspunkterkennungsalgorithmus, der FAST-Eckenerkennung und den BRIEF-Deskriptor kombiniert. Der ORB-Algorithmus hat eine hohe Recheneffizienz und ist für Echtzeitanwendungen geeignet.

In OpenCV können Sie diecv::ORBKlasse zur Implementierung der ORB-Merkmalspunkterkennung:

Beispiel

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints;
    cv::Mat descriptors;

    // ORB-Merkmalspunkterkennung
    cv::Ptr<cv::ORB> orb = cv::ORB::create();
    orb->detectAndCompute(src, cv::noArray(), keypoints, descriptors);

    // Merkmalspunkte zeichnen
    cv::Mat output;
    cv::drawKeypoints(src, keypoints, output);
    cv::imshow("ORB-Schlüsselpunkte", output);
    cv::waitKey(0);

    return 0;
}

Merkmalsabgleich

Merkmalsabgleich ist der Prozess, bei dem Merkmalspunkte zwischen zwei Bildern abgeglichen werden. Zu den gängigen Algorithmen für den Merkmalsabgleich gehören BFMatcher (Brute-Force Matcher) und der FLANN-Matcher.

BFMatcher

BFMatcher (Brute-Force Matcher) ist ein einfacher Algorithmus für den Merkmalsabgleich, der die besten übereinstimmenden Punkte findet, indem er die euklidische Distanz zwischen Merkmalsdeskriptoren berechnet. BFMatcher eignet sich für Fälle mit einer kleinen Anzahl an Merkmalspunkten.

In OpenCV können Sie diecv::BFMatcherKlasse zur Implementierung von BFMatcher:

Beispiel

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

int main() {
    cv::Mat src1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;

    // SIFT-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SIFT> sift = cv::xfeatures2d::SIFT::create();
    sift->detectAndCompute(src1, cv::noArray(), keypoints1, descriptors1);
    sift->detectAndCompute(src2, cv::noArray(), keypoints2, descriptors2);

    // BFMatcher-Abgleich
    cv::BFMatcher matcher(cv::NORM_L2);
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);

    // Matching-Ergebnisse zeichnen
    cv::Mat output;
    cv::drawMatches(src1, keypoints1, src2, keypoints2, matches, output);
    cv::imshow("BFMatcher-Übereinstimmungen", output);
    cv::waitKey(0);

    return 0;
}

FLANN-Matcher

FLANN (Fast Library for Approximate Nearest Neighbors) ist ein Algorithmus zur approximierten Nächste-Nachbarn-Suche, der den Feature-Matching-Prozess beschleunigt, indem er KD-Bäume oder K-Means-Bäume aufbaut. Der FLANN-Matcher eignet sich für Fälle mit einer großen Anzahl von Merkmalspunkten.

In OpenCV können Sie diecv::FlannBasedMatcherKlasse zur Implementierung des FLANN-Matchers:

Beispiel

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

int main() {
    cv::Mat src1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;

    // SIFT-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SIFT> sift = cv::xfeatures2d::SIFT::create();
    sift->detectAndCompute(src1, cv::noArray(), keypoints1, descriptors1);
    sift->detectAndCompute(src2, cv::noArray(), keypoints2, descriptors2);

    // FLANN-Matcher
    cv::FlannBasedMatcher matcher;
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);

    // Matching-Ergebnisse zeichnen
    cv::Mat output;
    cv::drawMatches(src1, keypoints1, src2, keypoints2, matches, output);
    cv::imshow("FLANN-Übereinstimmungen", output);
    cv::waitKey(0);

    return 0;
}

Merkmalspunkt-Matching und Filterung

In praktischen Anwendungen können die Ergebnisse des Merkmalspunkt-Matchings einige fehlerhafte Übereinstimmungspaare enthalten. Um die Matching-Genauigkeit zu verbessern, ist es üblicherweise erforderlich, die Matching-Ergebnisse zu filtern. Häufige Filtermethoden umfassen distanzbasierte Filterung und Filterung auf Basis geometrischer Randbedingungen.

Distanzbasierte Filterung

Die distanzbasierte Filterung entfernt Übereinstimmungspaare mit größeren Abständen durch Festlegen eines Schwellenwerts. In OpenCV können Sie diecv::DescriptorMatcher::radiusMatchFunktion verwenden, um die distanzbasierte Filterung zu implementieren.

Beispiel

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

int main() {
    cv::Mat src1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;

    // SIFT-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SIFT> sift = cv::xfeatures2d::SIFT::create();
    sift->detectAndCompute(src1, cv::noArray(), keypoints1, descriptors1);
    sift->detectAndCompute(src2, cv::noArray(), keypoints2, descriptors2);

    // BFMatcher-Abgleich
    cv::BFMatcher matcher(cv::NORM_L2);
    std::vector<std::vector<cv::DMatch>> matches;
    matcher.radiusMatch(descriptors1, descriptors2, matches, 50.0);

    // Matching-Ergebnisse zeichnen
    cv::Mat output;
    cv::drawMatches(src1, keypoints1, src2, keypoints2, matches, output);
    cv::imshow("Gefilterte Übereinstimmungen", output);
    cv::waitKey(0);

    return 0;
}

Filterung auf Basis geometrischer Randbedingungen

Die Filterung auf Basis geometrischer Randbedingungen entfernt Übereinstimmungspaare, die geometrische Randbedingungen nicht erfüllen, indem die Fundamentalmatrix oder Homographiematrix berechnet wird. In OpenCV können Sie diecv::findFundamentalMatodercv::findHomographyFunktion verwenden, um die Filterung auf Basis geometrischer Randbedingungen zu implementieren.

Beispiel

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

int main() {
    cv::Mat src1 = cv::imread("image1.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat src2 = cv::imread("image2.jpg", cv::IMREAD_GRAYSCALE);
    std::vector<cv::KeyPoint> keypoints1, keypoints2;
    cv::Mat descriptors1, descriptors2;

    // SIFT-Merkmalspunkterkennung
    cv::Ptr<cv::xfeatures2d::SIFT> sift = cv::xfeatures2d::SIFT::create();
    sift->detectAndCompute(src1, cv::noArray(), keypoints1, descriptors1);
    sift->detectAndCompute(src2, cv::noArray(), keypoints2, descriptors2);

    // BFMatcher-Abgleich
    cv::BFMatcher matcher(cv::NORM_L2);
    std::vector<cv::DMatch> matches;
    matcher.match(descriptors1, descriptors2, matches);

    // Filterung auf Basis geometrischer Randbedingungen
    std::vector<cv::Point2f> points1, points2;
    for (size_t i = 0; i < matches.size(); i++) {
        points1.push_back(keypoints1[matches[i].queryIdx].pt);
        points2.push_back(keypoints2[matches[i].trainIdx].pt);
    }

    cv::Mat mask;
    cv::findHomography(points1, points2, cv::RANSAC, 3, mask);

    // Passende Paare filtern
    std::vector<cv::DMatch> good_matches;
    for (size_t i = 0; i < matches.size(); i++) {
        if (mask.at<uchar>(i)) {
            good_matches.push_back(matches[i]);
        }
    }

    // Matching-Ergebnisse zeichnen
    cv::Mat output;
    cv::drawMatches(src1, keypoints1, src2, keypoints2, good_matches, output);
    cv::imshow("Gefilterte Übereinstimmungen", output);
    cv::waitKey(0);

    return 0;
}
Andere Erweiterungen