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:
| Algorithmus | Eigenschaften | Geeignete Szenarien |
|---|---|---|
| SIFT | Scale-Invariant Feature Transform, robust gegenüber Rotation, Skalierung und Helligkeitsänderungen. | Bild-Matching, Objekterkennung |
| SURF | Beschleunigte Version von SIFT, schnellere Berechnung, aber etwas weniger robust gegenüber Rotations- und Skalierungsänderungen. | Echtzeit-Bildabgleich |
| ORB | Basiert auf FAST-Schlüsselpunkterkennung und BRIEF-Deskriptoren, schnell und für Echtzeitanwendungen geeignet. | Echtzeit-Bildabgleich, SLAM |
| FAST | Schneller Algorithmus zur Eckenerkennung, erkennt nur Schlüsselpunkte, generiert keine Deskriptoren. | Echtzeit-Eckenerkennung |
| BRIEF | Binärer Deskriptor, schnelle Berechnung, aber weniger robust gegenüber Rotation und Skalierung. | Echtzeit-Bildabgleich |
| AKAZE | Algorithmus 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
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
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/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/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
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/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/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/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/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;
}