Der Vorlagenabgleich ist eine Technik zum Auffinden von Bereichen eines Bildes, die einem Patch (Vorlage) ähnlich sind.
Ein Patch ist ein kleines Bild mit bestimmten Funktionen. Das Ziel des Vorlagenabgleichs besteht darin, den Patch / die Vorlage in einem Bild zu finden.
Um es zu finden, muss der Benutzer zwei Eingabebilder angeben:  Quellbild (S)  - Das Bild, in dem die Vorlage gefunden werden soll, und  Vorlagenbild (T) - Das Bild, das im Quellbild gefunden werden soll.

  • Dies ist im Grunde eine Methode zum Suchen und Finden der Position eines Vorlagenbilds in einem größeren Bild.
  • Die Idee hier ist, identische Bereiche eines Bildes zu finden, die mit einer von uns bereitgestellten Vorlage übereinstimmen, und einen Schwellenwert anzugeben
    • Der Schwellenwert hängt von der Genauigkeit ab, mit der die Vorlage im Quellbild erkannt werden soll.
    • Wenn wir beispielsweise die Gesichtserkennung anwenden und die Augen einer Person erkennen möchten, können wir ein zufälliges Bild eines Auges als Vorlage bereitstellen und die Quelle (das Gesicht einer Person) durchsuchen.
    • In diesem Fall wird das Auge erkannt, da „Augen“ von Person zu Person große Unterschiede aufweisen, selbst wenn wir den Schwellenwert auf 50% (0,5) festlegen.
    • In Fällen, in denen nahezu identische Vorlagen durchsucht werden sollen, sollte der Schwellenwert hoch eingestellt werden (t> = 0,8).

Wie funktioniert Template Matching?

  • Das Vorlagenbild wird einfach über das Eingabebild verschoben (wie bei der 2D-Faltung).
  • Die Vorlage und der Patch des Eingabebilds unter dem Vorlagenbild werden verglichen.
  • Das erhaltene Ergebnis wird mit dem Schwellenwert verglichen.
  • Wenn das Ergebnis größer als der Schwellenwert ist, wird der Teil als erkannt markiert.
  • In der Funktion cv2.matchTemplate (img_gray, template, cv2.TM_CCOEFF_NORMED) ist der erste Parameter das Hauptbild, der zweite Parameter die zu vergleichende Vorlage und der dritte Parameter die Methode zum Abgleichen.
import cv2 
import numpy as np 
  
img_rgb = cv2.imread('mainimage.jpg'). 
  
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY) 
  
template = cv2.imread('template',0) 
  
w, h = template.shape[::-1] 
  
res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED) 
  
threshold = 0.8
  
loc = np.where( res >= threshold)  
  
for pt in zip(*loc[::-1]): 
    cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,255,255), 2) 
  
cv2.imshow('Detected',img_rgb)

Einschränkungen der Vorlagenübereinstimmung:

  1. Mustervorkommen müssen die Ausrichtung des Referenzmusterbildes (Vorlage) beibehalten.
  2. Infolgedessen funktioniert es nicht für gedrehte oder skalierte Versionen der Vorlage, da eine Änderung der Form / Größe / Scherung usw. der Objekt-WRT-Vorlage eine falsche Übereinstimmung ergibt.
  3. Das Verfahren ist ineffizient, wenn das Musterkorrelationsbild für mittlere bis große Bilder berechnet wird, da der Prozess zeitaufwändig ist.

Um das Problem zu vermeiden, das durch die unterschiedlichen Größen der Vorlage und des Originalbilds verursacht wird, können wir Multiscaling verwenden . Nur wenn die Abmessungen Ihrer Vorlage nicht mit den Abmessungen des Bereichs in dem Bild übereinstimmen, mit dem Sie übereinstimmen möchten, bedeutet dies nicht, dass Sie keine Vorlagenübereinstimmung anwenden können.

Multiskalierungsmechanismus beim Vorlagenabgleich



Der Prozess der Mehrfachskalierung ist wie folgt:

  1. Durchlaufen Sie das Eingabebild in mehreren Maßstäben (dh machen Sie das Eingabebild immer kleiner).
  2. Wenden Sie die Vorlagenübereinstimmung mit cv2.matchTemplate an und verfolgen Sie die Übereinstimmung mit dem größten Korrelationskoeffizienten (zusammen mit den x, y-Koordinaten der Region mit dem größten Korrelationskoeffizienten).
  3. Nehmen Sie nach dem Durchlaufen aller Skalen die Region mit dem größten Korrelationskoeffizienten und verwenden Sie diese als Ihre „angepasste“ Region.
