Einführung

Wir haben die Präsentationen der 56. Computer Vision Study Group @ Kanto zusammengefasst, die am Samstag, dem 19. Januar 2020, stattfanden. Sie können die Materialien des Tages von [hier] aus sehen (https://www.slideshare.net/NaoyaTakeuchi/ss-221273392?ref=https://kantocv.connpass.com/event/160053/presentation/).

Der Quellcode ist auf dem folgenden Github verfügbar. https://github.com/33taro/gaze_cv

Über das Verfahren der Iriserkennung

Irisierende Erkennung ist ein Thema, das ich während meines Studiums studiert habe, daher dachte ich, dass es mit dem weiterentwickelten OpenCV einfach sein würde. Das Verfahren ist wie folgt.

Erkennung von menschlichen Gesichtern und Gesichtspunkten anhand von Kamerabildern
Schneiden Sie die Augenpartie aus dem Orientierungspunkt im Gesicht aus
Binarisieren Sie die Augenpartie und extrahieren Sie die Irispartie
Irisierende Detektion aus der extrahierten Irisregion

虹彩検出手順.png

Erkennen des Gesichts und der Gesichtspunkte einer Person anhand von Kamerabildern

Ich habe zuvor versucht, die Iris (Teil des blauen Auges) mithilfe der in einem anderen Artikel eingeführten Erkennung des Gesichtes zu erkennen. Bitte beachten Sie dies für Details.

Schneiden Sie die Augenpartie aus dem Orientierungspunkt im Gesicht aus

Wie in Artikel oben eingeführt, ist das Wahrzeichen des Gesichts hier. Wir verwenden das trainierte Modell in Ressourcen / Gesichtspunkt-Anmerkungen /). Daher ist das rechte Auge "Nr. 37-42" und das linke Auge "Nr. 43-48".

目領域.png

Dies wird in "eye_region_manager.py" im Verzeichnis "Tracking_system" im eigentlichen Quellcode beschrieben.

`eye_region_manager.py`


    def detect_eye_region(self, face_landmark):
        """
Holen Sie sich die Koordinaten der Augenpartie vom Orientierungspunkt
        :param face_landmark:
        """
        #Ausschnitt für das rechte Auge
        self._right_eye_region = {'top_x': face_landmark[36][0], 'bottom_x': face_landmark[39][0],
                                  'top_y': face_landmark[37][1]
                                  if face_landmark[37][1] < face_landmark[38][1] else face_landmark[38][1],
                                  'bottom_y': face_landmark[41][1]
                                  if face_landmark[41][1] > face_landmark[40][1] else face_landmark[40][1]}

        #Ausschnitt des linken Auges
        self._left_eye_region = {'top_x': face_landmark[42][0], 'bottom_x': face_landmark[45][0],
                                 'top_y': face_landmark[43][1]
                                 if face_landmark[43][1] < face_landmark[45][1] else face_landmark[45][1],
                                 'bottom_y': face_landmark[47][1]
                                 if face_landmark[47][1] > face_landmark[46][1] else face_landmark[46][1]}

Da die Anordnung bei 0 beginnt, ist sie 0 bis 67 und die Zahlen werden um eins verschoben.
Die vertikalen y-Koordinaten der Augenpartie werden so erfasst, dass sie länger sind.

Binarisieren Sie die Augenpartie und extrahieren Sie die Iris

Die P-Kachel-Methode wurde verwendet, um die Augenpartie zu binarisieren. Dies ist eine Methode, um den Prozentsatz des Bildbereichs anzugeben, den Sie binärisieren möchten. Infolgedessen konnte die Iris unabhängig von der Helligkeit erfasst werden. (Als Faustregel gilt, dass die Iris 40% der Augenpartie ausmacht.)

目領域の2値化.png

2 Vor der Digitalisierung wird es mit einem Gaußschen Filter geglättet, um Rauschen zu entfernen.

Die P-Tile-Methode ist in OpenCV nicht implementiert, daher habe ich sie selbst erstellt. Es wird in "image_utility.py" im Verzeichnis "Utility" beschrieben.

`image_utility.py`


# coding:utf-8

import cv2


def p_tile_threshold(img_gry, per):
    """
Binarisierungsverarbeitung nach der P-Kachel-Methode
    :param img_gry:Graustufenbild, das binärisiert werden soll
    :param per:Prozentsatz der zu binärisierenden Bilder
    :return img_thr:Binarisiertes Bild
    """

    #Holen Sie sich das Histogramm
    img_hist = cv2.calcHist([img_gry], [0], None, [256], [0, 256])

    #Berechnen Sie die Anzahl der Pixel aus dem Verhältnis des zu binärisierenden Bildes
    all_pic = img_gry.shape[0] * img_gry.shape[1]
    pic_per = all_pic * per

    #Berechnung der Binarisierungsschwelle nach der P-Kachel-Methode
    p_tile_thr = 0
    pic_sum = 0

    #Aktuelle Helligkeit und Summe der Helligkeit(In absteigender Reihenfolge des Wertes hinzufügen)Berechnung von
    for hist in img_hist:
        pic_sum += hist

        #Die Verarbeitung endet, wenn die Gesamthelligkeit das angegebene Verhältnis überschreitet
        if pic_sum > pic_per:
            break

        p_tile_thr += 1

    #Binarisierungsprozess mit dem nach der P-Kachelmethode erhaltenen Schwellenwert
    ret, img_thr = cv2.threshold(img_gry, p_tile_thr, 255, cv2.THRESH_BINARY)

    return img_thr

