Détection et suivi de visage

Transcription

T RAITEMENT ET C ODAGE D ’I MAGE 2006/2007
1 / 13
2 / 13
INDEXATION DU DOCUMENT
TITRE :
REFERENCE :
ACTION
NOM
DATE
SIGNATURE
RÉDIGÉ PAR
Adrien COSSA et
Dominique GIRBAL
21 janvier 2007
SUIVI DU DOCUMENT
INDICE
DATE
MODIFICATIONS
NOM
3 / 13
Table des matières
1
Introduction à la reconnaissance et au suivi faciale
4
1.1
Enumérations des techniques existantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.2
La technique du pattern recognition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.2.1
Template Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.2.2
Mesures de similarité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
Classification par caractéristiques de Haar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.3.1
Caractéristiques de Haar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.3.2
Méthode de détection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
1.3
2
Expérimentations avec OpenCV
7
2.1
Présentation d’OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.1.1
La bibliothèque OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.1.2
Le sample facedetect.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
OpenCV sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.2.1
Installation d’OpenCV sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.2.2
Utilisation du sample sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
OpenCV sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.1
Installation d’OpenCV sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.2
Utilisation du sample sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2
2.3
2.4
2.5
3
Amélioration du score . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.1
Création d’une nouvelle cascade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.2
Modification du sample
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Réflexions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Bibliographie
13
4 / 13
Table des figures
1
Formule de cross-corrélation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2
Exemple de cross-corrélation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
3
Ensemble des caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
4
Ensemble restreint des caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
5
Table des zones sommées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
Résumé
Ce document a été réalisé au sein de l’Université Louis Pasteur pour le contrôle continu de Traitement et Codage d’Image
2006/2007. Il a été écrit en Docbook XML puis exporté au format PDF à l’aide de dblatex.
Le sujet concernait l’étude de flux vidéo pour la reconnaissance et le suivi de visages au sein du champ de vision d’une caméra de
type vidéo-surveillance. Nous avons réalisé dans un premier temps un petit état de l’art des différentes techniques utilisées dans
le domaine, puis nous avons testé l’une de ces techniques en particulier à l’aide de la bibliothèque de visualisation interactive
OpenCV.
1 Introduction à la reconnaissance et au suivi faciale
1.1 Enumérations des techniques existantes
Il existe une variété de techniques consacrées à la détection de visage. Les systèmes de suivi de visage se sont beaucoup développés ces dernières années grâce à l’amélioration du matériel et à la forte demande industrielle, par exemple pour la recherche
d’individu par le biais d’une caméra de surveillance, ou encore l’utilisation de robots d’exploration (recherche de survivants à la
suite d’un incendie).
Les techniques actuelles se basent sur l’extraction de clusters depuis la couleur de la peau (algorithme Mean Shift). On peut
également localiser des visages par détection de mouvements tels que le clignement des yeux, ou en considérant les positions relatives entre les yeux, le nez et la bouche (EigenFaces et Discrete Cosine Transform). Mais il existe aussi des approches bien plus
complexes, telle que la détection de visages en utilisant des réseaux de neurones qui essaient de reproduire le processus cognitif
humain. D’autres méthodes sont encore utilisées, se basant sur la transformée de Hough, la détection de contours (algorithme de
Canny) ou bien la reconnaisance de forme par template matching.
Nous allons maintenant présenter deux des méthodes les plus utilisées : le pattern recognition et la classification par caractéristiques de Haar.
1.2 La technique du pattern recognition
La reconnaissance de formes (pattern recognition) permet la description et la classification de mesures. C’est en fait une famille
de techniques proches les unes des autres, mais on peut quand même distinguer trois types d’approche :
– la reconnaissance de formes statistique ;
– la reconnaissance de formes syntactique ;
– la reconnaissance de formes basée sur les réseaux de neurones.
1.2.1 Template Matching
La méthode du template matching est très intéressante pour la détection de visage de par sa facilité d’application, bien que
l’aspect temps réel ne puisse pas lui être entièrement appliqué puisque cette méthode peut devenir très lourde. Le principe en est
le suivant : il s’agit, étant donné une image quelconque et un modèle prédéfini, de déterminer si ce modèle figure dans l’image à
tester et d’en trouver la position. Cette méthode peut etre amélioré avec des techniques de pré-traitement, comme le Mean Shift,
qui indiquera l’emplacement et l’orientation possible du visage.
5 / 13
1.2.2 Mesures de similarité
Ensuite, pour rechercher une similarité entre le modèle et la partie de l’image, on utilise une cross-corrélation normalisée. Voici
la formule mathématique associée, avec un exemple de cross-corrélation qui montre que plus l’image est similaire au modèle,
plus la corrélation est claire :
F IG . 1 – Formule de cross-corrélation
F IG . 2 – Exemple de cross-corrélation
Cette méthode peut être améliorée en binarisant l’image, ce qui permettra un traitement plus clair et rapide, mais nécessite une
passe de traitement supplémentaire.
1.3 Classification par caractéristiques de Haar
Une autre méthode est souvent utilisée dans le suivi de visage, elle utilise les caractéristiques de Haar combinées avec du boosting,
tels les algorithmes Discrete Adaboost, Real Adaboost ou encore Gentle Adaboost. Nous allons vous décrire cette méthode
appliquée avec l’algorithme Discrete Adaboost.
1.3.1 Caractéristiques de Haar
Les caractéristiques de Haar sont des fonctions permettant de connaître la différence de contraste entre plusieurs régions rectangulaires et contiguës d’une image. Un ensemble de ces caractéristiques peut être utilisé pour coder les contrastes existants dans
un visage humain et leurs relations spatiales.
Le plus grand problème de ce genre d’approche est la nécessité de calculer ces caractéristiques pour chaque fenêtre résultant
du balayage de l’image et ceci peut avoir un coût de calcul énorme. L’ensemble des caractéristiques possibles correspond à la
formule suivante, dans laquelle wi est le poids du rectangle ri :
6 / 13
F IG . 3 – Ensemble des caractéristiques
Cette ensemble dans sa taille actuelle n’est pas exploitable car il est trop grand, il faut donc le réduire. Pour cela :
– seules les combinaisons pondérées de la somme des pixels de deux rectangles sont considérées (N = 2) ;
– les poids de ces deux rectangles sont de signes opposés et sont utilisés pour compenser la différence de la taille des zones entre
les deux rectangles. De ce fait, pour des rectangles qui ne se recouvrent pas nous avons la relation
-w0 * RecSom(r0 ) = w1 * RecSom(r1 ). En posant w0 = -1, ceci donne w1 = RecSom(r0 ) / RecSom(r1 ).
Ces restrictions nous donnent les quatorzes caractéristiques de Haar représentées ci-dessous :
F IG . 4 – Ensemble restreint des caractéristiques
Ces prototypes sont redimensionnés indépendamment sur les axes horizontaux et verticaux afin de générer un ensemble surcomplet de caractéristiques, un ensemble complet étant un ensemble dont les éléments sont indépendants les uns des autres.
On calcule ensuite, pour chaque point de l’image de départ, une valeur Summed Area Table (table des zones sommées) ou SAT.
SAT(x, y) est définie à l’aide des valeurs des pixels du rectangle horizontal compris entre (0, 0) et (x, y) par la formule suivante :
F IG . 5 – Table des zones sommées
Par divers algorithmes tels que des algorithmes récursifs, on peut calculer ces sommes d’aire rapidement et ainsi, en réappliquant
sur des rectangles tournés à 45 degrés, trouver toute les caractéristiques de Haar.
1.3.2 Méthode de détection
La méthode de détection utilise des classifieurs, ce sont des outils permettant de déterminer à quelle classe appartient une entrée
donnée. Pour cela elle utilise une cascade de classifieurs simples, ce qui permet un traitement rapide est efficace.
Il existe différent types de classifieurs de base, comme le boosting avec des algorithmes tels que Discrete Adaboost, Real Adaboost ou encore Gentle Adaboost, le dernier offrant les meilleurs performances pour la détection de visages.
7 / 13
Nous avons expliqué plus haut que l’ensemble des caractéristiques de Haar que nous avons créées est très grand. Calculer
l’ensemble entier est gourmand en ressources temporelles. Le but de l’algorithme d’apprentissage du classifieur est donc de
trouver un petit nombre de caractéristiques qui, une fois combinées, forment un classifieur efficace.
Dans ce but, l’algorithme d’apprentissage des classifieurs faibles est conçu de manière à sélectionner la caractéristique qui sépare
le mieux les exemples positifs et négatifs. Pour chaque caractéristique, l’algorithme détermine une fonction seuil optimale qui
possède un taux d’erreur minimum.
L’algorithme Gentle Adaboost nous donne, à partir d’un ensemble d’images d’entraînement, une suite de classifieurs faibles
capables de séparer au mieux les exemples positifs et négatifs : nous l’appelons classifieur fort. Afin d’améliorer les performances
de la méthode, on peut combiner plusieurs classifieurs forts dans une structure en cascade. Une cascade de classifieurs est un
arbre de décision dégénéré, entraîné pour qu’à chaque étape on puisse détecter un maximum d’objets intéressants tout en rejetant
une certaine fraction des objets non-intéressants.
Ainsi un résultat positif du premier classifieur déclenche l’évaluation par un deuxième classifieur qui à son tour déclenche le
classifieur suivant. En revanche une détection négative de l’un des classifieurs entraîne un rejet de la sous-fenêtre en cours
d’évaluation. Le fait d’utiliser ces classifieurs en cascade permet de détecter efficacement la présence de visages au sein d’une
image, et à une vitesse suffisamment élevée pour pouvoir effectuer du traitement en temps réel.
2 Expérimentations avec OpenCV
2.1 Présentation d’OpenCV
2.1.1 La bibliothèque OpenCV
OpenCV est une bibliothèque libre de visualisation en temps réel pour le langage C/C++. Elle utilise idéalement les optimisations
Integrated Performance Primitives d’Intel mais fonctionne aussi très bien sans. Les domaines d’utilisation sont variés : IHM,
robotique, détection et reconnaissance d’objets ou de visages, ainsi que suivi et étude de leurs mouvements... Dans le cadre de ce
projet, nous nous sommes livrés à une petite expérimentation utilisant un sample paramétrable pour la détection de visage.
2.1.2 Le sample facedetect.c
Ce fichier est livré avec les sources d’OpenCV, comme une petite application de démonstration pour donner un apperçu des
capacités de la librairie en détection et suivi de visage. L’algorithme utilisé tente de localiser un ou plusieurs visages au sein
d’une image. Il découpe pour celà l’image en régions et confronte ces régions avec des modèles de visages, en utilisant comme
critère de comparaison la relativité spatiale des contrastes colorimétriques que présente un visage humain.
Le programme prend en paramètre ces modèles de visages qui sont codés dans un fichier XML par une cascade de classifieurs
de Haar. Il sait ensuite travailler :
–
–
–
–
sur une image ;
sur une liste d’images ;
sur un flux vidéo au format AVI ;
sur un flux vidéo directement issu d’une webcam.
Nous allons maintenant détailler l’installation d’OpenCV sur la machine de travail turing que nous avons utilisée.
2.2 OpenCV sous Linux
2.2.1 Installation d’OpenCV sous Linux
OpenCV ne sait pas exploiter directement un flux vidéo, pour ce faire il utilise ffmpeg, une solution complète de traitement
audio/vidéo. Nous allons ici détailler l’installation de ffmpeg et d’OpenCV sur turing. Comme on ne dispose pas des droits
super-utilisateurs sur la machine, on installe tout ça dans une arborescence fictive du système au sein même de notre répertoire
personnel.
8 / 13
La procédure d’installation nécessite l’utilisation d’environ 190 Mo d’espace disque dans /tmp, qui pourront être libéré par la
suite. Les fichiers qui seront installés dans votre répertoire personnel occuperont environ 60 Mo, qui ne devront pas être libéré
tant que vous souhaitez continuer à utiliser OpenCV.
On commence par récupérer et extraire les sources de ffmpeg et d’OpenCV.
$
$
$
$
$
cd /tmp && mkdir ‘whoami‘ && cd ‘whoami‘
wget http://ffmpeg.mplayerhq.hu/ffmpeg-checkout-snapshot.tar.bz2
tar xvf ffmpeg-checkout-snapshot.tar.bz2
wget http://kent.dl.sourceforge.net/sourceforge/opencvlibrary/opencv-1.0.0.tar.gz
tar xvzf opencv-1.0.0.tar.gz
On installe ffmpeg dans notre répertoire personnel avec l’option --enable-shared.
$ cd ffmpeg-checkout-* && ./configure --prefix=$HOME/root/usr/local --enable-shared
$ make && make install
On configure l’installation d’OpenCV, veuillez respecter à la lettre l’énumération de chaque paramètre tel qu’il est donné cidessous :
$ ./configure --prefix=$HOME/root/usr/local --enable-apps --enable-shared
--with-ffmpeg --with-gnu-ld --with-x --without-quicktime
CXXFLAGS=-fno-strict-aliasing
CFLAGS=-I$HOME/root/usr/local/include
CPPFLAGS=-I$HOME/root/usr/local/include
LDFLAGS=-L$HOME/root/usr/local/lib
Vérifiez que ffmpeg a bien été détécté sur le système et qu’il sera utilisé pour patcher la compilation d’OpenCV. Il suffit pour
celà de regarder dans les dernières lignes qui ont été écrites à l’écran. Si apparait ffmpeg: yes, vous pouvez alors continuer
l’installation.
$ make && make install
Il ne reste plus qu’à rajouter ces trois lignes à la fin de votre ~/.bashrc :
#OPENCV
export LD_LIBRARY_PATH=~/root/usr/local/lib
export PKG_CONFIG_PATH=~/root/usr/local/lib/pkgconfig
Si vous comptez utiliser OpenCV tout de suite, pensez également à recharger votre ~/.bashrc en tapant ceci :
$ . ~/.bashrc
Enfin, vous avez aussi le droit de vider l’espace occupé dans /tmp... on vous laisse deviner comment.
2.2.2 Utilisation du sample sous Linux
Si tout s’est bien passé, vous disposez maintenant d’un ~/root bien rempli. Au passage, le nom de ce répertoire a été choisi
ainsi pour signifier qu’il s’agit d’une arborescence fictive telle qu’on la trouve à la racine du système de fichier, et non pas pour
imiter le répertoire personnel du super-utilisateur.
Compiler maintenant facedetect.c et lancez-le sur un fichier AVI, par exemple sur celui que j’ai laissé dans /tmp :
$ cd ~/root/usr/local/share/opencv/samples/c
$ chmod 777 build_all.sh && ./build_all.sh
$ ./facedetect --cascade="../../haarcascades/haarcascade_frontalface_alt.xml"
/tmp/ocvtest.avi
9 / 13
Vous avez remarqué que l’on a ici utilisé la cascade de classifieurs de Haar haarcascades_frontalface_default.xml.
Il y en a d’autres, que l’on souhaite essayer de même afin de se livrer à une petite étude comparative. Pour faciliter cette
expérimentation, on voudrait utiliser le sample directement sur une capture de flux issu d’une webcam. L’ordinateur portable
dont nous disposons est doté d’une webcam mais celle-ci n’est malheureusement pas encore fonctionnelle sous Linux, les drivers
étant en cours d’écriture. On va alors installer la version Windows d’OpenCV qui est plus suceptible de fonctionner avec notre
webcam.
2.3 OpenCV sous Windows
2.3.1 Installation d’OpenCV sous Windows
L’installation sous Windows est un peu plus simple. OpenCV est distribué en tant que package binaire prêt à l’emploi. On a aussi
besoin d’un compilateur C++. L’environnement de développement libre Dev-C++ fera très bien l’affaire.
Commencez par télécharger le fichier d’installation d’OpenCV : http://heanet.dl.sourceforge.net/sourceforge/
opencvlibrary/OpenCV_1.0.exe. Installez le programme dans le chemin qui vous est proposé par défaut, c’est à dire
C:\ProgramFiles\OpenCV. Téléchargez maintenant Dev-C++ depuis http://prdownloads.sourceforge.net/
dev-cpp/devcpp-4.9.9.2_setup.exe et installez-le dans C:\Dev-Cpp.
Comme pour la version Linux, OpenCV est est livré avec des samples, celui qui nous interesse s’appelle toujours facedetect.
c. Il se trouve dans le répertoire C:\ProgramFiles\OpenCV\samples\c, ouvrez-le avec Dev-C++ et essayez de le compiler à l’aide de la combinaison de touches Ctrl-F9. Ca ne marche pas et c’est normal, il faut d’abord renseigner le compilateur
sur l’emplacement des fichiers installés par OpenCV.
Dans le menu Tools de Dev-C++, choisissez Compiler Options. Dans le premier onglet Compiler, cochez Add these commands
to the linker command line et saisissez ceci dans le champ de texte :
-lhighgui -lcv -lcxcore -lcvaux -lcvcam
Cliquez maintenant sur l’onglet Directories et dans la section Libraries ajoutez le chemin suivant :
C:\Program Files\OpenCV\lib
Il reste à lister les chemins qui contiennent les fichiers headers d’OpenCV, rajoutez pour celà dans les sections C Includes et C++
Includes tout ce qui suit :
C:\Program
C:\Program
C:\Program
C:\Program
C:\Program
Files\OpenCV\cxcore\include
Files\OpenCV\cv\include
Files\OpenCV\otherlibs\highgui
Files\OpenCV\cvaux\include
Files\OpenCV\otherlibs\cvcam\include
La combinaison Ctrl-F9 devrait maintenant compiler votre programme sans erreur. Avant de le lancer, il reste à informer le
système d’exploitation du chemin contenant les fichiers DLL d’OpenCV. Depuis les Propriétés système de Windows accessibles
avec un clic droit sur le Poste de travail, cliquez sur l’onglet Avancé puis sur le bouton Variables d’environnement et dans la
partie Variables système, sélectionnez la variable Path, cliquez sur le bouton Modifier et ajouter ceci à la fin du champs de saisie
Valeur de la variable (n’oubliez pas le point-virgule qui sert de séparateur) :
;C:\Program Files\OpenCV\bin
Et voilà ! facedetect.exe se lance maintenant, comme pour la version Linux, en spécifiant la cascade de classifieurs à
utiliser. Sans deuxième argument, il utilise directement votre webcam connectée comme source de flux vidéo.
10 / 13
2.3.2 Utilisation du sample sous Windows
Une petite archive contenant le sample compilé ainsi que les DLL nécessaires à son fonctionnement sous Windows a été placé
sur http://co2sa.free.fr/facedetect/facedetect_windows.zip. Téléchargez-la et décompressez-la où vous
voulez. Comme les librairies DLL se situent dans le même répertoire que l’éxécutable facedetect.exe, vous n’avez pas
besoin de mettre à jour la variable d’environnement Path du système. Vous pouvez immédiatement éxécutér les différents fichiers
se terminant par l’extension cmd. Ceux-ci ont pour effet de lancer le programme avec les différentes cascades de classifieurs
disponibles, et en utilisant le flux vidéo capté par votre webcam.
On s’interesse ici seulement aux cascades qui reconnaissent des visages, il s’agit de celles dont le nom contient frontalface (pour
la reconnaissance de visage placé face à la caméra) ou profileface (pour reconnaître les visages qui montrent leur profil à la
caméra).
Afin de comparer ces différentes cascades de manière objective, nous les avons testées sur une douzaine d’images contenant au
total 21 visages, qui ont été listée dans un fichier texte passé en paramètre du programme. Ces images ont été obtenus avec notre
webcam, dans des conditions différentes d’éclairage, et représentent des visages découverts ou masqués par des objets (bonnet,
lunette de soleil, foulard), en position droite ou inclinée, de face ou de profil... et même un dessin ! Voici les résultats obtenus par
les cascades de type frontalface et profileface :
–
–
–
–
–
frontalface_default : 13 détections, 1 doublon, 3 faux positifs ;
frontalface_alt : 14 détections, 0 doublon, 0 faux positif ;
frontalface_alt2 : 12 détections, 1 doublon, 0 faux positif ;
frontalface_alt_tree : 9 détections, 0 doublon, 0 faux positif ;
profileface : 7 détections, 2 doublons, 0 faux positifs.
Il s’avère que les résultats des différentes cascades se complètent puisque au total 17 visages sont détectés par une ou plusieurs
cascades. Nous allons maintenant voir comment ces scores peuvent être améliorés.
2.4 Amélioration du score
2.4.1 Création d’une nouvelle cascade
Nous avons expérimenté la création d’une nouvelle cascade de classifieurs. On ne s’attendait bien sur pas à fournir de meilleurs
résultats que ceux obtenus avec les cascades d’origines, qui ont été entrainées à partir de plusieurs centaines voir des milliers de
visages... Mais la démarche exploratoire nous a paru intéressante et nous allons vous décrire comment procéder pour créer une
nouvelle cascade à partir des fichiers images de votre choix.
Les programmes createsample et haartraining sont officiellement distribués avec OpenCV pour la création et l’entrainement d’une cascade de classifieurs.
Le premier utilise un fichier texte qui liste les différentes images à utiliser, ainsi que les coordonnées des visages à prendre en
compte au sein de ces images. A raison d’une image par ligne, voilà le format utilisé pour écrire ce fichier :
chemin nombre [abscisse ordonnee largeur hauteur]+
Il s’agit de spécifier le chemin de l’image, le nombre de visages qu’elle contient, puis pour chacun de ces visages l’abscisse et
l’ordonnée du coin supérieur gauche du rectangle encadrant le visage, suivies de sa largeur et de sa hauteur. Ainsi, pour notre
exemple le fichier que nous avons appelé index.txt contenait ceci :
~/FaceDataBase/faces01.jpg
1
1
1
1
1
1
1
1
1
20 43 57 37
10 49 56 35
30 52 62 32
5 16 58 57
28 28 66 38
23 25 39 26
22 5 85 54
13 38 55 45
46 40 54 32
11 / 13
1
1
1
1
1
1
42
27
26
17
20
28
47
37
38
31
35
34
62
41
47
36
57
31
33
26
28
21
30
15
Le lancement de createsample à partir de ce fichier crée un ensemble de vecteurs de similitude. Voici comment on utilise ce
programme en pratique :
$ ./opencv-createsample -vec ~/faces.vec
-info ~/FaceDataBase/index.txt -w 35 -h 20
Les vecteurs de similitude seront stockés dans faces.vec et les argument w et h correspondent aux dimensions vers lesquelles
les rectangles seront redimensionnés pour accroître les performances de la comparaison de visages.
On utilise ensuite haartraining pour effectuer à proprement parler l’entrainement de nos classifieurs :
$ ./opencv-haartraining -data ~/new_classifier.xml
-vec ~/faces.vec -w 35 -h 20 -bg ~/FaceDataBase/back.txt
-nstages 15 -nsplits 1 -minhitrate 0.995 -maxfalsealarm 0.5
Le paramètre identifié par -bg correspond à des images de fond ne contenant aucun visage, qui seront utilisées afin de former des
modèles de non-visages. Les autres paramètres définissent des limites, entre autre la limite de détection qui est un pourcentage
de similitude. Le résultat à l’écran ressemble à ceci :
Cascade performance
POS: 15 15 1.000000
NEG: 15 0.00085266
BACKGROUND PROCESSING TIME: 0.00
La cascade que nous avons générée ne s’est évidemment pas révélée performante... il aurait fallu utiliser une base de donnée
d’images énorme pour faire mieux que les cascades qui nous sont officiellement fournies avec OpenCV.
2.4.2 Modification du sample
Comme nous venont de le voir, les cascades déjà disponibles sont difficilement égalables ou remplaçables. Face à ce constat, nous
avons décidé d’aborder le problème non plus à la source mais en aval. Nous avons modifié le sample facedetect afin de détecter
davantage de visages, en utilisant lors de la même éxécution les deux cascades qui s’étaient révélées les plus performantes et
complémentaires : frontalface_alt et profileface.
La modification du code a consisté à intégrer, dans la fonction qui détecte et affiche les visages, l’éxécution séquentielle de deux
reconnaissances, une pour chaque cascade. Ces reconnaissances sont indépendantes, mais avant l’affichage on veille à recouper
et traiter les résultats afin de les harmoniser.
En effet, certains visages sont détectés par les deux cascades et dans les résultats figurent alors des doublons. Nous avons
solutionné ce problème en effectuant un test de distance : pour qu’un résultat ne constitue pas le doublon d’un autre, la distance
entre leurs centres doit être supérieure à la somme des rayons des cercles les représentant. Si un résultat est détecté comme le
doublon d’un autre, il est tout simplement évincé. On arrive ainsi à se préserver de l’introduction de doublons... et mieux encore,
on élimine les doublons propres à une seule cascade !
Voici du pseudo-code correspondant à la fonction qui détecte et affiche les visages. Les variables image, cascade1, cascade2 et
mode sont déclarées globales à l’ensemble du programme. Lorsque mode diffère de 2, on n’utilise qu’une seule cascade comme
dans le sample originale, sauf que l’on procède en plus à une suppression des doublons internes. Lorsque mode vaut 2, on utilise
les deux cascades cascade et on supprime tous les doublons (internes et croisés).
12 / 13
void detect_and_draw() {
// DETECTION
faces1 = HaarDetection(image, cascade1)
if (mode == 2)
faces2 = HaarDetection(image, cascade2)
n1 = faces1 ? faces1.taille : 0
n2 = faces2 ? faces2.taille : 0
// TRAITEMENT DES RESULTATS
for (i = 0; i < n1 + n2; i++) {
// AFFICHAGE
f1 = (i >= n1) ? getElem(faces2, i - n1) : getElem(faces1, i)
afficher(f1)
// SUPPRESSION DES DOUBLONS
for (j = i + 1; j < n1 + n2; j++) {
f2 = (i >= n1) ? getElem(faces2, j - n1) : getElem(faces1, j)
if (distance(f1, f2) < f1.rayon + f2.rayon) {
if (j >= n1) {
removeElem(faces2, j - n1)
n2-} else {
removeElem(faces1, j)
n1-}
j-}
}
}
}
Voici le score que cette version modifiée obtient sur le jeu de test précédemment utilisé : 15 détections, 0 doublon, 0 faux positif.
On cumule donc le score des deux cascades utilisées concernant les bonnes détections, et on se débarasse au passage des 2
doublons que retournaient profileface.
Le résultat optimal de 17 détections ne peut pas être obtenu avec seulement 2 cascades : il faut en utiliser au moins 3. Nous
n’avons cependant pas jugé interessant d’implémenter la détection utilisant plus de 2 cascades, car les reconnaissances étant
effectuées séquentiellement, le temps de calcul est finalement multiplié par le nombre de cascades utilisées. Afin de conserver
l’aspect temps-réel de l’application, il est préférable de s’en tenir à ces résultats non optimaux mais ne dégradant pas encore
vraiment l’efficacité.
13 / 13
2.5 Réflexions
Nous nous sommes servis d’OpenCV comme d’un outil clé-en-main pour effectuer une détection de visage. C’est une bibliothèque performante qui, de part ses capacités d’analyse vidéo en temps réel, permet de simuler le suivi de visage sans étudier la
dépendance temporelle entre les frames successives d’un flux vidéo.
Les résultats que l’on obtient sont assez convaincants, et dans nos tentatives d’amélioration par la création d’une nouvelle cascade
de classifieurs, nous nous sommes apperçus que la qualité d’une cascade est au moins aussi importante que l’algorithme qui
l’utilise.
Nous avons réussi à augmenter la qualité de la détection, non pas en s’attaquant directement à l’algorithme de classification, mais
en utilisant séquentiellement deux cascades puis en recoupant les résultats pour éliminer les doublons avant l’affichage.
Cette expérimentation fut intéressante de part sa qualité ludique et interactive. Si l’on devait émettre des critiques à l’encontre de
la classification utilisant les caractéristiques de Haar :
– les visages ne sont pas détectés dès lors qu’ils sont un peu trop penchés sur la gauche ou la droite, ou bien lorsqu’ils ne se
montrent pas suffisamment face à la caméra ;
– on n’obtient pas beaucoup de faux positifs en pratique, mais sachant comment fonctionne l’algorithme il est très facile d’en
produire. Par exemple, un simple T gribouillé de manière à simuler l’ombre d’un visage suffira pour tromper l’algorithme.
On retiendra de cette méthode de détection qu’elle ne se base pas sur les réelles caractéristiques du visage humain, mais sur les
ombres faciales ; celà présente à la fois des avantages (rapidité d’éxécution, taux de reconnaissance élevé) et des inconvénients
(introduction aisée de faux positifs, nécessité d’utiliser une cascade exhaustive). Les modifications que nous avons apportées
permettent d’améliorer le score de la détection tout en conservant l’algorithme de base de la mise en oeuvre.
3 Bibliographie
Carminati L.: Détection et suivi de visages par Support Vector Machine robustes aux changements d’échelle.
Kofman A., Ledru C., Le Stang J-B., Manguelle G., Monclus D., Olivier P.: Reconnaissance et suivi de visage en temps réel.
Heusch G.: Détection automatique de visages dans une séquence vidéo, 2002.
Adolf F.: How-to build a cascade of boosted classifiers based on Haar-like features, 2003.
Ferguson D., Levasseur F., Sensebe T., Talpin W.: Détection de visages, 2004.
Jaffré G.: Open Source Computer Vision Library, 2004.
Davoine F.: Suivi de visage et de mouvements faciaux, 2005.
Meynet F.: Localisation de visages, 2005.
http://opencvlibrary.sourceforge.net
http://www.comp.leeds.ac.uk/vision/opencv

Détection et suivi de visage

Transcription

Documents pareils

curruculum vitae - Sophia Antipolis - Méditerranée

Chaque visage est un miracle... Un enfant noir, à la peau noire, aux

TP image 1

Projet console Visual C++ 2010 avec OpenCV

Histoire du nouveau monde , Bartlomiej Woznica et Natyelli Mora

Comment utiliser javacv directement dans Processing - Mon Club-Elec

1. Introduction 2. Lire et afficher une image

paranormal.dossier.Histoires mystérieuses

Ο πρόςωποσ - Le prosopos