introduction

Nous avons résumé les présentations du 56th Computer Vision Study Group @ Kanto tenue le samedi 19 janvier 2020. Vous pouvez voir les documents de la journée sur ici.

Le code source est disponible sur le Github suivant. https://github.com/33taro/gaze_cv

À propos de la procédure de détection de l'iris

La détection irisée est un thème que j'étudiais quand j'étais à l'université, alors j'ai pensé que ce serait facile de le faire avec l'OpenCV avancé. La procédure est la suivante.

Détection du visage humain et des points de repère faciaux à partir d'images de caméra
Découpez le contour des yeux du repère sur le visage
Binarisez le contour des yeux et extrayez la zone de l'iris
Détection irisée de la région de l'iris extraite

虹彩検出手順.png

Détecter le visage et les repères faciaux d'une personne à partir d'images de caméra

J'ai essayé de détecter l'iris (partie des yeux au beurre noir) en utilisant la détection de repère du visage présentée dans Another article avant. Veuillez vous y référer pour plus de détails.

Découpez le contour des yeux du repère sur le visage

Comme présenté dans l'article ci-dessus, le repère du visage est [ici](https://ibug.doc.ic.ac.uk/ Nous utilisons le modèle entraîné dans resources / facial-point-annotations /). Par conséquent, l'œil droit est «n ° 37-42» et l'œil gauche est «n ° 43-48».

目領域.png

Ceci est décrit dans "eye_region_manager.py" dans le répertoire "tracking_system" dans le code source actuel.

`eye_region_manager.py`


    def detect_eye_region(self, face_landmark):
        """
Obtenez les coordonnées de la zone des yeux à partir du repère
        :param face_landmark:
        """
        #Découpe de l'œil droit
        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]}

        #Découpe de l'œil gauche
        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]}

Puisque l'arrangement commence de 0, il sera de 0 à 67 et les nombres seront décalés de un.
Les coordonnées y verticales du contour des yeux sont acquises de manière à être plus longues.

Binariser le contour des yeux et extraire la zone de l'iris

La méthode P-tile a été utilisée pour binariser le contour des yeux. Il s'agit d'une méthode pour spécifier le pourcentage de la zone d'image que vous souhaitez binariser. En conséquence, l'iris pourrait être acquis quelle que soit la luminosité. (En règle générale, l'iris représente 40% du contour des yeux)

目領域の2値化.png

2 Avant la numérisation, il est lissé avec un filtre gaussien pour éliminer le bruit.

La méthode P-tile n'est pas implémentée dans OpenCV, je l'ai donc créée moi-même. Il est décrit dans "image_utility.py" dans le répertoire "utilitaire".

`image_utility.py`


# coding:utf-8

import cv2


def p_tile_threshold(img_gry, per):
    """
Traitement de binarisation par méthode de tuile P
    :param img_gry:Image en échelle de gris à binariser
    :param per:Pourcentage d'images à binariser
    :return img_thr:Image binarisée
    """

    #Obtenir l'histogramme
    img_hist = cv2.calcHist([img_gry], [0], None, [256], [0, 256])

    #Calculer le nombre de pixels à partir du rapport de l'image à binariser
    all_pic = img_gry.shape[0] * img_gry.shape[1]
    pic_per = all_pic * per

    #Calcul du seuil de binarisation par la méthode P-tile
    p_tile_thr = 0
    pic_sum = 0

    #Luminosité actuelle et somme de la luminosité(Ajouter par ordre décroissant de valeur)Calculs de
    for hist in img_hist:
        pic_sum += hist

        #Le traitement se termine lorsque la luminosité totale dépasse le rapport spécifié
        if pic_sum > pic_per:
            break

        p_tile_thr += 1

    #Processus de binarisation avec la valeur seuil obtenue par la méthode des carreaux P
    ret, img_thr = cv2.threshold(img_gry, p_tile_thr, 255, cv2.THRESH_BINARY)

    return img_thr

Détection irisée de la région de l'iris extraite

J'ai pu obtenir la zone de l'iris, mais je ne peux pas extraire uniquement l'iris proprement à cause des ombres des sourcils et des paupières. Par conséquent, la zone noire a été acquise par suivi des points de contour, ajoutée à chaque zone pour se rapprocher du cercle circonscrit, et le cercle avec le plus grand rayon a été utilisé comme iris.

Cependant, si le cercle circonscrit est trop grand, il sera exclu des candidats à l'iris.

虹彩の外接円近似.png

Une série de détection de binarisation-iris est décrite dans "eye_system_manager.py" dans le répertoire "tracking_system".

`eye_system_manager.py`


    @staticmethod
    def _detect_iris(eye_img):
        #Après échelle de gris, lissage avec filtre gaussien
        eye_img_gry = cv2.cvtColor(eye_img, cv2.COLOR_BGR2GRAY)
        eye_img_gau = cv2.GaussianBlur(eye_img_gry, (5, 5), 0)

        #Binarisation par méthode de tuile P
        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)

        #Extraction de contour
        contours, hierarchy = cv2.findContours(eye_img_thr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        #Trouver l'iris du contour par le cercle circonscrit minimum
        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)

            #Exclure des candidats iris si le rayon est trop grand
            if eye_img_thr.shape[0] < radius*0.8:
                # #Dessin de candidats iris
                # cv2.circle(eye_img, center, radius, (255, 0, 0))
                continue

            #Le cercle avec le plus grand rayon est reconnu comme un iris
            if iris['radius'] < radius:
                iris['center'] = center
                iris['radius'] = radius
                iris['num'] = i

        return iris

