Template Matching¶

Schreiben Sie unter Druck
Preise gewinnen
Werde veröffentlicht

Anmeldeschluss ist der 12. April 2019.
Der Wettbewerb 2019 findet vom 20. bis 21. April 2019 statt

Der 2-Tage-Wettbewerb 2019 von CV2 ist beendet.

Theorie

Template Matching ist eine Methode zum Suchen und Finden der Position eines Vorlagenbilds in einem größeren Bild. OpenCV kommt mit einer Funktion cv2.matchTemplate () für diesen Zweck. Das Vorlagenbild wird einfach über das Eingabebild geschoben (wie bei der 2D-Faltung) und die Vorlage und der Patch des Eingabebilds werden unter dem Vorlagenbild verglichen. In OpenCV sind mehrere Vergleichsmethoden implementiert. (Sie können die Dokumente auf weitere Details überprüfen.) Es wird ein Graustufenbild zurückgegeben, bei dem jedes Pixel angibt, wie stark die Nachbarschaft dieses Pixels mit der Vorlage übereinstimmt.

Wenn das Eingabebild die Größe (BxH) und das Vorlagenbild die Größe (BxH) hat, hat das Ausgabebild die Größe (W-W + 1, H-H + 1). Sobald Sie das Ergebnis erhalten haben, können Sie es verwenden cv2.minMaxLoc () Funktion, um herauszufinden, wo sich der Maximal- / Minimalwert befindet. Nehmen Sie es als die linke obere Ecke des Rechtecks ​​und nehmen Sie (B, H) als Breite und Höhe des Rechtecks. Dieses Rechteck ist Ihre Region der Vorlage.

Wenn Sie cv2.TM_SQDIFF als Vergleichsmethode verwenden, ergibt der Mindestwert die beste Übereinstimmung.

Canny¶

Findet Kanten in einem Bild mithilfe des Canny86-Algorithmus.

C ++: vo> Canny (InputArray Bild, OutputArray Kanten, doppelt Schwelle1, doppelt Schwelle2int Öffnungsgröße= 3, bool L2gradient= false) ¶Python: cv2. Canny (Bild, Schwelle1, Schwelle2, Kanten, Blendengröße) → KantenC: vo> cvCanny (const CvArr * Bild, CvArr * Kanten, doppelt Schwelle1, doppelt Schwelle2int Öffnungsgröße= 3) ¶Python: Lebenslauf. Canny (Bild, Kanten, Schwelle1, Schwelle2, Aperturgröße = 3) → Keine

Parameter:
  • Bild - Einkanaliges 8-Bit-Eingangsbild.
  • Kanten - Ausgabekantenkarte, hat die gleiche Größe und den gleichen Typ wie das Bild.
  • Schwelle1 - erste Schwelle für das Hystereseverfahren.
  • Schwelle2 - zweite Schwelle für das Hystereseverfahren.
  • Öffnungsgröße - Blendengröße für den Sobel () Operator.
  • L2gradient - ein Flag, das angibt, ob zur Berechnung des Bildgradienten eine genauere Norm verwendet werden soll (L2gradient = true) oder ob die Standardnorm ausreicht (L2gradient = false).

Die Funktion findet Kanten im Eingabebild und markiert sie mit dem Canny-Algorithmus in den Ausgabebildkanten. Der kleinste Wert zwischen Schwelle1 und Schwelle2 wird für die Kantenverknüpfung verwendet. Der größte Wert wird verwendet, um anfängliche Segmente starker Kanten zu finden. Siehe http://en.wikipedia.org/wiki/Canny_edge_detector

  • Ein Beispiel zur Verwendung des Canny Edge Detectors finden Sie unter opencv_source_code / samples / cpp / edge.cpp
  • (Python) Ein Beispiel zur Verwendung des Canny Edge Detectors finden Sie unter opencv_source_code / samples / python / edge.py

CornerEigenValsAndVecs¶

Berechnet Eigenwerte und Eigenvektoren von Bildblöcken zur Eckendetektion.

