[PYTHON] Erstellen Sie mit Jetson Nano + USB-Kamera + OpenCV + Scikit-Bild ein System zur Messung der Subpixelgenauigkeit

Ich habe ein Python-Skript geschrieben, das die Subpixel-Genauigkeit mit Jetson Nano + USB-Kamera + OpenCV + Scikit-Bild misst. Nicht nur auf Jetson Nano beschränkt, wenn Python ausgeführt wird, funktioniert es auf Raspberry Pi.

Verwenden Sie die Phasenkorrelation, um Subpixel für die Koordinaten zu suchen, die durch Vorlagenabgleich gefunden wurden. Die Reproduzierbarkeit ist ziemlich gut, aber die Linearität hängt vom Objektiv ab.

Sie können das Skript herunterladen von: https://github.com/takurot/templatematch

Ausführungsumgebung

Ausführungsbeispiel

Erforderliche Module

OpenCV Scikit-image Numpy Matplot

Ausführungsverfahren

1. Setzen Sie das Vorlagenziel in den □ Cursor auf dem Bildschirm + ESC
2. Kontinuierliche Messausführung auf dem Bildschirm. □ Der Cursor wird dort gezeichnet, wo sich das Vorlagenbild befindet
3. Die print-Anweisung gibt die Ausführungszeit und die Pixelkoordinaten oben links als (0,0) aus.

Codekommentar

templatematch.py

def main():
    TEMPLATE_SIZE = 32
    capture = cv2.VideoCapture(0)

↑ Es heißt TEMPLATE_SIZE, aber die tatsächliche Größe ist doppelt 64 Erfassen Sie Bilder von einer USB-Kamera mit cv2.VideoCapture (0) Angenommen, die Kamera befindet sich an Port 0

templatematch.py

    while True:
        ret, org_img = capture.read()
        img = cv2.resize(org_img, dsize=None, fx=0.5, fy=0.5)

↑ Die Größe des Bildes wird durch fx und fy bestimmt. Die ursprüngliche Größe beträgt 1280 x 960, die Größe wurde jedoch auf 640 x 480 geändert. Ich habe die Größe so geändert, dass die Verarbeitungszeit angemessen ist, aber die Größe selbst kann beliebig eingestellt werden. Je kleiner das Bild, desto schneller.

templatematch.py

        height, width, channnel = img.shape[:3]
        
        y1 = int(height/2-TEMPLATE_SIZE)
        y2 = int(height/2+TEMPLATE_SIZE)
        x1 = int(width/2-TEMPLATE_SIZE)
        x2 = int(width/2+TEMPLATE_SIZE)
        # print(width, height, x1, x2, y1, y2)
        if ret != True:
            print("Error1")
            return
        disp = cv2.rectangle(img, (x1, y1), (x2, y2), (0, 0, 255), 3)
        cv2.imshow("Select Template(Size 64x64) Press ESC", disp)
        key = cv2.waitKey(10)
        if key == 27: # ESC 
            break

↑ Die Koordinaten zum Zeichnen des □ Cursors auf der Vorlage werden basierend auf der Bildmitte berechnet und angezeigt. Drücken Sie ESC, um die Vorlagenregistrierung abzuschließen.

templatematch.py

    image = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    template = image[y1:y2, x1:x2]

    cv2.imshow("Template-2", template)

↑ Das als Vorlage registrierte Bild wird in Schwarzweiß konvertiert und angezeigt.

templatematch.py

    while True:
        time_start = time.time()
        ret, org_img2 = capture.read()
        if ret != True:
            print("Error2")
            return
        img2 = cv2.resize(org_img2, dsize=None, fx=0.5, fy=0.5)
        offset_image = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)
        time_cap = int((time.time() - time_start) * 1000)

↑ Ändern Sie die Größe des gemessenen Bildes und konvertieren Sie es in Schwarzweiß. Die Messung erfolgt in Schwarzweiß.

templatematch.py

        time_start = time.time()
        result = match_template(offset_image, template)
        ij = np.unravel_index(np.argmax(result), result.shape)
        x, y = ij[::-1]
        meas_image = offset_image[y:(y+TEMPLATE_SIZE*2), x:(x+TEMPLATE_SIZE*2)]
        # print (template.shape[0], template.shape[1], meas_image.shape[0], meas_image.shape[1])
        shift, error, diffphase = register_translation(template, meas_image, 100)
        time_meas = int((time.time() - time_start) * 1000)

↑ ** Dies ist der Kern der Verarbeitung ** Schneiden Sie das Bild nach dem Vorlagenabgleich anhand der gefundenen Koordinatenkriterien auf die Vorlagengröße aus. Dann wird eine Phasenkorrelation (register_translation) für das ausgeschnittene Bild und das Schablonenbild ausgeführt, um die Koordinaten mit Subpixelgenauigkeit zu erhalten. Die letzten 100 von register_translation stehen für "1/100 Pixel Genauigkeit". Durch Erhöhen dieser Zahl wird die Genauigkeit erhöht.

templatematch.py

        cv2.rectangle(img2, (x, y), (x+TEMPLATE_SIZE*2, y+TEMPLATE_SIZE*2), (0, 255, 0), 3)

        cv2.imshow("Real Time Measurement 640x480", img2)

        print ("Capture[ms]:", time_cap, "Meas[ms]:", time_meas, "X[pix]:", x+TEMPLATE_SIZE+shift[0], "Y[pix]:", y+TEMPLATE_SIZE+shift[1])

        key = cv2.waitKey(10)
        if key == 27: # ESC 
            break

↑ □ Zeichnen Sie einen Cursor an die Koordinaten, an denen die Vorlage gefunden und ausgegeben wird Ausführungszeit und Koordinaten ausgeben Beenden Sie, wenn ESC gedrückt wird

Impressionen

Zu Hause konnte ich problemlos ein System zur Messung der Subpixelgenauigkeit aufbauen. Ich denke, es ist möglich, die Anzahl der Kameras zu erhöhen und Multi-Eye-Messungen durchzuführen. Da die Ausführungszeit von der gemessenen Bildgröße und Vorlagengröße abhängt, muss sie entsprechend der Zielzeit angepasst werden. Wenn Sie ein Mikroskop usw. verwenden, können Sie mit einer Genauigkeit von nm messen. Da jedoch die Vibration der Ausführungsumgebung einen großen Einfluss hat, ist eine Vibrationsisolationstabelle erforderlich.

Bitte lassen Sie mich wissen, ob es hilft! Aber nicht durch Kopieren einreichen!