Résultat de détection irisé

Comme le montre la figure ci-dessus, les iris des yeux gauche et droit sont fermement acquis. Cependant, il y a encore des problèmes concernant le haut et le bas. Cependant, lorsqu'une personne regarde de haut en bas, elle bouge souvent son visage plutôt que de bouger son iris. (En fait, regarder de haut en bas avec juste vos yeux vous fatigue) Je me demande donc si je peux en quelque sorte détecter l'orientation du visage à partir des points de repère sur le visage.

Lien de référence

Suivi des points de contour

** Tutoriel OpenCV-Python ~ Aperçu: Première étape ~ ** 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 Tutoriel OpenCV. Je l'ai utilisé comme référence pour une utilisation de base.
** OpenCV - Comment extraire des contours avec findContours ** https://www.pynote.info/entry/opencv-findcontours Les détails de findContours (), la fonction de suivi des points de contour d'OpenCV, sont présentés. Je l'ai utilisé comme référence lors de l'écriture du code source.
** [OpenCV; Python] Résumé de la fonction findcontours ** https://qiita.com/anyamaru/items/fd3d894966a98098376c Chaque fonction de la fonction de suivi des points de contour findContours () d'OpenCV est expliquée de manière facile à comprendre à l'aide de figures. Je l'ai utilisé comme référence pour comprendre cette technologie.

Cercle circonscrit minimum

** Tutoriel OpenCV-Python ~ Caractéristiques de la zone (Outline) ~ **
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
Tutoriel OpenCV. Je l'ai utilisé comme référence pour une utilisation de base.

Méthode de tuile P

** Solution d'imagerie ~ Méthode de tuile P ~ ** https://imagingsolution.net/imaging/p-tile-method/ Il explique la méthode de tuile P d'une manière facile à comprendre. Je l'ai utilisé comme référence pour comprendre et implémenter la méthode P-tile.
** Introduction au traitement d'image / méthode de mosaïque de collection d'échantillons en langage C - ** http://pgsample.info/image/other/PercentileMethod.html Il s'agit d'une implémentation de la méthode P tile en langage C. Cette fois, je l'ai utilisé comme référence lors de l'écriture du code de la méthode de tuile P en python.

J'ai essayé de détecter l'iris à partir de l'image de la caméra