C ++: vo> cornerEigenValsAndVecs (InputArray src, OutputArray dstint Block Größeint ksizeint borderType= BORDER_DEFAULT) ¶Python: cv2. cornerEigenValsAndVecs (src, blockSize, ksize, dst) → dst¶C: vo> cvCornerEigenValsAndVecs (const CvArr * Bild, CvArr * eigenvvint Block Größeint Öffnungsgröße= 3) ¶Python: Lebenslauf. CornerEigenValsAndVecs (Bild, Eigenvv, Blockgröße, Aperturgröße = 3) → Keine¶

Parameter:
  • src - Geben Sie ein einkanaliges 8-Bit- oder Gleitkommabild ein.
  • dst - Bild zum Speichern der Ergebnisse. Es hat die gleiche Größe wie src und den Typ CV_32FC (6).
  • Block Größe - Nachbarschaftsgröße (siehe Details unten).
  • ksize - Aperture-Parameter für den Sobel () -Operator.
  • borderType - Pixelextrapolationsmethode. Siehe borderInterpolate ().

Für jedes Pixel ist die Funktion cornerEigenValsAndVecs cons> blockSize blockSize neighbourhood. Es berechnet die Kovariationsmatrix von Derivaten über die Nachbarschaft als:

wobei die Derivate mit dem Sobel () -Operator berechnet werden.

Danach findet es Eigenvektoren und Eigenwerte von und speichert sie im Zielbild als wo

  • sind die nicht sortierten Eigenwerte von
  • sind die Eigenvektoren entsprechend
  • sind die Eigenvektoren entsprechend

Der Ausgang der Funktion kann zur robusten Kanten- oder Eckenerkennung verwendet werden.

  • (Python) Ein Beispiel für die Verwendung von Eigenvektoren und Eigenwerten zur Schätzung der Bildtextur-Flussrichtung finden Sie unter opencv_source_code / samples / python2 / texture_flow.py

CornerHarris¶

Harris-Kantendetektor.

C ++: vo> cornerHarris (InputArray src, OutputArray dstint Block Größeint ksize, doppelt kint borderType= BORDER_DEFAULT) ¶Python: cv2. cornerHarris (src, blockSize, ksize, k, dst) → dst¶C: vo> cvCornerHarris (const CvArr * Bild, CvArr * harris_responseint Block Größeint Öffnungsgröße= 3, doppelt k= 0.04) ¶Python: Lebenslauf. CornerHarris (Bild, harris_dst, Blockgröße, Aperturgröße = 3, k = 0,04) → Keine

Parameter:
  • src - Geben Sie ein einkanaliges 8-Bit- oder Gleitkommabild ein.
  • dst - Bild zum Speichern der Harris-Detektorantworten. Es hat den Typ CV_32FC1 und die gleiche Größe wie src.
  • Block Größe - Nachbarschaftsgröße (siehe Details zu cornerEigenValsAndVecs ()).
  • ksize - Aperture-Parameter für den Sobel () -Operator.
  • k - Harris Detektor frei Parameter. Siehe die Formel unten.
  • borderType - Pixelextrapolationsmethode. Siehe borderInterpolate ().

Mit dieser Funktion wird der Harris-Kantendetektor für das Bild ausgeführt. Ähnlich wie bei cornerMinEigenVal () und cornerEigenValsAndVecs () wird für jedes Pixel eine Gradientenkovarianzmatrix über einer Nachbarschaft berechnet. Dann berechnet es das folgende Merkmal:

Ecken in dem Bild können als die lokalen Maxima dieser Antwortkarte gefunden werden.

CornerMinEigenVal¶

Berechnet den minimalen Eigenwert von Gradientenmatrizen für die Eckendetektion.

C ++: vo> cornerMinEigenVal (InputArray src, OutputArray dstint Block Größeint ksize= 3, int borderType= BORDER_DEFAULT) ¶Python: cv2. cornerMinEigenVal (src, blockSize, dst, ksize) → dst¶C: vo> cvCornerMinEigenVal (const CvArr * Bild, CvArr * eigenvalint Block Größeint Öffnungsgröße= 3) ¶Python: Lebenslauf. CornerMinEigenVal (Bild, Eigenwert, Blockgröße, Aperturgröße = 3) → Keine