Irisierende Detektion aus der extrahierten Irisregion

Ich konnte den Irisbereich erfassen, aber ich kann aufgrund der Schatten der Augenbrauen und Augenlider nicht nur die Iris sauber extrahieren. Daher wurde der schwarze Bereich durch Konturpunktverfolgung erfasst, zu jedem Bereich hinzugefügt, um den umschreibenden Kreis zu approximieren, und der Kreis mit dem größten Radius wurde als Iris verwendet.

Wenn der umschreibende Kreis jedoch zu groß ist, wird er von den Kandidaten für die Iris ausgeschlossen.

虹彩の外接円近似.png

Eine Reihe von Binärisierungs-Iris-Erkennungen wird in "eye_system_manager.py" im Verzeichnis "Tracking_system" beschrieben.

`eye_system_manager.py`


    @staticmethod
    def _detect_iris(eye_img):
        #Nach Graustufen Glättung mit Gauß-Filter
        eye_img_gry = cv2.cvtColor(eye_img, cv2.COLOR_BGR2GRAY)
        eye_img_gau = cv2.GaussianBlur(eye_img_gry, (5, 5), 0)

        #Binarisierung nach der P-Kachel-Methode
        eye_img_thr = p_tile_threshold(eye_img_gau, IRIS_PER)

        cv2.rectangle(eye_img_thr, (0, 0), (eye_img_thr.shape[1] - 1, eye_img_thr.shape[0] - 1), (255, 255, 255), 1)

        #Konturextraktion
        contours, hierarchy = cv2.findContours(eye_img_thr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        #Finden Sie die Iris von der Kontur durch den minimalen umschreibenden Kreis
        iris = {'center': (0, 0), 'radius': 0}
        for i, cnt in enumerate(contours):
            (x, y), radius = cv2.minEnclosingCircle(cnt)
            center = (int(x), int(y))
            radius = int(radius)

            #Von Iriskandidaten ausschließen, wenn der Radius zu groß ist
            if eye_img_thr.shape[0] < radius*0.8:
                # #Zeichnung von Iriskandidaten
                # cv2.circle(eye_img, center, radius, (255, 0, 0))
                continue

            #Der Kreis mit dem größten Radius wird als Iris erkannt
            if iris['radius'] < radius:
                iris['center'] = center
                iris['radius'] = radius
                iris['num'] = i

        return iris

Ergebnis der schillernden Erkennung

Wie in der obigen Abbildung gezeigt, sind die Iris des linken und rechten Auges fest erfasst. Es gibt jedoch immer noch Probleme in Bezug auf die Ober- und Unterseite. Wenn eine Person jedoch auf und ab schaut, bewegt sie oft ihr Gesicht, anstatt ihre Iris zu bewegen. (Wenn du nur mit deinen Augen auf und ab schaust, bist du müde.) Ich frage mich also, ob ich die Ausrichtung des Gesichts anhand der Orientierungspunkte auf dem Gesicht erkennen kann.

Referenzlink

Konturpunktverfolgung

** OpenCV-Python Tutorial ~ Überblick: Erster Schritt ~ ** http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/html/py_tutorials/py_imgproc/py_contours/py_contour_features/py_contour_features.html OpenCV-Tutorial. Ich habe es als Referenz für die grundlegende Verwendung verwendet.
** OpenCV - So extrahieren Sie Konturen mit findContours ** https://www.pynote.info/entry/opencv-findcontours Details zu findContours (), der Konturpunktverfolgungsfunktion von OpenCV, werden vorgestellt. Ich habe es als Referenz beim Schreiben des Quellcodes verwendet.
** [OpenCV; Python] Zusammenfassung der Funktion findcontours ** https://qiita.com/anyamaru/items/fd3d894966a98098376c Jede Funktion der Konturpunktverfolgungsfunktion findContours () von OpenCV wird anhand von Abbildungen leicht verständlich erläutert. Ich habe es als Referenz für das Verständnis dieser Technologie verwendet.

Minimaler umschreibender Kreis

** OpenCV-Python Tutorial ~ Funktionen des Bereichs (Gliederung) ~ **
http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/html/py_tutorials/py_imgproc/py_contours/py_contour_features/py_contour_features.html
OpenCV-Tutorial. Ich habe es als Referenz für die grundlegende Verwendung verwendet.

P Kachelmethode

** Bildgebungslösung ~ P Fliesenmethode ~ ** https://imagingsolution.net/imaging/p-tile-method/ Es erklärt die P-Kachel-Methode auf leicht verständliche Weise. Ich habe es als Referenz zum Verständnis und zur Implementierung der P-Tile-Methode verwendet.
** Einführung in die Bildverarbeitung / C-Sprache Beispielsammlung-P-Kachelmethode - ** http://pgsample.info/image/other/PercentileMethod.html Es ist eine Implementierung der P-Kachel-Methode in der C-Sprache. Dieses Mal habe ich es als Referenz verwendet, als ich den Code für die P-Kachel-Methode in Python geschrieben habe.

[PYTHON] Ich habe versucht, Iris aus dem Kamerabild zu erkennen