import cv2 
import numpy as np 
   
img_rgb = cv2.imread('mainimage.jpg') 
   
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY) 
   
template = cv2.imread('template',0) 
   
w, h = template.shape[::-1] 
found = None
  
for scale in np.linspace(0.2, 1.0, 20)[::-1]: 
  
    
    
    resized = imutils.resize(img_gray, width = int(img_gray.shape[1] * scale)) 
    r = img_gray.shape[1] / float(resized.shape[1]) 
   
    
    
    
    
    
    
    
    
    if resized.shape[0] < h or resized.shape[1] < w: 
            break
    found = (maxVal, maxLoc, r) 
   
(_, maxLoc, r) = found 
(startX, startY) = (int(maxLoc[0] * r), int(maxLoc[1] * r)) 
(endX, endY) = (int((maxLoc[0] + tW) * r), int((maxLoc[1] + tH) * r)) 
  
cv2.rectangle(image, (startX, startY), (endX, endY), (0, 0, 255), 2) 
cv2.imshow("Image", image) 
cv2.waitKey(0)

Schrittweise Erklärung des obigen Codes:

  • Nachdem wir die Breite und Höhe der Vorlage in w und r gespeichert haben, initialisieren wir eine Variable, die gefunden wurde, um den Bereich und den Maßstab des Bildes mit der besten Übereinstimmung zu verfolgen. Von dort aus beginnen wir mit der Funktion np.linspace, die mehreren Skalen des Bildes zu durchlaufen. Diese Funktion akzeptiert drei Argumente, den Startwert, den Endwert und die Anzahl gleicher Chunk-Slices dazwischen. In diesem Beispiel gehen wir von 100% der Originalgröße des Bildes aus und arbeiten uns in 20 gleich großen Prozentblöcken auf 20% der Originalgröße herunter.
  • Anschließend ändern wir die Größe des Bildes entsprechend dem aktuellen Maßstab und berechnen das Verhältnis der alten zur neuen Breite. Wie Sie später sehen werden, ist es wichtig, dass wir dieses Verhältnis verfolgen. Wir überprüfen, ob das Eingabebild größer ist als unser Vorlagenabgleich. Wenn die Vorlage größer ist, gibt unser Aufruf cv2.matchTemplate einen Fehler aus, sodass wir in diesem Fall einfach aus der Schleife ausbrechen.
  • An dieser Stelle können wir den Vorlagenabgleich auf unser verkleinertes Bild anwenden:
    • Die Funktion cv2.minMaxLoc verwendet unser Korrelationsergebnis und gibt ein 4-Tupel zurück, das den minimalen Korrelationswert, den maximalen Korrelationswert, die (x, y) -Koordinate des minimalen Werts und die (x, y) -Koordinate von enthält der Maximalwert. Wir interessieren uns nur für den Maximalwert und die (x, y) -Koordinate, also behalten wir die Maxima bei und verwerfen die Minima.
  • Danach untersuchen wir die Bereiche des Bildes, die bei jeder Iteration der Skala übereinstimmen. Von dort aus aktualisieren wir unsere gefundene gefundene Variable, um den bisher gefundenen maximalen Korrelationswert, die (x, y) -Koordinate des Maximalwerts, zusammen mit dem Verhältnis der ursprünglichen Bildbreite zur aktuellen Bildbreite in der Größe zu verfolgen .
  • Nachdem wir alle Skalen des Bildes durchlaufen haben, entpacken wir unsere gefundene Variable und berechnen dann unsere Start- und Endkoordinaten (x, y) unseres Begrenzungsrahmens. Es wird besonders darauf geachtet, die Koordinaten des Begrenzungsrahmens mit dem Verhältnis zu multiplizieren, um sicherzustellen, dass die Koordinaten mit den ursprünglichen Abmessungen des Eingabebildes übereinstimmen.
  • Schließlich zeichnen wir unseren Begrenzungsrahmen und zeigen ihn auf unserem Bildschirm an.

Dieser Artikel wurde von Pratima Upadhyay verfasst . Wenn Ihnen GeeksforGeeks gefällt und Sie einen Beitrag leisten möchten, können Sie auch einen Artikel mit Contrib.geeksforgeeks.org schreiben oder Ihren Artikel an Contribute@geeksforgeeks.org senden . Sehen Sie sich Ihren Artikel auf der GeeksforGeeks-Hauptseite an und helfen Sie anderen Geeks.

Bitte schreiben Sie Kommentare, wenn Sie etwas Falsches finden oder weitere Informationen zu dem oben diskutierten Thema teilen möchten.