Parameter:
  • src - Geben Sie ein einkanaliges 8-Bit- oder Gleitkommabild ein.
  • dst - Bild zum Speichern der minimalen Eigenwerte. Es hat den Typ CV_32FC1 und die gleiche Größe wie src.
  • Block Größe - Größe der Nachbarschaft (siehe Details unter cornerEigenValsAndVecs ()).
  • ksize - Aperture-Parameter für den Sobel () -Operator.
  • borderType - Pixelextrapolationsmethode. Siehe borderInterpolate ().

Die Funktion ähnelt cornerEigenValsAndVecs (), berechnet und speichert jedoch nur den minimalen Eigenwert der Kovarianzmatrix von Derivaten, dh anhand der Formeln in der cornerEigenValsAndVecs () - Beschreibung.

Entstehung

Neues Schreiben und Gespräche über das Entstehen

Viel Spaß! Ein ganz anderes Gedicht als ich normalerweise schreiben würde. Immer wieder interessant zu sehen, was dabei herauskommt!

–Charlotte, beim 2-tägigen Gedichtwettbewerb

CornerSubPix¶

Verfeinert die Eckpositionen.

C ++: vo> cornerSubPix (InputArray Bild, InputOutputArray Ecken, Größe winSize, Größe zeroZone, TermCriteria Kriterien ) ¶Python: cv2. cornerSubPix (Bild, Ecken, WinSize, ZeroZone, Kriterien) → KeineC: vo> cvFindCornerSubPix (const CvArr * Bild, CvPoint2D32f * Eckenint Anzahl, CvSize Sieg, CvSize zero_zone, CvTermCriteria Kriterien ) ¶Python: Lebenslauf. FindCornerSubPix (Bild, Ecken, Gewinn, Zero_Zone, Kriterien) → Ecken

Parameter:
  • Bild - Eingabebild.
  • Ecken - Anfangskoordinaten der Eingabeecken und verfeinerte Koordinaten prov> winSize = Size (5,5), dann wird ein Suchfenster verwendet.
  • zeroZone - Die Hälfte der Größe des toten Bereichs in den m> criter.maxCount-Iterationen oder wenn sich die Eckposition bei einer Iteration um weniger als criter.epsilon bewegt.

Die Funktion iteriert, um die subpixelgenaue Position von Ecken oder radialen Sattelpunkten zu ermitteln, wie in der folgenden Abbildung dargestellt.

Der subpixelgenaue Eckenlokalisierer basiert auf der Beobachtung, dass jeder Vektor von der Mitte zu einem Punkt in der Nähe von orthogonal zum Bildgradienten ist, wenn Bild- und Messrauschen auftreten. Betrachten Sie den Ausdruck:

wo ist ein Bildverlauf an einem der Punkte in einer Nachbarschaft von. Der Wert von ist so zu finden, dass er minimiert wird. Ein Gleichungssystem kann mit Null eingerichtet werden:

wo die Farbverläufe innerhalb eines Stadtviertels ("Suchfenster") von summiert werden. Das Aufrufen des ersten Gradiententerms und des zweiten Gradiententerms ergibt:

Der Algorithmus legt den Mittelpunkt des Nachbarschaftsfensters auf diesen neuen Mittelpunkt fest und iteriert dann, bis der Mittelpunkt innerhalb eines festgelegten Schwellenwerts bleibt.

GoodFeaturesToTrack¶

Bestimmt starke Ecken in einem Bild.

C ++: vo> goodFeaturesToTrack (InputArray Bild, OutputArray Eckenint maxCorners, doppelt Qualitätslevel, doppelt minDistance, InputArray Maske= noArray (), int Block Größe= 3, bool useHarrisDetector= falsch, doppelt k= 0.04) ¶Python: cv2. goodFeaturesToTrack (Bild, maxCorners, qualityLevel, minDistance, Ecken, Maske, BlockSize, useHarrisDetector) → Ecken¶C: vo> cvGoodFeaturesToTrack (const CvArr * Bild, CvArr * eig_image, CvArr * temp_image, CvPoint2D32f * Eckenint * corner_count, doppelt Qualitätslevel, doppelt min_distance, const CvArr * Maske= NULL, int Block Größe= 3, int use_harris= 0, doppelt k= 0.04) ¶Python: Lebenslauf. GoodFeaturesToTrack (image, eigImage, tempImage, cornerCount, qualityLevel, minDistance, mask = None, blockSize = 3, useHarris = 0, k = 0.04) → cornerCount¶

Parameter:
  • Bild - Geben Sie ein 8-Bit- oder ein Gleitkomma-32-Bit-Einkanalbild ein.
  • eig_image - Der Parameter wird ignoriert.
  • temp_image - Der Parameter wird ignoriert.
  • Ecken - Ausgabevektor der erkannten Ecken.
  • maxCorners - Maximale Anzahl der zurückzugebenden Ecken. Gibt es mehr Ecken als gefunden, wird die stärkste zurückgegeben.
  • Qualitätslevel - Parameter, der die minimal akzeptierte Qualität der Bildecken kennzeichnet. Der Parameterwert wird mit dem besten Eckqualitätsmaß multipliziert, bei dem es sich um den minimalen Eigenwert (siehe cornerMinEigenVal ()) oder die Harris-Funktionsantwort (siehe cornerHarris ()) handelt. Die Ecken mit dem Qualitätsmaß kleiner als das Produkt werden verworfen. Wenn beispielsweise die beste Ecke das Qualitätsmaß 1500 und das Qualitätsniveau 0,01 aufweist, werden alle Ecken mit einem Qualitätsmaß von weniger als 15 verworfen.
  • minDistance - Minimum mögliches Eucl> CV_8UC1 und die gleiche Größe wie Bild), spezifiziert den Bereich, in dem die Ecken erkannt werden.
  • Block Größe - Größe eines Durchschnittsblocks zum Berechnen einer abgeleiteten Kovariationsmatrix über jede Pixelumgebung. Siehe cornerEigenValsAndVecs ().
  • useHarrisDetector - Parameter, der angibt, ob ein Harris-Detektor (siehe cornerHarris ()) oder cornerMinEigenVal () verwendet werden soll.
  • k - Freie Parameter des Harris Detektors.

Die Funktion findet die markantesten Ecken im Bild oder im angegebenen Bildbereich, wie in Shi94 beschrieben:

  1. Die Funktion berechnet das Eckqualitätsmaß für jedes Quellbildpixel mit Hilfe von cornerMinEigenVal () oder cornerHarris ().
  2. Die Funktion führt eine Nicht - Maximal - Unterdrückung durch (die lokalen Maximalwerte in 3 x 3 nachbarschaft bleiben erhalten).
  3. Die Ecken mit dem minimalen Eigenwert kleiner als werden verworfen.
  4. Die verbleibenden Ecken werden nach dem Qualitätsmaß in absteigender Reihenfolge sortiert.
  5. Funktion wirft jede Ecke weg, für die es eine stärkere Ecke in einem Abstand von weniger als maxDistance gibt.

Mit dieser Funktion kann ein punktbasierter Tracker eines Objekts initialisiert werden.

Wenn die Funktion mit unterschiedlichen Werten A und B des Parameters qualityLevel und A> aufgerufen wird , der Vektor der zurückgegebenen Ecken mit qualityLevel = A ist das Präfix des Ausgabevektors mit qualityLevel = B.

HoughCircles¶

Findet mit der Hough-Transformation Kreise in einem Graustufenbild.

C ++: vo> HoughCircles (InputArray Bild, OutputArray Kreiseint Methode, doppelt dp, doppelt minDist, doppelt param1= 100, doppelt param2= 100, int minRadius= 0, int maxRadius= 0) ¶C: CvSeq * cvHoughCircles (CvArr * Bildvo>) ¶Python: cv2. HoughCircles (Bild, Methode, dp, minDist, Kreise, param1, param2, minRadius) → Kreise¶

Parameter:
  • Bild - Einkanaliges 8-Bit-Graustufen-Eingabebild.
  • Kreise - Ausgabevektor der gefundenen Kreise. Jeder Vektor wird als 3-Element-Gleitkomma-Vektor codiert.
  • circle_storage - In der C-Funktion ist dies ein Speicher, der die Ausgabesequenz der gefundenen Kreise enthält.
  • Methode - Zu verwendende Erkennungsmethode. Derzeit ist CV_HOUGH_GRADIENT die einzige implementierte Methode 21HT , beschrieben in Yuen90.
  • dp - Inverses Verhältnis der Akkuauflösung zur Bildauflösung. Wenn beispielsweise dp = 1 ist, hat der Akkumulator die gleiche Auflösung wie das Eingabebild. Wenn dp = 2 ist, hat der Akkumulator die Hälfte der Größe w> CV_HOUGH_GRADIENT. Dies ist die höhere Schwelle der beiden, die an den Canny () - Kantendetektor übergeben werden (die untere ist zweimal kleiner).
  • param2 - Zweiter methodenspezifischer Parameter. Im Fall von CV_HOUGH_GRADIENT ist dies die Akkumulatorschwelle für die Kreismittelpunkte in der Erkennungsphase. Je kleiner es ist, desto mehr falsche Kreise können erkannt werden. Kreise, die den größeren Akkumulatorwerten entsprechen, werden zuerst zurückgegeben.
  • minRadius - Mindestkreisradius.
  • maxRadius - Maximaler Kreisradius.

Die Funktion findet mithilfe einer Modifikation der Hough-Transformation Kreise in einem Graustufenbild.

Normalerweise erkennt die Funktion die Zentren von Kreisen gut. Es kann jedoch vorkommen, dass die richtigen Radien nicht gefunden werden. Sie können die Funktion unterstützen, indem Sie den Radiusbereich (minRadius und maxRadius) angeben, wenn Sie ihn kennen. Sie können den zurückgegebenen Radius auch ignorieren, nur den Mittelpunkt verwenden und den richtigen Radius mithilfe eines zusätzlichen Verfahrens ermitteln.

  • Ein Beispiel für die Verwendung des Hough-Kreisdetektors finden Sie unter opencv_source_code / samples / cpp / houghcircles.cpp

HoughLines¶

Findet Linien in einem Binärbild mit der Standard-Hough-Transformation.

C ++: vo> HoughLines (InputArray Bild, OutputArray Linien, doppelt rho, doppelt Thetaint Schwelle, doppelt srn= 0, doppelt stn= 0) ¶Python: cv2. HoughLines (image, rho, theta, threshold, lines, srn) → lines¶C: CvSeq * cvHoughLines2 (CvArr * Bildvo>) ¶Python: Lebenslauf. HoughLines2 (Bild, Speicher, Methode, Rho, Theta, Schwelle, param1 = 0, param2 = 0) → lines¶

Parameter:
  • Bild - Einkanaliges 8-Bit-Binärquellenbild. Das Bild kann durch die Funktion verändert werden.
  • Linien - Ausgabevektor von Linien. Jede Linie wird durch einen Vektor mit zwei Elementen dargestellt. ist der Abstand vom Koordinatenursprung (linke obere Ecke des Bildes). ist der Rotationswinkel der Linie im Bogenmaß ().
  • rho - Entfernungsauflösung des Akkus in Pixel.
  • Theta - Winkelauflösung des Akkus im Bogenmaß.
  • Schwelle - Akkuschwellenparameter. Es werden nur die Zeilen zurückgegeben, die genügend Stimmen erhalten ( texttt"/> ).
  • srn - Für die mehrskalige Hough-Transformation ist dies ein Teiler für die Entfernungsauflösung rho. Die grobe Akkumulatorentfernungsauflösung ist rho und die genaue Akkumulatorauflösung ist rho / srn. Wenn sowohl srn = 0 als auch stn = 0 ist, ist das> Theta.
  • Methode

Eine der folgenden Hough-Transformationsvarianten:

  • CV_HOUGH_STANDARD > Typ CV_32FC2
  • CV_HOUGH_PROBABILISTIC probabilistische Hough-Transformation (effizienter, wenn das Bild einige lange lineare Segmente enthält). Es werden Liniensegmente und nicht die gesamte Linie zurückgegeben. Jedes Segment wird durch Start- und Endpunkte dargestellt, und die Matrix muss vom Typ CV_32SC4 sein (die erstellte Sequenz ist).
  • CV_HOUGH_MULTI_SCALE Multi-Scale-Variante des> CV_HOUGH_STANDARD.
  • param1

    Erster methodenabhängiger Parameter:

    • Für die> srn.
  • param2

    Zweiter methodenabhängiger Parameter:

    • Für die> stn.
  • Die Funktion implementiert den Standard- oder Standard-Multiskalen-Hough-Transformationsalgorithmus für die Linienerkennung. Eine gute Erklärung der Hough-Transformation finden Sie unter http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm. Siehe auch das Beispiel in der Beschreibung von HoughLinesP ().

    • Ein Beispiel für die Verwendung des Hough-Zeilendetektors finden Sie unter opencv_source_code / samples / cpp / houghlines.cpp

    HoughLinesP¶

    Findet Liniensegmente in einem Binärbild mithilfe der probabilistischen Hough-Transformation.

    C ++: vo> HoughLinesP (InputArray Bild, OutputArray Linien, doppelt rho, doppelt Thetaint Schwelle, doppelt minLineLength= 0, doppelt maxLineGap= 0) ¶Python: cv2. HoughLinesP (image, rho, theta, threshold, lines, minLineLength) → lines¶

    Parameter:
    • Bild - Einkanaliges 8-Bit-Binärquellenbild. Das Bild kann durch die Funktion verändert werden.
    • Linien - Ausgabevektor von Linien. Jede Linie wird durch einen Vektor mit 4 Elementen dargestellt, wobei und die Endpunkte jedes erkannten Liniensegments sind.
    • rho - Entfernungsauflösung des Akkus in Pixel.
    • Theta - Winkelauflösung des Akkus im Bogenmaß.
    • Schwelle - Akkuschwellenparameter. Es werden nur die Zeilen zurückgegeben, die genügend Stimmen erhalten ( texttt"/> ).
    • minLineLength - Minimale Leitungslänge. Kürzere Liniensegmente werden verworfen.
    • maxLineGap - Maximal zulässige Lücke zwischen Punkten auf derselben Linie, um sie zu verbinden.

    Die Funktion implementiert den in Matas00 beschriebenen probabilistischen Hough-Transformationsalgorithmus zur Linienerkennung. Siehe das Beispiel zur Linienerkennung unten:

    Dies ist ein Beispielbild, für das die Funktionsparameter optimiert wurden:

    Und dies ist die Ausgabe des obigen Programms im Fall der probabilistischen Hough-Transformation:

    PreCornerDetect¶

    Berechnet eine Feature-Map für die Eckenerkennung.

    C ++: vo> preCornerDetect (InputArray src, OutputArray dstint ksizeint borderType= BORDER_DEFAULT) ¶Python: cv2. preCornerDetect (src, ksize, dst) → dst¶C: vo> cvPreCornerDetect (const CvArr * Bild, CvArr * Eckenint Öffnungsgröße= 3) ¶Python: Lebenslauf. PreCornerDetect (Bild, Ecken, Aperturgröße = 3) → Keine

    Parameter:
    • src - Quelle einkanaliges 8-Bit-Gleitkommabild.
    • dst - Das Ausgabebild hat den Typ CV_32F und die gleiche Größe wie src.
    • ksize - Öffnungsgröße des Sobel ().
    • borderType - Pixelextrapolationsmethode. Siehe borderInterpolate ().

    Die Funktion berechnet die komplexe räumliche Ableitungsfunktion des Quellbilds

    wo,: math: D_y sind die ersten Bildableitungen,,: math: D_ sind die zweiten Bildableitungen und ist die gemischte Ableitung.

    Die Ecken können wie unten gezeigt als lokale Maxima der Funktionen gefunden werden: