Rapport de fin d’étude en vue de l’obtention d’un diplôme d’ingénieur en

Télécommunication & TIC

IMPLEMENTATION D’UN SYSTEME DE

RECONNAISSANCE FACIALE PAR LA
TECHNIQUE DES EIGENFACES SOUS JAVA
ET ANDROID

Rédigé par

NZIWOUE CHIADJEU Wilfried

Sous la direction de :
M. Guy Christian AYISSI

Mars 2016
A LA FAMILLE NZIWOUE

i
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

REMERCIEMENTS

La rédaction de ce mémoire n’étant en fait que la partie émergée de l’iceberg, je tiens ici à
remercier toutes ces personnes qui de près ou de loin ont été pour moi d’un grand soutien
durant toute ma formation. Etant dans l’incapacité de toutes les citer, je tiens à rendre un
grand hommage à :

• à Dr NDOUMBE Jean, Chef du département TTIC1 pour son esprit aiguisé de

gestion des étudiants ;

• à Mr AYISSI Guy Christian, mon encadreur et enseignant au département GI de

l’IUT pour ses conseils avisés, sa serviabilité, sa très bonne moralité et sa très grande
disponibilité ;

• à tous les enseignants du département TTIC pour toutes les connaissances qu’ils
m’ont transmises. Je tiens à dire un merci particulier à Monsieur ABANG Thierry pour
sa disponibilité et ses conseils ;

• à ma maman chérie, sans qui je ne serai jamais arrivé jusqu’à ce stade ;

• à mon papa, qui n’a jamais cessé d’oeuvré de sa personne afin que je devienne
l’homme que je suis aujourd’hui ;

• à toutes mes soeurs NZIWOUE Sorelle, NZIWOUE Gaëlle, NZIWOUE Aurelie,

NZIWOUE Syntiche pour tout leur soutien et amour dans ma vie, sans oublier mon
petit bébé Joana Leuna ;

• à la famille WANDJI pour les aides de différentes natures qu’ils m’ont apporté ;

• à l’école " Les Petits Champions du Campus 2" pour avoir toujours accepté que j’y
travaille de jour comme de nuit ;

• à la famille KAMAHA et FAGUEP pour leur soutien moral, matériel et financier ;

• à tous mes amis, KOAMENI Yannick, NKEMADJOU Jacob, NGONGANG Elisé,

OUSSOUMANOU, ZONGUE TATIANA, CHEUSSA Laurice pour leur tendre amitié ;

• à NKOT YOGO, étudiant à la FGI pour son aide précieuse dans le développement
en JAVA ;

1
Télécommunication et Technologie de l’Information et de la Communication

Rédigé par Wilfried NZIWOUE ii Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

• à tous mes camarades et amis de la 4me promotion TTIC de la FGI. Je pense

particulièrement à NGANDO CLaudel, TABOU Stéphane, ZARA MALLOUM, HEYA
Nicole, DJOUBAIROU OUMAROU, BOBGA Jude.

Rédigé par Wilfried NZIWOUE iii Telecoms & IT Student Engineer - FGI
 Résumé

Ce travail présente une vision nouvelle de la sécurité où il serait possible d’identifier un

individu par la seule acquisition et connaissance de son visage. Au regard des problèmes
sécuritaires qui minent le monde, l’Afrique et particulièrement le Cameroun, il nous a paru
très important de proposer un système permettant d’identifier de manière automatique un
individu grâce à son visage.

Mots clés : Biométrique, Reconnaissance faciale, EigenFaces, Système informatique, Ap-

plication Java, Application Android.
 Abstract

This work presents a new vision of security , where it would be possible to identify an
individual by the mere acquisition and knowledge of his face. In view of the security prob-
lems that plague the world, particularly Africa and Cameroon , we thought it will be very
important to provide a system for automatically identifying an individual with his face.

Keywords : Biometric , Facial Recognition , Eigenface, Security, Computer System ,

Java Application , Android Application.
Table des matières

Dédicaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ii
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii
Abstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i

Introduction Générale 1

I La reconnaissance faciale en théorie 3

Chapitre 1 La biométrie 4
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Généralité de la biométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Les technologies biométriques . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Biométrie par empreintes digitales . . . . . . . . . . . . . . . . . . . . . 5
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.2 Biométrie par la forme de la main . . . . . . . . . . . . . . . . . . . . . 6
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.3 Biométrie par le visage . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.4 Biométrie par la voix . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

i
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.5 Biométrie par l’iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.6 Biométrie par la dynamique de la frappe au clavier . . . . . . . . . . . 9
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.7 Biométrie par la signature dynamique . . . . . . . . . . . . . . . . . . . 9
Avantages : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Inconvénients : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Applications : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4 Raison du choix de la reconnaissance par visage . . . . . . . . . . . . . . . . . 10
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Chapitre 2 Etat de l’art de la reconnaissance faciale 12

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 La détection de visage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.1 Approche basée sur les connaissances acquises . . . . . . . . . . . . . . 12
2.2.2 Approche basée sur le «Template-matching» . . . . . . . . . . . . . . 14
2.2.3 Approche basée sur l’apparence . . . . . . . . . . . . . . . . . . . . . . 14
2.2.4 Approche basée sur des caractéristiques invariantes . . . . . . . . . . . 15
2.3 La reconnaissance de visage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.1 Méthodes globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.2 Méthodes locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Méthodes basées sur les caractéristiques locales . . . . . . . . . . . . . 17
Méthodes basées sur l’apparence locale (Local apparence-based methods) 18
2.3.3 Méthodes Hybrides . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Rédigé par Wilfried NZIWOUE ii Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Chapitre 3 La reconnaissance faciale par la technique des EigenFaces 21

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Le module de pré-traitement de l’image . . . . . . . . . . . . . . . . . . . . . . 21
3.2.1 Transformation en une image à niveau de gris . . . . . . . . . . . . . . 22
3.2.2 Étirement d’histogramme . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.3 Application du filtre médian . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.4 Redimensionnement de l’image pour une taille de 112 ∗ 92 pixels . . . . 25
3.3 Sous-système d’apprentissage de l’individu par les EigenFaces . . . . . . . . . 26
3.3.1 Principe de fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4 Sous-système reconnaissance . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4.1 Principe de fonctionnement du bloc «Détection du visage» . . . . . . . 31
3.4.2 Principe de fonctionnement du bloc «Identification de l’individu» . . . 32
3.4.3 Principe de fonctionnement du bloc «Authentification de l’individu» . . 33
3.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

II Implémentation de la solution 36

Chapitre 4 Analyse des besoins 37

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2 Présentation des fonctions principales de notre système . . . . . . . . . . . . . 37
4.2.1 Fonction N˚ 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.2 Fonction N˚ 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.3 Fonction N˚ 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2.4 Fonction N˚ 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3 Contraintes d’exécution des différentes fonctions . . . . . . . . . . . . . . . . . 38
4.3.1 Contrainte N˚ 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.2 Contrainte N˚ 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.3 Contrainte N˚ 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.4 Contrainte N˚ 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Rédigé par Wilfried NZIWOUE iii Telecoms & IT Student Engineer - FGI
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

4.3.5 Contrainte N˚ 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Chapitre 5 Conception 40
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.2 Principaux diagrammes de conception . . . . . . . . . . . . . . . . . . . . . . . 40
5.2.1 Diagramme N˚1 : Diagramme de déploiement . . . . . . . . . . . . . . 40
5.2.2 Diagramme N˚2 : Diagramme de cas d’utilisation . . . . . . . . . . . . 41
5.2.3 Diagramme N˚3 : Diagramme de classes . . . . . . . . . . . . . . . . . . 45
5.2.4 Le Modèle Conceptuel de Données (MCD) et le Modèle Logique de
Données (MLD) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Chapitre 6 Logiciels utilisés durant la conception et la réalisation de notre

solution 49
6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2 Logiciels utilisés pendant l’analyse et la conception . . . . . . . . . . . . . . . 49
6.2.1 Enterprise Architect . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2.2 JMerise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.3 Logiciels utilisés pendant l’analyse et la conception . . . . . . . . . . . . . . . 51
6.3.1 Notepad++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.3.2 Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3.3 Java Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.3.4 WampServer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3.5 Inno Setuo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Chapitre 7 Résultats et commentaires 56

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2 Fonctionnement général du système . . . . . . . . . . . . . . . . . . . . . . . . 56
7.2.1 Principe de fonctionnement de l’authentification CHAP . . . . . . . . . 57
7.3 Présentation des différents résultats . . . . . . . . . . . . . . . . . . . . . . . . 59

Rédigé par Wilfried NZIWOUE iv Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

7.3.1 L’application Mobile Android . . . . . . . . . . . . . . . . . . . . . . . 60

Caractéristiques matérielles requises . . . . . . . . . . . . . . . . . . . 60
Captures d’écran de l’application en cours de fonctionnemant : . . . . 61
7.3.2 L’application Cliente PC . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Caractéristiques matérielles requises . . . . . . . . . . . . . . . . . . . 67
Captures d’écran de l’application en cours d’installation . . . . . . . . 68
Captures d’écran de l’application en cours de fonctionnement . . . . . 72
7.3.3 L’application Serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Caractéristiques matérielles requises . . . . . . . . . . . . . . . . . . . 80
Captures d’écran de l’application en cours de fonctionnement . . . . . 81
7.4 Observations apportées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Conclusion Générale 86

III Annexes 90

Annexe A Cahier de charge 91

Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Information sur le projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Historique des révisions du document . . . . . . . . . . . . . . . . . . . . . . . . . . 93
1 Nature du document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
1.1 Objectif du document . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
1.2 Ce que comprend le document . . . . . . . . . . . . . . . . . . . . . . . 93
1.3 Ce que ne comprend pas le document . . . . . . . . . . . . . . . . . . . 94
2 Présentation générale du projet . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.1 Besoin et contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.2 Description du système . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.3 Expression fonctionnelle des besoins . . . . . . . . . . . . . . . . . . . . 95
Fonction N˚ 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Fonction N˚ 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

Rédigé par Wilfried NZIWOUE v Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Fonction N˚ 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Fonction N˚ 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.4 Contraintes d’exécution des différentes fonctions . . . . . . . . . . . . . 95
Contrainte N˚ 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Contrainte N˚ 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Contrainte N˚ 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Contrainte N˚ 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Contrainte N˚ 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.5 Fonctions secondaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Fonction N˚ 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Fonction N˚ 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Fonction N˚ 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3 Solutions proposées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
3.1 Application Serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
3.2 Application Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Annexe B Présentation de l’API OpenCV 98

1 Les fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
1.1 Fonctionnalités obtenus dans le calculs matriciels . . . . . . . . . . . . 98
1.2 Fonctionnalités obtenus pour le traitement d’image et vidéo . . . . . . 99
1.3 Algorithme d’apprentissage . . . . . . . . . . . . . . . . . . . . . . . . 99

Annexe C Procédure de prise de photo lors de l’apprentissage d’un individu100

Annexe D Code source du service Identification 105

1 Code au niveau Serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
1.1 Codes Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
1.2 Codes JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2 Code au niveau des applications clientes . . . . . . . . . . . . . . . . . . . . . 116
2.1 Application PC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
2.2 Application ANDROID . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Annexe E Les principaux diagrammes de conceptions 124

Rédigé par Wilfried NZIWOUE vi Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

1 Les diagrammes d’interaction client - serveur . . . . . . . . . . . . . . . . . . . 126

Rédigé par Wilfried NZIWOUE vii Telecoms & IT Student Engineer - FGI
Liste des abréviations

ACP Analyse des Composantes Principales. 15

ADL Analyse Discriminante Linéaire. 15

API Application Programming Interface. 29

BD Base de Données. 32, 91

CHAP Challenge HandShake Protocol. 55

CNI Carte Nationale d’Identité. 36

CPU Central Processing Unit. 58

DD Dique Dur. 65

GO GigaOctets. 58

IDE Integrated Development Environment. 50

IP Internet Protocol. 54

JDK Java Development Kit. 50, 51

JPEG Joint Photographic Experts Group. 36

JRE Java Runtime Environment. 65, 78

MCD Modèle Conceptuel de Donnée. 38, 45

MD5 Message Digest 5. 55

viii
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

MLD Modèle Logique de Données. 38, 45

MO MegaOctets. 58

MP MégaPixels. 37, 92

PC Personal Computer. 57

PDF Portable Document Format. 58

RAM Random Access Memory. 58, 84

ROM Read Only Memory. 58

SQL Structured Query Language. 48

TCP Transport Control Protocol. 54

UML Unified Modeling Language. 38

Rédigé par Wilfried NZIWOUE ix Telecoms & IT Student Engineer - FGI

Table des figures

2.1 Modèle de visage composé de 16 régions . . . . . . . . . . . . . . . . . . . . . 14

3.1 Image d’entrée pour les différents traitements . . . . . . . . . . . . . . . . . . 22

3.2 Image transformée en Noir/Blanc . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Image après l’égalisation de l’histogramme . . . . . . . . . . . . . . . . . . . . 24
3.4 Image après application du filtre médian . . . . . . . . . . . . . . . . . . . . . 25
3.5 Image redimensionnée à la taille 112*92 pixels . . . . . . . . . . . . . . . . . . 25
3.6 Taux d’identification moyen en fonction du nombre d’exemples d’apprentissage
par individu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.7 Illustration de la détection visage à l’aide d’OpenCV . . . . . . . . . . . . . . 31
3.8 Schéma fonctionnel du système . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5.1 Diagramme de déploiement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

5.2 Diagramme de cas d’utilisation pour l’application cliente . . . . . . . . . . . . 42
5.3 Diagramme de cas d’utilisation de l’application serveur (partie1) . . . . . . . . 43
5.4 Diagramme de cas d’utilisation de l’application serveur (partie 2) . . . . . . . 44
5.5 Diagramme de classe de l’application cliente . . . . . . . . . . . . . . . . . . . 45
5.6 Diagramme de classe de l’application serveur . . . . . . . . . . . . . . . . . . . 46
5.7 Modèle Conceptuel de Données . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.8 Modèle Logique de Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.1 Capture d’écran de Enterprise Architec . . . . . . . . . . . . . . . . . . . . . . 50

6.2 Capture d’écran de JMerise . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.3 Capture d’écran de Notepad ++ . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.4 Capture d’écran de Android Studio . . . . . . . . . . . . . . . . . . . . . . . . 53
6.5 Capture d’écran de WampServer . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.6 Capture d’écran d’Inno Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

x
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

7.1 Application du filtre ’tcp.port == 1992’ dans Wireshark . . . . . . . . . . . . 58

7.2 Authentification CHAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.3 Accueil de l’application Android . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.4 Message d’erreur en cas de combinaison mot de passe et pseudo incorrecte . . 61
7.5 Volet d’identification d’un individu de l’application Android . . . . . . . . . . 62
7.6 Voler d’authentification d’un individu de l’application Android . . . . . . . . . 62
7.7 Volet de recherche d’un individu de l’application Android . . . . . . . . . . . . 63
7.8 Visage choisi pour identification dans l’application Android . . . . . . . . . . . 63
7.9 Choix du type de détection de visage (automatique ou manuelle) de l’applica-
tion Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.10 Attente de traitement de l’application Android . . . . . . . . . . . . . . . . . . 64
7.11 Résultat de traitement d’identification de l’application Android . . . . . . . . 65
7.12 Liste des individus détectés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.13 Affichage des informations de l’individu sélectionné . . . . . . . . . . . . . . . 66
7.14 Les différentes options offertes . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.15 Message de bienvenue de l’assistant d’installation . . . . . . . . . . . . . . . . 68
7.16 Insertion du mot de pass : WilNziCoorporation . . . . . . . . . . . . . . . . . 69
7.17 Affichage des informations d’installation . . . . . . . . . . . . . . . . . . . . . 69
7.18 Installation de l’application dont le setup contient la JRE en son sein . . . . . 70
7.19 Installation de l’application dont le setup ne contient pas la JRE en son sein . 70
7.20 Fin de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
7.21 Position de l’application dans le menu démarrer . . . . . . . . . . . . . . . . . 71
7.22 Accueil de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.23 Espace de choix de l’image à identifier . . . . . . . . . . . . . . . . . . . . . . 73
7.24 Photo choisie pour identification . . . . . . . . . . . . . . . . . . . . . . . . . . 73
7.25 Choix entre une détection de visage automatique ou manuelle . . . . . . . . . 74
7.26 Résultat de l’identification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
7.27 Affichage des informations d’un utilisateur . . . . . . . . . . . . . . . . . . . . 75
7.28 Génération du fichier Pdf contenant les informations de l’individu . . . . . . . 75
7.29 Message d’erreur lors de la modification des informations d’un individu . . . . 76

Rédigé par Wilfried NZIWOUE xi Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

7.30 Modification des informations terminées avec succès . . . . . . . . . . . . . . . 76

7.31 Les différents fonctionnalités offertes par l’application . . . . . . . . . . . . . 77
7.32 Interface d’apprentissage d’un individu . . . . . . . . . . . . . . . . . . . . . . 77
7.33 Formulaire d’insertion d’information d’un individu . . . . . . . . . . . . . . . . 78
7.34 Interface d’authentification d’un individu . . . . . . . . . . . . . . . . . . . . . 78
7.35 Interface de recherche d’un individu suivant son nom et son prénom . . . . . . 79
7.36 Interface de recherche d’un individu suivant son numéro d’identifiant . . . . . 79
7.37 Les différentes aides proposées à l’utilisateur . . . . . . . . . . . . . . . . . . . 80
7.38 Démarrage de l’application Serveur . . . . . . . . . . . . . . . . . . . . . . . . 81
7.39 Espace de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
7.40 Espace de connexion en tant que simple administrateur . . . . . . . . . . . . 82
7.41 Espace de connexion en tant que super administrateur . . . . . . . . . . . . . 83
7.42 Sélection d’un utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7.43 Espace d’Affichage et de modification des informations de l’utilisateur sélec-
tionné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
7.44 Option d’ouverture du fichier "Log" . . . . . . . . . . . . . . . . . . . . . . . 84
7.45 Le fichier "Log" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

C-1 Photo d’apprentissage N˚1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

C-2 Photo d’apprentissage N˚2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
C-3 Photo d’apprentissage N˚3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
C-4 Photo d’apprentissage N˚4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
C-5 Photo d’apprentissage N˚5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
C-6 Photo d’apprentissage N˚6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
C-7 Photo d’apprentissage N˚7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C-8 Photo d’apprentissage N˚8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C-9 Photo d’apprentissage N˚9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C-10 Photo d’apprentissage N˚10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

E-1 Diagramme de cas d’utilisation de l’application serveur . . . . . . . . . . . . . 125

E-2 Diagramme d’interaction entre le client et le serveur lors de la connexion du
client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Rédigé par Wilfried NZIWOUE xii Telecoms & IT Student Engineer - FGI
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

E-3 Diagramme d’interaction entre le client et le serveur lors de l’apprentissage

d’un individu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
E-4 Diagramme d’interaction entre le client et le serveur lors de l’identification
d’un individu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
E-5 Diagramme d’interaction entre le client et le serveur lors de l’authentification
d’un individu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
E-6 Diagramme d’interaction entre le client et le serveur lors de la recherche d’un
individu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Rédigé par Wilfried NZIWOUE xiii Telecoms & IT Student Engineer - FGI
Introduction Générale

La reconnaissance de visage par ordinateur a depuis des années été un sujet de recherche
dans le domaine de la vision par ordinateur. En fait, comment peut on de manière auto-
matique reconnaître un individu par la seule prise en compte de l’image de son visage ? La
réponse à cette seule question sera le fil directeur de notre travail.

Traditionnellement, il existe deux grandes manières d’identifier un individu. La première est

fondée sur la connaissance d’une information sécrète (mot de passe, phrase sécrète, schéma,
etc...) La seconde se base sur la possession d’un objet (possession d’un badge, d’une carte
électromagnétique, carte à puce, d’une CNI, etc...) A ce sujet, en effectuant une recherche
de quelques secondes sur un moteur de recherche, on obtient en résultat des articles comme
[Wik16a] qui met en exergue différentes astuces permettant de deviner un mot de passe et
par conséquent les mots de passe à éviter par tout moyen . Toutefois, malgré l’ensemble de
ces mesures, il est relativement aisé de pourvoir usurper l’identité d’un individu, en lui volant
son badge, en devinant son mot de passe, etc...

Afin de résoudre, jusqu’à un certain niveau, ce problème récurent d’usurpation d’identité,

des chercheurs ont pensé identifier un individu non pas à l’aide de la connaissance d’une
information sécrète ou encore par la possession d’un objet relativement bien gardé mais à
travers des caractéristiques propres à cet individu (signature, visage, pomme de main, iris,
empreinte, etc...). Le volet de la science traitant de cet aspect de l’identification est appelé
la biométrie.

Afin de répondre à la question posée plus haut, nous avons subdivisé notre travail en deux
grandes parties. La première intitulée " La reconnaissance faciale en théorie ", nous
permet de présenter la biométrie dans son ensemble, de ressortir les différentes avancés dans

1
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

ce domaine promoteur de la biométrie à travers l’état de l’art de la reconnaissance faciale

et par la suite de faire une étude plus poussée sur la reconnaissance faciale par la technique
des EigenFaces. Dans la seconde partie, intitulée " Implémentation de la solution ",
nous déterminerons à travers une analyse des besoins les différents objectifs et contraintes de
la solution à implémenter, et afin de les respecter lors de la réalisation de la solution, nous
ressortirons les principaux diagrammes de conception à travers le volet conception. Dans
ce soucis d’expliciter la réalisation de notre solution, nous présenterons les logiciels utilisés
pendant la conception et la réalisation de notre solution et afin nous terminerons par les
résultats obtenus et commentaires observés.

Rédigé par Wilfried NZIWOUE 2 Telecoms & IT Student Engineer - FGI

 Première partie

LA RECONNAISSANCE FACIALE EN
THEORIE

3
Chapitre 1

La biométrie

1.1 Introduction

La sécurité d’accès à une information et à des systèmes est un élément important dans la
sécurité informatique. Au préalable plusieurs méthodes ont été mises sur pied, à l’instar de
l’accès par carte magnétique, par mot de passe, par phrase sécrète ou phrase de passe 1 , par
schéma, par mot de passe image, etc... Cependant le véritable problème de ces méthodes est
le fait qu’il n’assure en rien que la personne qui fournit le passe est bel et bien la
personne qui devrait être autorisée. Afin de palier à ce problème, des chercheurs ont
conçus d’autres méthodes dites biométriques car elles utilisent les caractéristiques propres à
un individu pour l’identifier.

Dans cette partie, nous allons tout d’abord présenter la biométrie, ensuite les différentes
technologies biométriques utilisables de nos jours et enfin ressortir les raisons nous ayant
amenées au choix de la technologie utilisée pour la réalisation de notre projet.

1.2 Généralité de la biométrie

La biométrie peut être définie comme étant " la reconnaissance d’une personne en utilisant
les traits distinctifs ". Et d’après [BOU] elle est définie comme " toutes caractéristiques phy-
siques ou traits personnels automatiquement mesurables, robustes et distinctives qui peuvent

1
mot de passe contenant un nombre fort de caractères (20 - 30 caractères )

4
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

être utilisées pour identifier un individu ou pour vérifier l’identité prétendue d’un individu ".

L’utilisation de la biométrie dans la sécurité informatique apporte de nombreux avantages,

parmi lesquels nous pouvons citer :

• La suppression du doute sur l’identité de l’individu ;

• la suppression quasi-complète de l’utilisation des mots de passe ;

• la difficulté de contre-façon .

Cependant, son utilisation entraîne un principal inconvénient qui est le coût lié à son
implémentation

1.3 Les technologies biométriques

Dans cette section, nous allons lister les différentes technologies de biométrie en précisant
leurs avantages, inconvénients et possibles applications.

Les informations apportées dans cette partie sont principalement tirées de [GAE15].

1.3.1 Biométrie par empreintes digitales

La biométrie par empreintes digitales consiste à identifier / authentifier un individu à l’aide

de l’empreinte d’un de ses doigts.

Avantages :

• La technologie la plus répandue et la plus connue du grand public ;

• Petite taille du lecteur facilitant son intégration dans la majorité des applications (té-
léphones portables, PC) ;

• Traitement rapide ;

• Bon compromis entre le taux de faux rejet et le taux de fausse acceptation.

Rédigé par Wilfried NZIWOUE 5 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Inconvénients :

• Besoin de la coopération de l’utilisateur (pose correcte du doigt sur le lecteur) ;

• Certains systèmes peuvent accepter un moulage de doigt ou un doigt coupé (la détection
du doigt vivant permet d’éviter ce type d’usurpation).

Applications :

• Distributeur de billets, accès extérieur à des locaux ;

• Contrôle d’accès physique (locaux, machines, équipements spécifiques) ;

• Contrôle d’accès logique (systèmes d’information) ;

1.3.2 Biométrie par la forme de la main

La biométrie par la forme de la main consiste à identifier / authentifier un individu à l’aide

de la silhouette d’une de ses mains. Cette silhouette possède des paramètres propres à un
individu comme la longueur des doigts, leur épaisseur et leur position relative.

Avantages :

• Bonne acceptation chez les usagers ;

• Très simple à utiliser ;

• Traitement rapide ;

• Le résultat est indépendant de l’humidité et de l’état de propreté des doigts ;

• Fichier "gabarit" de petite taille.

Inconvénients :

• Trop encombrant pour un usage sur le bureau, dans une voiture ou un téléphone ;

• Risque de fausse acceptation pour des jumeaux ou des membres d’une même famille.

Rédigé par Wilfried NZIWOUE 6 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Applications :

• Contrôle d’accès à des locaux ;

• Parloirs de prison.

1.3.3 Biométrie par le visage

La biométrie par le visage consiste à identifier ou authentifier un individu à l’aide de son

visage.

Avantages :

• Très bien acceptée par le public ;

• Ne demande aucune action de l’usager (peu intrusive), pas de contact physique ;

• Technique peu coûteuse.

Inconvénients :

• Technologie sensible à l’environnement (éclairage, position, expression du visage...) ;

• Les vrais jumeaux ne sont pas différenciés ;

• Sensible aux changements (barbe, moustache, lunette, percing, chirurgie...).

Applications :

• Contrôle d’accès à faible niveau de sécurité ;

• Technologie pouvant être associée avec une autre technologie pour la compléter.

1.3.4 Biométrie par la voix

La biométrie par la voix consiste à identifier ou authentifier un individu à l’aide du son de

sa voix.

Rédigé par Wilfried NZIWOUE 7 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Avantages :

• Il est plus facile de protéger le lecteur que dans les autres technologies ;

• Seule information utilisable via le téléphone ;

• Impossible d’imiter la voix par un individu.

Inconvénients :

• Sensible à l’état physique et émotionnel de l’individu ;

• Fraude possible par enregistrement ;

• Sensible aux bruits ambiants ;

• Taux de faux rejet et fausse acceptation élevés .

Applications :

• Dans un immeuble d’habitation, on pourra facilement protéger un micro derrière une

grille anti-vandalisme ;

• Conversion téléphonique .

1.3.5 Biométrie par l’iris

La biométrie par l’iris consiste à identifier ou authentifier un individu à l’aide de la prise

d’une image de son iris.

Avantages :

• Grande quantité d’information contenue dans l’iris ;

• Vrais jumeaux non confondus ;

Inconvénients :

• Aspect psychologiquement invasif de la méthode ;

Rédigé par Wilfried NZIWOUE 8 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

• L’iris est aisément visible et peut être photographié. Le problème de sécurité est alors
lié aux vérifications effectuées lors de la prise de vue.

Applications :

• Distributeurs de billets de banque ;

• Contrôle d’accès physique (locaux, machines, équipements spécifiques), contrôle d’accès

logique (systèmes d’information) ;

• En théorie, toutes les applications d’authentification car la caméra est plus exposée
qu’un micro (voix) mais moins qu’un capteur tactile (empreintes digitales).

1.3.6 Biométrie par la dynamique de la frappe au clavier

La biométrie par la dynamique de la frappe au clavier consiste à identifier ou authentifier

un individu à travers sa manière de saisir sur un clavier. Les éléments ainsi analysés sont : la
vitesse de frappe, suite de lettre, temps de frappe, pauses, ...

Avantages :

• Grande quantité d’information contenue dans l’iris ;

• Vrais jumeaux non confondus ;

Inconvénients :

• Non intrusif, geste naturel pour un individu.

Applications :

• Documents administratif, bancaire, assurance...

1.3.7 Biométrie par la signature dynamique

La biométrie par la signature dynamique consiste à identifier ou authentifier un individu

à travers sa signature.

Rédigé par Wilfried NZIWOUE 9 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Avantages :

• La signature écrite sur un document peut être conservée dans certains documents ;

• Action qui implique la responsabilité de l’individu car la signature est utilisée comme
élément juridique ou administratif.

Inconvénients :

• Besoin d’une tablette graphique ;

• Sensible aux émotions de l’individu ;

• Pas utilisable pour du contrôle d’accès en extérieur par exemple.

Applications :

• Documents administratif, bancaire, assurance...

1.4 Raison du choix de la reconnaissance par visage

Nous avons choisi d’utiliser la reconnaissance par le visage à cause de sa facilité d’implémen-
tation, et qu’elle était la seule à pouvoir, à des coûts réduits, palier au problème de sécurité
qui sévit dans notre pays en ces jours. Et de plus, du fait qu’elle est pratiquement pas intru-
sive, elle est facilement utilisable dans des lieux publics (aéroports, marchés, super-marchés,
etc...) sans que personne ne s’en rende compte. Et mieux encore avec cette technologie, des
grands magasins peuvent effectuer des présentations personnalisées à leurs clients.

1.5 Conclusion

A travers ce chapitre, il a été question pour nous de parler de la biométrie en général et de

présenter les raisons du choix portés sur la reconnaissance faciale. Il est également à noter
que, les critères de choix d’implémentation d’une technologie biométrique sont les suivants :
le coût de la technologie (lecteurs, capteurs, etc...), le niveau de perception par l’utilisateur

Rédigé par Wilfried NZIWOUE 10 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

du test comme intrusif, l’effort requis par l’utilisateur, l’efficacité de la méthode (capacité à
identifier quelqu’un).

Rédigé par Wilfried NZIWOUE 11 Telecoms & IT Student Engineer - FGI

Chapitre 2

Etat de l’art de la reconnaissance faciale

2.1 Introduction

Depuis des années, des recherches visant à identifier et/ou à reconnaître un visage humain,
ont été menées. De celles-ci ont découlé différentes méthodes plus ou moins efficaces. Le but
de ce chapitre est de présenter les méthodes utilisées dans le cadre de la détection et de la
reconnaissance d’un visage.

2.2 La détection de visage

La détection de visage est le domaine de la vision par ordinateur qui consiste à détecter
un ou plusieurs visages humains dans une image numérique. Elle fait partie de la grande
famille de la détection des objets en traitement d’image.

Les méthodes de la détection du visage ont été classifiées par [MHYDN41] en quatre caté-
gories :

2.2.1 Approche basée sur les connaissances acquises

Selon [ABA08] cette approche s’intéresse aux parties caractéristiques du visage comme
le nez, la bouche et les yeux. Elle se base sur la définition de règles strictes à partir des
rapports entre les caractéristiques du visage. Ces méthodes sont principalement conçues pour
la localisation du visage dans une image. Tout d’abord, les caractéristiques du visage sont

12
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

localisées à l’aide de la méthode de projection permettant de détecter les contours du ou des

visages présents. Soit I(x, y), l’intensité de la luminance du pixel (x, y) de l’image m ∗ n, les
projections horizontale et verticale de cette image sont définies par

n
X
HI(x) = I(x, y)
y=1

et
n
X
V I(x) = I(x, y)
x=1

Le profil horizontal de l’image originale est calculé en premier. Les deux minima locaux sont
déterminés, ils correspondent aux bords gauche et droit du visage. Ensuite, le profil vertical
est à son tour calculé. Les minima locaux de ce profil vertical correspondent aux positions
de la bouche, du nez et des yeux. L’inconvénient de cette méthode est qu’elle n’arrive pas à
détecter le visage lorsque ce dernier se trouve sur un arrière plan complexe.

Toutefois, Yang and Huang [HY71] quant à eux, ont étudié les évolutions des caractéris-
tiques du visage en fonction de la résolution. Quand la résolution de l’image d’un visage est
réduite progressivement, par sous-échantillonnage ou par moyenne, les traits macroscopiques
du visage disparaissent. Ainsi, pour une résolution faible, la région du visage devient uniforme.
Au travers de cette observation, Yang et Huang ont proposé une méthode hiérarchique de
détection de visages. En commençant par les images à faible résolution, un ensemble de vi-
sages de candidat est déterminé à l’aide d’un ensemble de règles permettant de rechercher les
régions uniformes dans une image. Les candidats de visage sont ensuite vérifiés en cherchant
l’existence de traits faciaux proéminents grâce au calcul des minima locaux à des résolutions
supérieures. Une caractéristique intéressante de cette technique « descendante » de recherche
de zone d’intérêt (informations globales vers des informations plus détaillées) est de réduire le
temps de calcul nécessaire par l’utilisation d’images sous-échantillonnées. Malheureusement,
cette technique occasionne de nombreuses fausses détections et un taux faible de détection.

Rédigé par Wilfried NZIWOUE 13 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

2.2.2 Approche basée sur le «Template-matching»

Comme mentionné dans [ABA08], les templates peuvent être définis soit " manuellement
", soit paramétrés à l’aide de fonctions. L’idée est de calculer la corrélation entre l’image can-
didate et le template. Ces méthodes rencontrent encore quelques problèmes de robustesse liés
aux variations de lumière, d’échelle, etc. Sinha [Sin54] [Sin95] utilise un ensemble d’invariants
décrivant le modèle du visage. Afin de déterminer, les invariants aux changements de lumino-
sité permettant de caractériser les différentes parties du visage (telles que les yeux, les joues,
et le front) ; cet algorithme calcule ainsi les rapports de luminance entre les régions du visage
et retient les directions de ces rapports (par exemple, la région 1 est elle plus claire ou plus
sombre que la région 2). La figure 2.2.2 est un exemple de modèle prédéfini correspondant à
23 relations pouvant être utilisées pour former un template.

Figure 2.1 – Modèle de visage composé de 16 régions tiré de [ABA08] à la page 24

2.2.3 Approche basée sur l’apparence

Ces approches appliquent généralement des techniques d’apprentissage automatique. Ainsi,

les modèles sont appris à partir d’un ensemble d’images représentatives de la variabilité de
l’aspect du visage. Ces modèles sont alors employés pour la détection. L’idée principale de
ces méthodes étant de considérer le problème comme celui d’une classification (visage, non-
visage), l’une des approches plus utilisée est l’Eigenface , elle consiste à projeter l’image
dans un espace et à calculer la distance euclidienne entre l’image et sa projection. En effet,
en codant l’image dans un espace, on dégrade l’information contenue dans l’image, puis on

Rédigé par Wilfried NZIWOUE 14 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

calcule la perte d’information entre l’image et sa projection. Si cette perte d’information est
grande (évaluée à partir de la distance, que l’on compare à un seuil fixé à priori), l’image n’est
pas correctement représentée dans l’espace : elle ne contient pas de visage. Cette méthode
donne des résultats assez encourageants, mais le temps de calcul est très important.

Dans Rowley et al. [RBK98], les auteurs proposent un système de détection de visage se
basant sur la classification par des réseaux de neurones. Leur technique est divisée en deux
étapes : la localisation des visages en utilisant un réseau de neurones et la vérification des
résultats obtenus. Les auteurs ont construit un réseau de neurones qui, à partir d’une image
prétraitée de 20x20 pixels, indique s’il s’agit d’un visage ou non. Le pré-traitement consiste
à égaliser l’histogramme, l’image étant balayée avec des fenêtres de 20x20. Pour détecter les
visages de différentes tailles, une analyse multi-résolutions est alors effectuée.

2.2.4 Approche basée sur des caractéristiques invariantes

D’après [ABA08], ces approches sont utilisées principalement pour la localisation de visage.
Les algorithmes ainsi développés visent à trouver les caractéristiques structurales existantes
même si la pose, le point de vue, ou la condition d’éclairage peuvent varier. Puis ils emploient
ces caractéristiques invariables pour localiser les visages. L’implémentation de cette approche
se fait soit par la la couleur de la peau ou par les caractéristiques de visage (les deux yeux,
les deux narines et la jonction nez/lèvre).

L’algorithme développé par De Silva et al. [LCDSH95] est un exemple typique des méthodes
basées sur les caractéristiques. Leur algorithme utilise tout d’abord une hypothèse sur la
position du haut du visage ensuite l’algorithme de recherche parcourt le visage de haut en
bas afin de trouver l’axe des yeux « eye-plane » caractérisé par une augmentation soudaine
de la densité de contours (mesurée par le rapport noir/blanc le long des plans horizontaux).
La longueur entre le haut du visage et le plan de l’oeil est alors utilisée comme une longueur
de référence pour construire un « template » facial flexible.

Rédigé par Wilfried NZIWOUE 15 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

2.3 La reconnaissance de visage

La reconnaissance de visage définie par [Wik15b] comme étant " un domaine de la vision
par ordinateur consistant à reconnaître automatiquement une personne à partir d’une image
de son visage " peut s’effectuer aussi bien sur une vidéo et sur une photo. Cependant dans
le cadre de ce travail, nous l’effectuerons uniquement sur des images. On peut facilement
répartir l’ensemble des techniques de reconnaissance de visage, en trois grandes catégories :
les méthodes globales, les méthodes locales et les méthodes hybrides.

2.3.1 Méthodes globales

Ces méthodes dites globales ou encore holistiques sont des méthodes qui utilisent toute la
région du visage comme information d’entrée. Son principal inconvénient peut résider dans la
taille des données à stocker lors de la phase d’apprentissage. Cependant avec l’actuel capacité
de stockage de nos ordinateurs, nous pouvons relativement palier à ce problème.

Parmi les méthodes globales, nous pouvons citer :

• l’ACP Analyse des Composantes Principales(encore appelée EigenFace) qui sera mieux
détaillé dans le chapitre 3 débuttant à la page 21, car c’est la technique utilisée dans
notre travail ;

• l’ADL Analyse Discriminante Linéaire(encore appelée FisherFace) les méthodes basées

sur l’Analyse Discriminante Linéaire (ADL) déterminent les directions de projection les
plus discriminantes dans l’eigenspace. Pour cela, elles maximisent les variations inter-
personne par rapport aux variations intra-personne. Cependant, si un seul exemple
d’apprentissage par personne est utilisé, c’est-à-dire si les variations intra-classes sont
nulles, alors les performances de l’ADL deviennent faibles par rapport à celles qui sont
données par l’eigenface. Afin de remédier à ce problème, des chercheurs ont proposé de
remplacer la matrice de dispersion intra-personne par une matrice constante. Ainsi, la
méthode basée ADL se réduit alors à la méthode eigenface ;

• L’approche Probabiliste transforme le problème d’identification de visage en un pro-

blème de classification en deux classes. Elle évalue la probabilité de la différence entre

Rédigé par Wilfried NZIWOUE 16 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

une image de test et une image prototype appartenant aux classes intra-personne et
inter-personne. Notons que la distribution intra-personne ne peut pas être évaluée dans
le cas d’un exemple par personne, et la méthode se ramène aussi à la méthode eigenface.

Remarque : Les méthodes basées sur une approche holistique (globale) ont toute en com-
mun le fait que chaque image de dimension (n ∗ m) pixels est représentée par un vecteur
simple de dimension n ∗ m appélé vecteur image, en concaténant les valeurs du niveau de gris
de tous les pixels de l’image du visage. Et la concaténation de tous ces vecteurs images au
sein d’une matrice forme l’espace image.

2.3.2 Méthodes locales

Les méthodes locales prennent pour données de calcul les caractéristiques locales du visage
pour sa reconnaissance . Elles sont relativement matures comparées aux méthodes holis-
tiques (globales) . Dans ces méthodes, le visage est représenté par un ensemble de vecteurs
caractéristiques de dimensions faibles, plutôt que par un seul vecteur de grande dimension.

Les méthodes locales peuvent être classifiées en deux catégories : les méthodes basées
sur les caractéristiques locales : extractions et localisation des points caractéristiques,
et les méthodes basées sur les apparences locales : partitions des images de visage en
régions caractéristiques.

Méthodes basées sur les caractéristiques locales

Les approches basées sur l’extraction de points caractéristiques sont composées de deux
catégories : les approches géométriques et les approches basées sur les graphes.

Approches géométriques : elles se basent sur l’extraction de la position relative des

éléments qui constituent le visage (tels que le nez, la bouche et les yeux). La plupart de
ces approches utilisent des points d’intérêt (comme les coins de la bouche et des yeux).
Au début des années 1990, des chercheurs ont décrit un système de reconnaissance faciale
qui extrait automatiquement 35 (trente cinq) caractéristiques géométriques du visage. La
similitude est calculée à l’aide de ”classifieurs de Bayes”. Pour les 47 (quarante sept) sujets
étudiés, l’approche a atteint un taux d’identification 90%. Et de plus, le coût de stockage des

Rédigé par Wilfried NZIWOUE 17 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

techniques géométriques est très bas comparé à celui des autres techniques. Cependant, ces
approches présentent des inconvénients, notamment :

• les caractéristiques géométriques sont généralement difficiles à extraire, surtout dans

des cas complexes : illumination variable, occultations, etc ;

• les caractéristiques géométriques seules ne suffisent pas pour représenter un visage,

tandis que d’autres informations utiles comme les niveaux de gris de l’image ne sont
pas du tout exploitées.

Approches basées sur les graphes : à défaut d’utiliser les caractéristiques géométriques
du visage, des chercheurs ont opté de représenter les caractéristiques locales du visage sous
forme de graphes. Ils ont donc mis sur pied une méthode de détection de caractéristiques
locales du visage, basée sur la décomposition en ondelettes de Gabor. La reconnaissance
de visages est alors formulée comme un problème de mise en correspondance de graphes.
L’efficacité de cette méthode a été validée sur un ensemble de données de visage de 86
sujets, contenant des variations d’expression et de pose, un taux de reconnaissance de 90%
en moyenne a été rapporté démontrant la robustesse de cette approche. Mais hélas après
construction, le graphe topologique ne peut pas être modifié. Cependant, les images de visage
sont toujours sujettes à des changements (illumination, expression, pose, etc.), et du coup un
schéma de graphe topologique fixe n’est plus adéquat.

Méthodes basées sur l’apparence locale (Local apparence-based methods)

Ces techniques s’utilisent de manière modulaire pour les différentes régions faciales. Le
modèle global est alors défini à partir de la combinaison des différents modèles locaux. De
ce fait, les différentes régions du visages ne seront plus affectées de la même manière par
variations possibles lors de la prise de l’image( le port de lunettes de soleil change considé-
rablement l’aspect des yeux, tandis qu’un sourire affecte plus la région de la bouche ). Dans
cette approche, le visage est caractérisé par sa forme (rectangle, ellipse) et sa taille. Les
caractéristiques des régions locales s’obtiennent à partir d’une analyse des valeurs de niveau
gris. Des techniques comme les Ondelettes de Gabor et l’analyse fractale sont aussi utilisées
pour l’extraction de caractéristiques. En général, les caractéristiques à base de valeurs de

Rédigé par Wilfried NZIWOUE 18 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

gris préservent l’information de texture, tandis que les caractéristiques de Gabor sont plus
robustes face aux changements d’illumination et aux transformations géométriques .

ACP et ADL modulaire : des chercheurs ont introduit l’approche des « Modular
Eigenspase ». Les régions faciales ainsi prises en compte sont : la totalité du visage, les yeux
et le nez. Une ACP est appliquée sur chacune de ces régions et les résultats de classifications
obtenus sont agrégés. La prise en compte de la bouche dans cette approche engendre radica-
lement la baisse du taux de reconnaissance, car elle est la partie du coprs humain peu sensible
aux changements d’expressions. Cette approche peut être ainsi qualifiée d’hybride, puisque
utilisant des caractéristiques globales et locales dans son implémentation. Les auteurs ont
montré qu’elle est plus efficace que les techniques globales ou strictement locales appliquées
séparément.

Les approches probabilistes locales modulaires : des chercheurs font montre d’une
approche probabiliste locale pour la reconnaissance de visages avec des occultations par-
tielles et des variations d’expression. Ils utilisent un seul exemple d’apprentissage par classe.
Chaque visage est divisé en six régions locales sous forme d’ellipses. Les régions ayant les
mêmes positions pour chaque visage sont groupées séparément dans un sous-espace. Pour
une représentation plus compacte et efficace, chaque sous-espace de visage est à nouveau
transformé dans un eigenspace, où la distribution est évaluée par la moyenne d’un modèle de
mélange de Gaussiennes en utilisant des algorithmes précis. Dans l’étape d’identification, les
images de test sont aussi divisées en six régions locales et sont projetées respectivement dans
l’eigenspace calculé. Une approche probabiliste plutôt qu’une approche de vote est utilisée
pour mesurer la similitude d’un appariement donné. Les tests sur un jeu de 2600 images ont
montré que l’approche probabiliste locale ne réduit pas la précision même pour 16 des visages
partiellement occultés.

2.3.3 Méthodes Hybrides

Les méthodes hybrides sont des approches qui combinent les caractéristiques holistiques et
locales afin d’améliorer les performances de la reconnaissance de visage. En effet, les caracté-
ristiques locales et les caractéristiques globales ont des propriétés tout à fait différentes. On

Rédigé par Wilfried NZIWOUE 19 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

peut espérer pouvoir exploiter leur complémentarité pour améliorer la classification.

2.4 Conclusion

L’état de l’art de la détection et de la reconnaissance d’un visage est très dense, nous
y trouvons une multitude d’algorithmes que nous ne pouvons malheureusement tous citer.
Cependant il est important de retenir que la détection d’un visage dans une image peut
se faire selon une approche basée sur les connaissances acquises, une approche basée sur le
template matching, une approche basée sur l’apparence ou alors selon une approche basée
des caractéristiques invariantes. Et concernant la reconnaissance de visage, elle s’effectue en
utilisant soit une méthode globale , une méthode locale ou une méthode hybride.

Rédigé par Wilfried NZIWOUE 20 Telecoms & IT Student Engineer - FGI

Chapitre 3

La reconnaissance faciale par la

technique des EigenFaces

3.1 Introduction

A travers ce chapitre, nous allons présenter l’utilisation de la technique des eigenFaces pour
la reconnaissance faciale. Cette technique, commme bien d’autres, a besoin pour son implé-
mentation que le système de reconnaissance soit divisé en deux principaux sous-systèmes,
le sous-système d’apprentissage de l’individu et le sous-système de reconnaissance de l’indi-
vidu. Cependant, il est très souvent judicieux de placer avant ces deux blocs un module de
pré-traitement de l’image acquise.

3.2 Le module de pré-traitement de l’image

Du fait que les images avec lesquelles nous travaillons dans le système proviennent généra-
lement de différentes sources, elles possèdent généralement des fonds différents, des variations
de contrastes , des résolutions différentes et sont de tailles différentes. Il nous a ainsi paru
nécessaire de mettre à l’entrée du système un module de pré-traitement de ces images dont
le rôle principal est la normalisation de l’image à son entrée dans le système.

Afin d’illustrer les différents traitements effectués, nous les avons appliqués sur cette image
source.

21
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 3.1 – Image d’entrée pour les différents traitements

Pour la normalisation de l’image, le module applique les traitements suivants :

3.2.1 Transformation en une image à niveau de gris

Cette transformation permet, dans le cas et rien que dans le cas où l’image source est en
couleur, de la transformer en une image Noir/Blanc afin de réduire la taille en mémoire de
l’image. Car celle-ci est désormais représentée uniquement sur une seule couche et la valeur
d’un pixel est comprise entre 0 et 255 car codée sur 8 bits. La figure ci-dessous présente le
résultat de ce traitement sur l’image de la figure 3.1 .

Rédigé par Wilfried NZIWOUE 22 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 3.2 – Image transformée en Noir/Blanc

3.2.2 Étirement d’histogramme

Étirement d’histogramme ou encore égalisation d’histogramme est un traitement d’image

permettant de répartir au mieux les intensités lumineuses sur l’ensemble de la plage de valeurs
possibles (0 et 255). Ce traitement permet ainsi d’ajuster le contraste de l’image. L’image
ci-dessous illustre l’application du dit traitement sur l’image de la figure 3.2

Rédigé par Wilfried NZIWOUE 23 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 3.3 – Image après l’égalisation de l’histogramme

3.2.3 Application du filtre médian

L’application du filtre médian nous permet d’éliminer un type particulier de bruit, dit «Salt
and Pepper noise» qui consiste en des tâches dispersées d’intensité très forte ou très faible.
L’utilisation de ce filtre est très importante car malgré la réduction du bruit dans l’image,
elle conserve également les contours ; ce qui est très utile pour la détection d’un visage et
sa réconnaissance. La figure ci-après illustre l’application du filtre médian sur l’image de la
figure 3.2

Rédigé par Wilfried NZIWOUE 24 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 3.4 – Image après application du filtre médian

3.2.4 Redimensionnement de l’image pour une taille de 112∗92 pixels

Il s’agit en fait ici de respectivement réduire ou augmenter la taille de l’image pour qu’elle
soit de 112 ∗ 92 pixels. La figure ci-dessous montre un exemple de redimensionnement d’une
image ; L’image ci-après illustre le redimensionnement de l’image de la figure 3.4

Figure 3.5 – Image redimensionnée à la taille 112*92 pixels

Rédigé par Wilfried NZIWOUE 25 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Remarque : le redimensionnement de l’image ne s’effectue que lorsque l’image est prête

pour se faire identifier ou authentifier.

3.3 Sous-système d’apprentissage de l’individu par les Ei-

genFaces

Le sous système d’apprentissage de l’individu, utilise la partie apprentissage de la technique

dite des faces propres encore appelés les «EigenFaces» pour son fonctionnement.

3.3.1 Principe de fonctionnement

De prime abord , nous avons choisi cette technique car elle est une méthode très utilisée
pour la reconnaissance de visage, relativement simple, et possédant un bon fondement ma-
thématique. Toutefois, comme toute méthode de reconnaissance faciale, à caractère globale,
elle nécessite pour son bon fonctionnement un nombre considérable de photos de visage par
individu, et de plus la précision de cette méthode va croissant avec le nombre de photo de
visage d’un individu. Le diagramme ci-dessous tiré de [ABA08] à la page 40 illustre au mieux
ce qui est dit.

Figure 3.6 – Taux d’identification moyen en fonction du nombre d’exemples d’apprentissage

par individu tiré de [ABA08] à la page 40

Rédigé par Wilfried NZIWOUE 26 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

De ce fait, nous avons choisi prendre 10 photos par individu pour notre base d’apprentis-
sage.

Les étapes de la phase d’apprentissage des Eigenfaces sont les suivantes :

1. Pour chaque image normalisée d’un individu I(x, y), de dimension N ∗ P (dans
notre cas ; N=112, P=92 ). Transformer sa matrice d’image en un un vecteur colonne
x de dimension L ∗ 1 avec L = N ∗ P ;

2. Former la matrice

S = {x1 , x2 , x3 , x4 , x5 , x6 , x8 , x9 , x10 , .........................., xM } (3.1)

avec M = I * Nombre de photo par individu (10 dans notre cas) ; où I = Nombre
d’individus de la base d’apprentissage ;

3. Calculer le vecteur image moyen par la formule :

M
1 X
ψ= xn (3.2)
M n=1

Le vecteur visage moyen obtenu est un vecteur de taille L ∗ 1. Il servira par la suite
à l’analyse d’image.

4. Calculer la différence entre les vecteurs images d’entrée xi et l’image moyen :

φi = xi − ψ 1≤i≤M (3.3)

φi est un vecteur de dimension L∗1. Il est en fait la représentation de l’image d’entrée,

ne comportant que ses informations propres.

5. Calculer la matrice de covariance, D :

D = QQT (3.4)

Rédigé par Wilfried NZIWOUE 27 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

avec

Q = [φ1 , φ2 , φ3 , φ4 , φ5 , φ6 , φ7 , φ8 , φ9 , φ10 , ................., φM ] (3.5)

De ce fait, Q est une matrice de dimension de taille L ∗ M . Impliquant que D est

une matrice de taille L ∗ L

6. Réduire l’information en limitant les composantes de travail.

Pour le faire, nous devrons appliquer l’ACP sur la matrice D. Toutefois, étant de
dimensions L ∗ L , nous allons à la place utiliser une matrice de dimension inférieure
mais dont il existe une relation entre ses vecteurs propres et les vecteurs propres de la
matrice D.
Considérons la matrice
E = QT Q (3.6)

L’utilisation de E nous réduit la charge de travail car elle est de taille M ∗ M . En

résultat de l’application de l’ACP, nous obtenons des vecteurs propres orthogonaux
entre eux ei de taille M ∗ 1 et les valeurs propres y associées λi .

7. Déduire les vecteurs propres di de la matrice D et valeurs propres λi asso-

ciées.

En effet nous avons la relation suivante :

Eei = QT Qei = λi ei (3.7)

La multiplication de part et d’autre de cette relation par Q nous permet d’obtenir :

QEei = QQT Qei = Qλi ei (3.8)

| {z }
D

Rédigé par Wilfried NZIWOUE 28 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Ainsi,
DQei = λi Qi ei (3.9)

Par analogie avec l’équation 3.7, nous pouvons déduire l’équation suivante :

di = Qei (3.10)

Pour que les vecteurs di soient véritablement utilisables, il faut les "normer ".

di
di = (3.11)
||di ||

On obtient ainsi des vecteurs propres di de taille M ∗ 1 normés et orthogonaux entre-

eux ; de valeur propre associée λi (valeur propre associée à ei ).

8. Déterminer les faces propres à utiliser dans la phase de reconnaissance.

Ici, il faut choisir les N vecteurs propres de plus grandes valeurs propres. Dans notre
cas, ce sont les N = 40 premiers vecteurs propres possédant les plus grandes valeurs
propres.

Nous pouvons nous rendre compte que l’utilisation de l’ACP a permis une réduction
des données de travail car l’on est passé de l’utilisation de 10 ∗ Iavec (I ≥ 40)1 à l’uti-
lisation de N = 40 vecteurs uniquement. Cependant, la quasi-totalité des informations
utiles a été conservée.

9. Calculer les poids de chaque visage propre φi

1
I ≥ 40 car la base de données d’images (ORL face database) que nous avons utilisée possède 40 individus
avec 10 images chacun.

Rédigé par Wilfried NZIWOUE 29 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Les faces propres obtenues à l’étape précédente forment désormais un espace vectoriel
euclidien 2
V, possédant une base orthonormée B, formée par nos 40 visages propres,
dans laquelle nous pouvons représenter tous nos visages normalisé.

Ainsi la décomposition de φi dans la base B est donnée par :

N
X
φi = ωji dj (3.12)
j=1

Avec

ωji = dTj φi (3.13)

Ainsi, on a :

 
i
 ω1 
 
 ωi 
 2
 
 i
 ω3 
φi = 
 i
 avec 1 ≤ i ≤ M (3.14)
 ω4 
 
 . 
 .. 
 
 
i
ωN

Comme nous le constatons, le processus d’apprentissage prend fin lorsque le système

connaît les N "faces propres" qu’il devra utiliser pour la phase de reconnaissance et qu’il
aura calculer les poids de chaque visage propre.

3.4 Sous-système reconnaissance

Le sous-système de reconnaissance se compose de trois blocs, le bloc détection du visage,

le bloc identification de l’individu et celui d’authentification de l’individu. Dans la partie
2
un espace vectoriel euclidien est un espace vectoriel de dimension finie sur le corps des réels, muni d’un
produit scalaire.

Rédigé par Wilfried NZIWOUE 30 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

suivante, nous allons détailler le fonctionnement de chaque bloc.

3.4.1 Principe de fonctionnement du bloc «Détection du visage»

Le bloc détection du visage, comme son nom l’indique a pour principal objectif de détec-
ter un ou plusieurs visage(s) sur une image. Et, pour le faire, il utilise une API (Application
Programming Interface) dénommée OpenCV. Une présentation plus complète de OpenCV
est faite à l’annexe 1.3.

Pour effectuer cette cruciale tâche, de détection de visage, nous avons utilisé le classificateur
"haarcascade_frontalface_alt.xml" disponible dans OpenCV. Toutefois, elle ne détecte dans
la majeur partie des cas que les visages frontaux, c’est pour cette raison, que l’angle de prise
de vue de l’image doit être le meilleur possible (prise de vue frontale).

La figure ci-après montre un exemple de détection de visage sur une image.

Figure 3.7 – Illustration de la détection visage à l’aide d’OpenCV

Rédigé par Wilfried NZIWOUE 31 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

3.4.2 Principe de fonctionnement du bloc «Identification de l’indi-

vidu»

Après avoir normalisé et détecté le ou les visage(s), sur l’image d’entrée, le système peut
déjà identifier le ou les individu(s). Identifier un individu consiste à déterminer son identité
à partir de l’image de son visage. Pour le faire, le système procède comme suit :

1. Considérons l’image du visage d’entrée comme A, ainsi, A est de taille L ∗ 1, comme

précisé à l’étape 1 à la page 27

2. Déterminer le visage propre ΓA par le calcul :

ΓA = A − ψ (3.15)

3. Ecrire ΓA dans la base B.  

A
 ω1 
 
ωA 
 2
 
 A
 ω3 
ΓA = 
 A
 (3.16)
 ω4 
 
 . 
 .. 
 
 
A
ωN

Avec
ωjA = dTj .ΓA ; 1≤j≤N (3.17)

4. Calculer la distance euclidienne ai entre ΓA et φi

D’après 3.14 et 3.16, on a :

N
X
a2i = (ωji − ωjA )2 1≤i≤N (3.18)
j=1

Ainsi, v
q u N
uX
2
ai = ai = t (ωji − ωjA )2 (3.19)
j=1

Rédigé par Wilfried NZIWOUE 32 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

5. Le vecteur φi dont ai = min{a1 , a2 , a3 , ........, aM }, détermine au plus près l’identité de

l’individu.

3.4.3 Principe de fonctionnement du bloc «Authentification de l’in-

dividu»

Authentifier un individu est le fait de déterminer si un individu X est bel et bien celui qui
prétend être. D’après cette définition, on se rend bien compte que authentifier un individu
revient à faire une comparaison entre l’image du visage de l’individu proclamé
(se retrouvant dans la BD 3 ) et l’image du visage de l’individu à authentifier.

En définitive, les différentes actions que le système effectue sont les suivantes : l’apprentis-
sage d’un individu, l’identification d’un individu et l’authentification d’un individu. La figure
ci-après illustre schéma fonctionnel de notre système.

3
Base de Données

Rédigé par Wilfried NZIWOUE 33 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 3.8 – Schéma fonctionnel du système

Rédigé par Wilfried NZIWOUE 34 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

3.5 Conclusion

Dans ce chapitre, nous avons expliciter au mieux le procédé de reconnaissance de visage

par la méthode des EigenFaces. Il est à noter que, afin d’obtenir un fort taux de recon-
naissance, il est nécessaire d’avoir un grand nombres de photos par individu lors de la phase
d’apprentissage.

Rédigé par Wilfried NZIWOUE 35 Telecoms & IT Student Engineer - FGI

 Deuxième partie

IMPLEMENTATION DE LA
SOLUTION

36
Chapitre 4

Analyse des besoins

4.1 Introduction

Dans ce chapitre, nous allons présenter les différentes fonctions principales que notre sys-
tème devra posséder et les contraintes d’implémentations de ces fonctions. La présentation
d’une fonction passe par la mise en exergue de son nom et du critère permettant d’évaluer si
oui ou non cette fonction a été remplie lors du fonctionnement du système. Cependant, dans
un soucis de mieux expliciter les attentes de notre système, nous avons fourni en annexe 3.2
un cahier de charge comportant toutes les informations pratiques du système.

4.2 Présentation des fonctions principales de notre sys-

tème

4.2.1 Fonction N˚ 1

Nom Identifier un individu sur une photo.

Critère Fournir des informations sur un individu détecté dans une image et se trouvant
dans la BD .

4.2.2 Fonction N˚ 2

Nom Authentifier un individu sur une photo.

Critère Dire avec un niveau de certitude qu’un individu est bien celui qu’il prétend être.

37
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

4.2.3 Fonction N˚ 3

Nom Apprendre un individu.

Critère Un utilisateur devra être capable d’ajouter un individu dans la base de données
du système à tout moment.

4.2.4 Fonction N˚ 4

Nom Rechercher un individu.

Critère Il devra être possible pour un utilisateur de chercher et dans une certaine mesure
de trouver un individu en fournissant son numéro de CNI (Carte Nationale d’Identité) ou
son nom et son prénom.

4.3 Contraintes d’exécution des différentes fonctions

4.3.1 Contrainte N˚ 1

Nom Avoir un bon taux de bonne reconnaissance.

Critère Taux de bonne reconnaissance supérieure ou égale au seuil de référence qui sera
déterminé ultérieurement.

4.3.2 Contrainte N˚ 2

Nom Avoir un faible taux de fausse reconnaissance.

Critère Taux de fausse reconnaissance inférieure ou égale au seuil de référence qui sera
déterminé ultérieurement.

4.3.3 Contrainte N˚ 3

Nom Posséder des images d’entrées de mêmes caractéristiques.

Critère N˚ 1 Taille de l’image = 112 * 92 pixels
1
Critère N˚ 2 Format de l’image : JPG

1
extensions de fichier image employant la compression JPEG Joint Photographic Experts Group

Rédigé par Wilfried NZIWOUE 38 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

4.3.4 Contrainte N˚ 4

Nom Avoir des appareils de prise de vue de bonne résolution.

Critère Résolution : 8 MP (MégaPixels)
Flexibilité Minimum : 5 MP ; Maximum : Le meilleur qui existe sur le marché au moment
de l’implémentation du système.

4.3.5 Contrainte N˚ 5

Nom Avoir une base d’apprentissage bien fournie.

Critère Avoir 10 images pour chaque individu dans la base de données de reconnaissance.

4.4 Conclusion

Dans ce chapitre, il a été question pour nous de réaliser une analyse des besoins du système
à concevoir. Afin de mieux documenter cette analyse, un cahier de charge mieux établi se
trouve en annexe 3.2.

Rédigé par Wilfried NZIWOUE 39 Telecoms & IT Student Engineer - FGI

Chapitre 5

Conception

5.1 Introduction

Dans ce chapitre, nous allons présenter les principaux diagrammes de conception et à partir
de ceux-ci ressortir le MCD (Modèle Conceptuel de Donnée) et le MLD (Modèle Logique de
Données) de notre système.

5.2 Principaux diagrammes de conception

Grâce à l’analyse des besoins effectuée au chapitre 4, nous avons pu ressortir les diagrammes
ci-dessous. Ces diagrammes ont été effectués à l’aide du langage UML (Unified Modeling
Language).

5.2.1 Diagramme N˚1 : Diagramme de déploiement

A travers ce diagramme, nous ressortons l’architecture physique de notre système.

40
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.1 – Diagramme de déploiement

Notre système est ainsi basé sur une architecture client - serveur centralisée, avec un
client léger et un serveur lourd.

5.2.2 Diagramme N˚2 : Diagramme de cas d’utilisation

Comme présenté dans le diagramme de déploiement, notre système possède une architec-
ture client-serveur. De ce fait, nous avons un diagramme de cas d’utilisation pour l’appli-
cation cliente et un autre pour l’application serveur.

Rédigé par Wilfried NZIWOUE 41 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.2 – Diagramme de cas d’utilisation pour l’application cliente

Rédigé par Wilfried NZIWOUE 42 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.3 – Diagramme de cas d’utilisation de l’application serveur (partie1)

Rédigé par Wilfried NZIWOUE 43 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.4 – Diagramme de cas d’utilisation de l’application serveur (partie 2)

Rédigé par Wilfried NZIWOUE 44 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

5.2.3 Diagramme N˚3 : Diagramme de classes

Ici, nous présentons les différents diagrammes de classes utilisées .

Figure 5.5 – Diagramme de classe de l’application cliente

Rédigé par Wilfried NZIWOUE 45 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.6 – Diagramme de classe de l’application serveur

5.2.4 Le Modèle Conceptuel de Données (MCD) et le Modèle Lo-

gique de Données (MLD)

Afin d’avoir une facile réalisation des cas d’utilisation du système, à travers une bonne
conception de la base de donnée, nous avons défini les règles de gestions suivantes :

1. Un client se connecte à un ou plusieurs serveurs à des instants différents et un serveur

accepte la connexion de zéro ou plusieurs clients à cet instant ;

2. Un client est ajouté par un et un seul administrateur et un administrateur ajoute

zéro ou plusieurs clients ;

3. Un client authentifie un ou plusieurs individus et un client est authentifié par un ou

plusieurs clients ;

Rédigé par Wilfried NZIWOUE 46 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

4. un client apprend un ou plusieurs individus et un individu est appris par un unique

client ;

5. un super-administrateur crée un ou plusieurs administrateur et un administra-

teur est créé par un et un seul super-administrateur ;

De ces règles de gestions, découle le MCD (Modèle Conceptuel de Donnée) et MLD

(Modèle Logique de Données) suivants :

Figure 5.7 – Modèle Conceptuel de Données

Rédigé par Wilfried NZIWOUE 47 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 5.8 – Modèle Logique de Données

5.3 Conclusion

Dans ce chapitre, nous avons présenté les principaux diagrammes nécessaires à la compré-
hension du fonctionnement de notre système, et nous avons également mis sur pied le MCD et
MLD du système. Cependant les diagrammes d’interactions client-serveur et quelques autres
diagrammes sont présentés à l’annexe ??. Nous allons à présent passer à la réalisation de
ce système, en nous fixant pour objectifs la réalisation des fonctions principales de notre
système, et ce, en respectant les contraintes fixées.

Rédigé par Wilfried NZIWOUE 48 Telecoms & IT Student Engineer - FGI

Chapitre 6

Logiciels utilisés durant la conception et

la réalisation de notre solution

6.1 Introduction

Dans ce chapitre, nous allons présenter les différents logiciels que nous avons utilisés dans
notre projet. La présentation de ces logiciels se fera en deux phases, en premier, les logiciels
utilisés dans la phase de l’analyse et de la conception et en second les logiciels utilisés dans
la phase de la réalisation..

6.2 Logiciels utilisés pendant l’analyse et la conception

Durant la phase de l’analyse et la conception, nous avons utilisés les logiciels ci-après :

6.2.1 Enterprise Architect

Présentation générale : Enterprise Architect est un logiciel de modélisation et de concep-

tion UML, édité par la société australienne Sparx Systems. De, par ses fonctionnalités, l’en-
semble des étapes du cycle de conception d’application, il est l’un des logiciel de conception
et de modélisation les plus reconnus.

Site Web : http ://www.sparxsystems.com.au/products/index.html

49
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Version utilisée : Version 10.0

Remarques : Il possède une version d’essaie d’un mois téléchargeable gratuitement sur
leur site web.

Figure 6.1 – Capture d’écran de Enterprise Architec

6.2.2 JMerise

Présentation générale : JMerise de la société JFreeSoft est un logiciel gratuit permettant

d’éffectuer les principaux modèles de la méthode MERISE. Il a été développé en JAVA et
permet la création et l’exécution du scrip SQL (Structured Query Language) dans différents
serveurs.

Site Web : http ://www.jfreesoft.com/JMerise/

Rédigé par Wilfried NZIWOUE 50 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Version utilisée : Version 0.4.0.0

Figure 6.2 – Capture d’écran de JMerise

6.3 Logiciels utilisés pendant l’analyse et la conception

6.3.1 Notepad++

Présentation générale : Notepad ++ est un éditeur gratuit de texte générique codé en

C++, qui intègre la coloration syntaxique de code source pour les langages et fichiers C,
C++, Java, XML, HTML, PHP, JavaScript, makefile, art ASCII, doxygen, etc... Et ainsi
que pour tout autre langage informatique, car ce logiciel propose la possibilité de créer ses
propres colorations syntaxiques pour un langage quelconque.

Site Web : https ://notepad-plus-plus.org/fr/

Rédigé par Wilfried NZIWOUE 51 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Version utilisée : Version 6.8.7

Figure 6.3 – Capture d’écran de Notepad ++

6.3.2 Android Studio

Présentation générale : Android Studio est un environnement de développement gra-

tuit pour développer des applications Android. Il est basé sur IntelliJ IDEA qui est est un
IDE(Integrated Development Environment) Java commercial développé par JetBrains.

Site Web : http ://developer.android.com/sdk/index.html

Remarques : Pour son installation, il faudrait que le JDK (Java Development Kit) soit
préalablement installé.

Version utilisée : Version 1.5

Rédigé par Wilfried NZIWOUE 52 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 6.4 – Capture d’écran de Android Studio

6.3.3 Java Development Kit

Présentation générale : Le Java Development Kit (JDK) désigne un ensemble de bi-

bliothèques logicielles de base du langage de programmation Java, ainsi que les outils avec
lesquels le code Java peut être compilé, transformé en bytecode destiné à la machine virtuelle
Java.

Site Web : http ://developer.android.com/sdk/index.html

Remarques : Pour son installation, il faudrait que la JDK (Java Development Kit) le soit
au préalable.

Version utilisée : J2SE 7.0

Rédigé par Wilfried NZIWOUE 53 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

6.3.4 WampServer

Présentation générale : WampServer (anciennement WAMP5) est une plateforme de

développement Web de type WAMP1 , permettant de faire fonctionner localement (sans se
connecter à un serveur externe) des scripts PHP. WampServer n’est pas en soi un logiciel,
mais un environnement comprenant deux serveurs (Apache et MySQL), un interpréteur de
script (PHP), ainsi que phpMyAdmin pour l’administration Web des bases MySQL. Il dispose
d’une interface d’administration permettant de gérer et d’administrer ses serveurs au travers
d’un tray icon (icône près de l’horloge de Windows).

Site Web : http ://www.wampserver.com/

Version utilisée : Version 2.4

Figure 6.5 – Capture d’écran de WampServer

1
WAMP pour Windows, Apache, MySQL, PHP est une architecture comportant ces quatres composants
dont le rôle respectifs est d’assurer l’attributions des ressources aux trois autres, repondre aux requêtes web
des clients, stocker les données des applications et exécuter les scripts PHP

Rédigé par Wilfried NZIWOUE 54 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

6.3.5 Inno Setuo

Présentation générale : Inno Setup est un logiciel libre permettant de créer des instal-
lateurs pour Windows. Ceux-ci peuvent comporter des scripts programmés en Pascal.

Site Web : http ://www.innosetup.com/

Version utilisée : Version 10.0

Figure 6.6 – Capture d’écran d’Inno Setup

6.4 Conclusion

Dans ce chapitre, nous avons présenté les différents logiciels que nous avons utilisés durant
la conception et la réalisation de notre projet. Toutefois, cette liste n’est pas complète car il
y’a plein de petits outils que nous ont été nécessaire.

Rédigé par Wilfried NZIWOUE 55 Telecoms & IT Student Engineer - FGI

Chapitre 7

Résultats et commentaires

7.1 Introduction

A travers ce chapitre, nous allons tout d’abord parler du fonctionnement général du système
et par la suite présenter successivement les différents résultats obtenus et enfin les observations
que nous avons effectuées. Pour un soucis de compréhension et de facilité de lecture, le serveur
fait référence à l’application serveur, le client fait référence aux applications clientes mobile
(développée pour le système Android pour téléphone et tablette) et PC.

7.2 Fonctionnement général du système

Notre système de reconnaissance faciale est en fait un système central possédant une ar-
chitecture client - serveur avec un serveur lourd et le client étant léger.

Dans un soucis d’interopérabilité et de standardisation, nous avons conçu notre système

pour qu’il fonctionne sur la pile protocolaire TCP/IP (Transport Control Protocol / Inter-
net Protocol). Et au niveau de la couche transport,le protocole utilisé est TCP (Transport
Control Protocol).

De ce fait, le serveur offre les services ci-dessous aux clients à travers les ports suivant :

• La connexion d’une application cliente sur le port 1989 ;

56
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

• L’identification d’un individu sur le port 1992 ;

• L’authentification d’un individu sur le port 1985 ;

• La recherche d’un individu sur le port 2001 ;

• La modification des informations d’un individu sur le port 1987 ;

• L’apprentissage d’un individu sur le port 1962.

Remarque : Ces ports ont été choisis de manière arbitraire car les tests ont juste été faits
dans un environnement contrôlé.
Cependant pour un soucis de sécurité, avant l’utilisation d’un service l’application cliente
doit d’abord s’authentifier au près du serveur. Cette phase d’authentification étant très
cruciale, elle se déroule suivant le protocole CHAP (Challenge Handshake Protocol).

7.2.1 Principe de fonctionnement de l’authentification CHAP

Le principe de l’authentification suivant le protocole CHAP (Challenge HandShake Proto-

col) est le suivant :

1. Après que le client s’est connecté au port du serveur désiré, le serveur génère un message
aléatoire (challenge message) qu’il envoie au client.

2. Après réception du challenge message, le client calcule à l’aide du MD5 (Message Di-
gest 5) le hash de ce message en passant en paramètre la clé sécrète et le pseudo de
l’utilisateur. Et il envoie le hash et le pseudo au serveur.

3. A la reception de ces valeurs, le serveur calcule à son tour le hash à l’aide du MD5 en
passant en paramètre le pseudo reçu et le challenge message préalablement généré.

4. Si le hash calculé par le serveur est le même que celui envoyé par le client, alors le client
est considéré comme étant un client valide et la communication peut alors continuer.
Dans le cas contraire, le serveur ferme l’interface de connexion avec ce client considéré
comme non légitime.

Rédigé par Wilfried NZIWOUE 57 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Sur la figure 7.2.1, nous avons une illustration de l’authentification CHAP à travers le
réseau. Cette capture a été réalisé avec le logiciel Wireshark1

Figure 7.1 – Application du filtre ’tcp.port == 1992’ dans Wireshark

1
Wireshark est un analyseur de paquets libre utilisé dans le dépannage et l’analyse de réseaux informa-
tiques, le développement de protocoles, l’éducation et la rétro-ingénierie.

Rédigé par Wilfried NZIWOUE 58 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.2 – Authentification CHAP

7.3 Présentation des différents résultats

Dans cette partie de ce chapitre, nous allons présenter les différentes applications que nous
avons conçu. En prélude, nous allons présenter l’application Android, ensuite l’application
cliente pour PC (Personal Computer) et enfin l’application serveur. La présentation d’une
application se fera de la manière suivante :

• Nous ferons ressortir les caractéristiques matérielles de l’équipement qui pourra l’exé-
cuter ;

• Présenterons les différentes captures de l’application en cours de fonctionnement et

éventuellement son installation ;

Rédigé par Wilfried NZIWOUE 59 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

7.3.1 L’application Mobile Android

Caractéristiques matérielles requises

Pour son bon fonctionnement, l’application Android devra être installée sur un Smart-
phone2 possédant les caractéristiques suivantes :

• Système d’exploitation du Smartphone : Android

• Applications nécessaires : une application de prise de photo, un lecteur de fichier PDF

(Portable Document Format)

• Version minimum : Android 4.1.1 (JellyBean)

• RAM (Random Access Memory) : 512 MO (MégaOctets)

• CPU (Central Processing Unit) : 1GHz

• ROM (Read Only Memory) : 1 GO (GigaOctets)

• Résolution appareil photo : minimum 5 MP

• Taille de l’écran : avoisinant les 320 x 480 pixels

2
Un smartphone ou téléphone intelligent, est un téléphone mobile évolué disposant des fonctions d’un
assistant numérique personnel, d’un appareil photo numérique et d’un ordinateur portable.

Rédigé par Wilfried NZIWOUE 60 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Captures d’écran de l’application en cours de fonctionnemant :

Figure 7.3 – Accueil de l’application Android

Figure 7.4 – Message d’erreur en cas de combinaison mot de passe et pseudo incorrecte

Rédigé par Wilfried NZIWOUE 61 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.5 – Volet d’identification d’un individu de l’application Android

Figure 7.6 – Voler d’authentification d’un individu de l’application Android

Rédigé par Wilfried NZIWOUE 62 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.7 – Volet de recherche d’un individu de l’application Android

Figure 7.8 – Visage choisi pour identification dans l’application Android

Rédigé par Wilfried NZIWOUE 63 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.9 – Choix du type de détection de visage (automatique ou manuelle) de l’applica-

tion Android

Figure 7.10 – Attente de traitement de l’application Android

Rédigé par Wilfried NZIWOUE 64 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.11 – Résultat de traitement d’identification de l’application Android

Figure 7.12 – Liste des individus détectés

Rédigé par Wilfried NZIWOUE 65 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.13 – Affichage des informations de l’individu sélectionné

Figure 7.14 – Les différentes options offertes

Rédigé par Wilfried NZIWOUE 66 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

7.3.2 L’application Cliente PC

Caractéristiques matérielles requises

Pour son bon fonctionnement, l’application cliente devra être installée sur un ordinateur
possédant les caractéristiques suivantes :

• Système d’expoitation du PC : Windows, Linux.

• Logiciels indispensables : Une JRE (Java Runtime Environment) de version supérieure

à la 7.0 ; un lecteur de Pdf et un outil de modification d’image par défaut.

• RAM : 512 MO

• CPU : DualCore 2x 1 Ghz au minimum

• DD (Dique Dur) : 250 GO

Remarque : Concernant l’installation de la JRE, nous avons deux "setup.exe" l’un com-
prenant en son sein la JRE que l’utilisateur devra installer manuellement par la suite et
l’autre ne contenant pas la JRE dans l’éventualité où l’utilisateur en possède déjà une.

Rédigé par Wilfried NZIWOUE 67 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Captures d’écran de l’application en cours d’installation

Figure 7.15 – Message de bienvenue de l’assistant d’installation

Rédigé par Wilfried NZIWOUE 68 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.16 – Insertion du mot de pass : WilNziCoorporation

Figure 7.17 – Affichage des informations d’installation

Rédigé par Wilfried NZIWOUE 69 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.18 – Installation de l’application dont le setup contient la JRE en son sein

Figure 7.19 – Installation de l’application dont le setup ne contient pas la JRE en son sein

Rédigé par Wilfried NZIWOUE 70 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.20 – Fin de l’installation

Figure 7.21 – Position de l’application dans le menu démarrer

Rédigé par Wilfried NZIWOUE 71 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Captures d’écran de l’application en cours de fonctionnement

Figure 7.22 – Accueil de l’application

Rédigé par Wilfried NZIWOUE 72 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.23 – Espace de choix de l’image à identifier

Figure 7.24 – Photo choisie pour identification

Rédigé par Wilfried NZIWOUE 73 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.25 – Choix entre une détection de visage automatique ou manuelle

Figure 7.26 – Résultat de l’identification

Rédigé par Wilfried NZIWOUE 74 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.27 – Affichage des informations d’un utilisateur

Figure 7.28 – Génération du fichier Pdf contenant les informations de l’individu

Rédigé par Wilfried NZIWOUE 75 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.29 – Message d’erreur lors de la modification des informations d’un individu

Figure 7.30 – Modification des informations terminées avec succès

Rédigé par Wilfried NZIWOUE 76 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.31 – Les différents fonctionnalités offertes par l’application

Figure 7.32 – Interface d’apprentissage d’un individu

Rédigé par Wilfried NZIWOUE 77 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.33 – Formulaire d’insertion d’information d’un individu

Figure 7.34 – Interface d’authentification d’un individu

Rédigé par Wilfried NZIWOUE 78 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.35 – Interface de recherche d’un individu suivant son nom et son prénom

Figure 7.36 – Interface de recherche d’un individu suivant son numéro d’identifiant

Rédigé par Wilfried NZIWOUE 79 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.37 – Les différentes aides proposées à l’utilisateur

7.3.3 L’application Serveur

Caractéristiques matérielles requises

Pour son bon fonctionnement, l’application serveur devra être installée sur un ordinateur
possédant les caractéristiques suivantes :

• Système d’expoitation du serveur : Windows, Linux.

• Logiciels indispensables : Une JRE (Java Runtime Environment) de version supérieure

à la 7.0, un lecteur de fichier Pdf ;

• RAM : 16 GO

• CPU : Intel Core i7 2Ghz x 8

• Disque Dur : minimum 500 GO

Rédigé par Wilfried NZIWOUE 80 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Captures d’écran de l’application en cours de fonctionnement

Figure 7.38 – Démarrage de l’application Serveur

Remarque : A ce moment, le serveur est entrain de mettre à jour la base de données

d’image ; et aucun service n’est encore lancé.

Rédigé par Wilfried NZIWOUE 81 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.39 – Espace de connexion

Figure 7.40 – Espace de connexion en tant que simple administrateur

Rédigé par Wilfried NZIWOUE 82 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.41 – Espace de connexion en tant que super administrateur

Figure 7.42 – Sélection d’un utilisateur

Rédigé par Wilfried NZIWOUE 83 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.43 – Espace d’Affichage et de modification des informations de l’utilisateur sélec-

tionné

Figure 7.44 – Option d’ouverture du fichier "Log"

Rédigé par Wilfried NZIWOUE 84 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

Figure 7.45 – Le fichier "Log"

7.4 Observations apportées

Pendant les différentes phases de test réalisées sur notre système, nous avons pu ressortir
les observations suivantes :

• Pour améliorer la fiabilité du système, il faut que les photos d’apprentissage soient
prises avec des éclairages différents, des expressions différentes mais pas trop varié et
plus encore ces photos doivent être différentes. La prise des photos lors de la phase
d’apprentissage d’un individu étant très importante, nous y avons placé dans l’aide de
l’application cliente PC, une procédure à suivre afin de mieux la réaliser. Et à l’annexe
C, nous pouvons trouver cette même procédure.

• Afin d’améliorer le taux de bonne identification, il est intéressant de prendre plusieurs

photos (avec des changements d’éclairage ; prise de photo avec flash et sans flash) de
l’individu à identifier ;

• Un individu appris ne pourra être identifiable qu’après le redémarrage du serveur.

Rédigé par Wilfried NZIWOUE 85 Telecoms & IT Student Engineer - FGI

 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

• La détection de visage automatique génère très souvent des erreurs d’espace libre dans
la RAM (Random Access Memory) sur la machine de test. Par conséquent, il faudrait
limiter le plus souvent son utilisation.

7.5 Conclusion

Dans ce chapitre , il a été question pour nous de présenter les différentes applications que
nous avons conçus. Cependant, du au manque de temps, certaines fonctionnalités prévues
dans le diagramme de cas d’utilisation de l’application serveur présenté dans les figures 5.3
et 5.4 n’ont pas été réalisées.

Rédigé par Wilfried NZIWOUE 86 Telecoms & IT Student Engineer - FGI

Conclusion Générale

En somme, tout au long de notre travail il a été question pour nous dans un premier temps
de présenter la biométrie en générale et la reconnaissance faciale en particulier. Et dans un
second temps de proposer une implémentation de solution de reconnaissance faciale à l’aide
des EigenFaces.

Durant la réalisation de ce système de reconnaissance faciale, nous avons trouvé que la

détection de visage automatique du visage n’était pas toujours concluante, nous avons de ce
fait offert la possibilité à l’utilisateur de la réaliser manuellement par un simple rognage.

Le système étant encore à sa première version, le taux d’identification avec les variations
de pose n’est pas encore très satisfaisant.

Toutefois, nous espérons avoir apporté une contribution dans ce domaine très innovateur
de la biométrie. Et nous nous donnons pour objectif d’améliorer ce taux à la prochaine
version.

87
Bibliographie

[ABA08] SOUHILA GUERFI ABABSA. Authentification d’individus par reconnaissance

de caractéristiques biométriques liées aux visages 2D/3D. PhD thesis, Université
D’EVRY VAL D’ESSONNE, 03 Octobre 2008.

[BOU] Sofiane BOUDJELLAL. Détection et identification de personne par la méthode

biométrique. Master’s thesis, Faculté de Génie Electrique et d’Informatique,
Université Mouloud MAMMERI de TIZI-OUZOU.

[GAE15] NOTORIO GAETANO. Les étapes du cahier des charges pour une appli-
cation mobile : le cas fini l’ennui, Septembre 2015. http ://www.gaetano-
notorio.com/portfolio/cahier-des-charges-pour-une-application-mobile.

[HY71] T.S. Huang and G. Yang. Human face detection in complex background. Pat-
tern Recognition, pages 53–63, Volume 27(1).

[LCDSH95] K. Aizawa L. C. De Silva and M. Hatori. Detection and tracking of facial

features by using a facial feature model and deformable circular template. IEEE
Trans, Pattern Anal. Mach, Intell, page 1195 ?1207, 1995.

[MA10] FODDA Mohamed Aymen. Détection et reconnaissance de visage. Master’s

thesis, Ecole Supérieure Privée d’Ingénierie et de Technologies, Narsil Tehcno-
logie, 19 Octobre 2010.

[MA 1] TURK Matthew and PENTLAND Alex. Eigenfaces for recognition. Vision and
Modeling Group, The Media Laboratory, Massachusetts Institute of Technology,
pages 72– 76, Volume 3, Number 1.

[Mee10] Team Meetopia. Cahier des Charges Meetopia. Epitech, 2010.

88
 Implémentation d’un système de reconnaissance faciale par la technique des
EigenFaces sous Java et Android

[Mel09] Anouar Mellakh. Reconnaissance des visages en conditions dégradées. PhD

thesis, Institut National des Télécommunications, 07 Avril 2009.

[MHYDN41] Ming-Hsuan, Yang, Kriegman David, J, and Ahuja Narenda. Detecting faces in
images : A survey. Dans IEEE Transactions on Pattern Analysis and Machine
Intelligence, pages 34–58, Volume 24(1).

[Ope15] OpenCV. The OpenCV Tutorials, Release. OpenCV, 26 Février 2015.

[RBK98] H. A. Rowley, S. Baluja, and T. Kanade. Neural network based face detection.
IEEE Trans, Pattern Anal. Mach, Intell, pages 23–38, January 1998.

[Sin54] P. Sinha. Object recognition via image invariants : A case study. Investigative
Ophthalmology and Visual Science, pages 1735–1740, Volume 35(4).

[Sin95] P. Sinha. Processing and Recognizing 3D Forms. PhD thesis, Massachusetts

Institute of Technology, 1995.

[Wik15a] Wikipedia. Détection de visage, 20 Décembre 2015.

https ://fr.wikipedia.org/wiki/Détection_de_visage.

[Wik15b] Wikipedia. Reconnaissance de visage, 20 Décembre 2015.

https ://fr.wikipedia.org/wiki/Reconnaissance_de_visage.

[Wik16a] WikiHow. Déviner un mot de pass, 15 Février 2016.

http ://fr.wikihow.com/deviner-un-mot-de-passe.

[Wik16b] Wikipedia. Smartphone, 15 Février 2016.

https ://fr.wikipedia.org/wiki/Smartphones.

Rédigé par Wilfried NZIWOUE 89 Telecoms & IT Student Engineer - FGI

Troisième partie

ANNEXES

90
Annexe A

Cahier de charge

CAHIER DE CHARGES DE FaceRecognition

Rédigé par

NZIWOUE CHIADJEU Wilfried

Téléphones : 676 571 376 / 697 463 954

Email : [email protected]

Version 2.0

Statut du document : Validé

91
 Annexe A : Cahier de charge de FaceRecognition

Résumé

Ce travail présente une vision sécuritaire où il serait possible d’identifier un individu rien que
par la connaissance de son visage. En effet, au regard des problèmes sécuritaires qui minent
notre société actuelle (La secte islamique, les bandits de grands chemins, les fraudes au exa-
mens nationaux, etc...) , il nous a paru très intéressant de proposer un système qui permettra
d’identifier de manière automatique un individu grâce à l’acquisition et la connaissance de
son visage.

Mots clés : Biométrique, Reconnaissance faciale, Sécurité, Système informatique, Pro-

grammation, Application Java , Application Android, Linux, Matlab.

Rédigé par Wilfried NZIWOUE 92 Telecoms & IT Student Engineer - FGI

 Annexe A : Cahier de charge de FaceRecognition

Information sur le projet

Nom du projet FaceRecognition

Type de document Cahier des charges
Version 2.0
Statut du document Validé

Historique des révisions du document

Version Date Description

0.1 13/09/2015 Création du document
1.0 06/10/2015 Réinitialisation du document
2.0 28/12/2015 Ajout des fonctions principales et secon-
daires

1 Nature du document

1.1 Objectif du document

Ce cahier des charges vise à définir les « spécification de base » de notre projet FaceRecog-
nition.

En interne, ce cahier de charge permettra d’établir de manière certaine les différentes tâches
à effectuer et leur délai de réalisation.

En externe, ce document servira de point de référence lors des tests de fonctionnalités du

livrable.

1.2 Ce que comprend le document

Ce document comprend les spécifications listées ci-dessous :

• les objectifs généraux à atteindre ;

• les modalités d’exécution sans toutefois entrer en profondeur dans les solutions utilisées ;

Rédigé par Wilfried NZIWOUE 93 Telecoms & IT Student Engineer - FGI

 Annexe A : Cahier de charge de FaceRecognition

• les critères d’évaluations des livrables ;

• les contraintes principales ;

1.3 Ce que ne comprend pas le document

Ce document ne comprend pas :

• les descriptions techniques des solutions utilisées ;

• les concepts mathématiques utilisés pour la réalisation de FaceRecognition ;

2 Présentation générale du projet

2.1 Besoin et contexte

Une observation assez orientée permet de se rendre compte du fait que : une personne peut
très facilement se présenter dans un service administratif, à l’entrée d’un examen national,
dans une entreprise et affirmer s’appeler telle ou telle sans que personne ne soit capable
d’infirmer ou affirmer son assertion. De plus, il est possible et facile pour un individu recherché
de passer incognito à travers un point de contrôle et même de se faire interpeller par la police
sans être inquiéter ; ceci étant dû au fait que les forces de l’ordre et les agents de sécurité
n’ont pas de moyens d’obtenir de manière rapide et efficace les informations sur un individu.

C’est dans cette optique que nous avons décidé de concevoir un système qui permettra
d’identifier ou d’authentifier un individu sur une photo ou/et une vidéo. Ce système devra
être terminé avant Janvier 2016.

2.2 Description du système

Durant son fonctionnement, le système devrait permettre à un utilisateur d’enregistrer un

nouvel individu dans la base de données , d’identifier, de rechercher, et d’authentifier un
individu.

Rédigé par Wilfried NZIWOUE 94 Telecoms & IT Student Engineer - FGI

 Annexe A : Cahier de charge de FaceRecognition

2.3 Expression fonctionnelle des besoins

Fonction N˚ 1

Nom Identifier un individu sur une photo.

Critère Fournir des informations sur un individu détecté dans une image et se trouvant
dans la BD Base de Données .

Fonction N˚ 2

Nom Authentifier un individu sur une photo.

Critère Dire avec un niveau de certitude qu’un individu est bien celui qu’il prétend être.

Fonction N˚ 3

Nom Apprendre un individu.

Critère Un utilisateur devra être capable d’ajouter un individu dans la base de données
du système à tout moment.

Fonction N˚ 4

Nom Rechercher un individu.

Critère Il devra être possible pour un utilisateur de chercher et dans une certaine mesure
de trouver un individu en fournissant son numéro de CNI ou, son nom et son prénom.

2.4 Contraintes d’exécution des différentes fonctions

Contrainte N˚ 1

Nom Avoir un bon taux de bonne reconnaissance.

Critère Taux de bonne reconnaissance supérieure ou égale au seuil de référence qui sera
déterminé ultérieurement.

Contrainte N˚ 2

Nom Avoir un faible taux de fausse reconnaissance.

Critère Taux de fausse reconnaissance inférieure ou égale au seuil de référence qui sera
déterminé ultérieurement.

Rédigé par Wilfried NZIWOUE 95 Telecoms & IT Student Engineer - FGI

 Annexe A : Cahier de charge de FaceRecognition

Contrainte N˚ 3

Nom Posséder des images d’entrées de mêmes caractéristiques.

Critère N˚ 1 Taille de l’image = 112 * 92 pixels
Critère N˚ 2 Format de l’image : JPG

Contrainte N˚ 4

Nom Avoir des appareils de prise de vue de bonne résolutions.

Critère Résolution : 8 MPMégaPixels
Flexibilité Minimum : 5 MP ; Maximum : Le meilleur qui existe sur le marché à l’heure
de l’implémentation du système.

Contrainte N˚ 5

Nom Avoir une base d’apprentissage bien fournie.

Critère Avoir 10 images pour chaque individu de la base de données de reconnaissance.

2.5 Fonctions secondaires

Fonction N˚ 1

Nom Récupérer de la BD et afficher les informations d’un individu

Critère Les informations affichées doivent être précises et affichées de manière très claire.

Fonction N˚ 2

Nom Permettre à un utilisateur de se connecter ou déconnecter à tout moment.

Critère Le système doit être disponible à minimum 95% de son temps de fonctionnement
afin de permettre à un utilisateur de se connecter ou déconnecter au moment voulu.

Fonction N˚ 3

Nom Posséder des fonctions d’administration du système avec différents groupes d’utilisa-
teurs.

Critère Le système doit pouvoir posséder des groupes d’utilisateurs distincts avec leurs
permissions.

Rédigé par Wilfried NZIWOUE 96 Telecoms & IT Student Engineer - FGI

 Annexe A : Cahier de charge de FaceRecognition

3 Solutions proposées

Afin de résoudre les problèmes énoncés plus haut, nous proposons de développer les solu-
tions ci-après :

• Deux applications clientes dont l’une dédiée pour les PC développée en JAVA qui fonc-
tionnera sur les systèmes Windows et Linux systèmes Linux et l’autre pour SmartPhone
développée en Android ;

• une application serveur fonctionnant sous Linux et développée à l’aide du langage JAVA
.

3.1 Application Serveur

L’application serveur devra être développée en JAVA et devra tourner sur un système
Linux. Elle permettra la communication entre le sytème et la Base de donnée et tout autre
système externe. Elle éffectuera également les fonctions de détection de visage et de recherche
de l’individu dans la base et renverra les différents résultats au client ayant initier la démande
.

3.2 Application Client

L’application client sera principalement un moyen d’interaction entre l’utilisateur et le

sytème. De ce fait sa principale fonction serait de prendre la ou les photos d’un individu,
choisir le traitement à y effectuer et les envoyer à l’application serveur.

Rédigé par Wilfried NZIWOUE 97 Telecoms & IT Student Engineer - FGI

Annexe B

Présentation de l’API OpenCV

OpenCV pour Open Computer Vision est une bibliothèque graphique développée sous
licence BSD. BSD pour "Berkeley Software Distribution License" est une licence libre utilisée
pour la distribution de logiciels. Elle permet de réutiliser tout ou une partie du logiciel sans
restriction, qu’il soit intégré dans un logiciel libre ou propriétaire. OpenCV est initialement
développée par Intel et est spécialisée dans le traitement d’images en temps réel. Elle est
développé en C, C++, Java, Android, Python et implémentable sur toutes ces plate-formes.

Pour obtenir OpenCV, il faut se rendre à l’adresse de téléchargement , et choisir la version

correspondante à votre plate-forme de travail.

1 Les fonctionnalités

OpenCV propose diverses fonctionnalités dans les domaines du calculs matriciels, du trai-
tement d’images, traitement vidéos, des algorithmes d’apprentissage, et bien d’autres encore.

1.1 Fonctionnalités obtenus dans le calculs matriciels

A l’aide de cette API, il est possible d’effectuer des opérations de :

• Calcul du déterminant d’une matrice ;

• calcul de la transposée d’une matrice ;

• calcul des valeurs propres ;

98
 Annexe B : Présentation de OpenCV

• etc...

1.2 Fonctionnalités obtenus pour le traitement d’image et vidéo

Parlant du traitement d’image et vidéo, nous pouvons réaliser des opérations de :

• Lecture, écriture et affichage d’une image ;

• lecture, écriture et affichage d’une vidéo (depuis un fichier ou une caméra) ;

• calcul de l’histogramme des niveaux de gris ou d’histogrammes couleurs ;

• détection de visages par la méthode de Viola et Jones ;

• détection de points d’intérêts (yeux par exemples) ;

• etc ...

1.3 Algorithme d’apprentissage

Les algorithmes classiques du domaine de l’apprentissage artificiel disponibles dans OpenCV

sont :

• AdaBoost et divers algorithmes de boosting ;

• Estimateur (statistique) ;

• etc...

Rédigé par Wilfried NZIWOUE 99 Telecoms & IT Student Engineer - FGI

Annexe C

Procédure de prise de photo lors de

l’apprentissage d’un individu

La prise des photos d’un individu lors de la phase apprentissage, étant une étape très im-
portante, nous avons mis à votre disposition ce petit guide vous fournissant la procédure à
suivre. Le respect scrupuleux de cette procédure améliore grandement la précision du système
dans les opérations futures.

Tout d’abord, il est important de préciser que ces photos doivent être au nombre de 10 et
différentes chacune des autres.

Il est intéressant de préciser que les différentes photos devront être prises dans de meilleures
conditions d’éclairage possible. Et, elles devront juste comporter la face de l’individu prises
en vue de face et avec des expressions faciales différentes des unes des autres.

Parlant du l’arrière-plan de la photo, il devra dans la mesure du possible être uniforme, et

de préférence de couleur unique.

100
 Annexe C : Procédure de prise de photo lors de l’apprentissage d’un individu

Photo d’apprentissage N˚1

Figure C-1 – Photo d’apprentissage N˚1

La photo N˚1 est très importante car c’est elle qui sera utilisée comme photo de profil de
l’individu. L’individu devra être dans la meilleure de ces postures.

Photo d’apprentissage N˚2

Figure C-2 – Photo d’apprentissage N˚2

L’individu esquisse un petit sourire.

Photo d’apprentissage N˚3

Figure C-3 – Photo d’apprentissage N˚3

L’individu ferme petitement ses yeux tout en froissant le visage.

Rédigé par Wilfried NZIWOUE 101 Telecoms & IT Student Engineer - FGI
 Annexe C : Procédure de prise de photo lors de l’apprentissage d’un individu

Photo d’apprentissage N˚4

Figure C-4 – Photo d’apprentissage N˚4

L’individu sourit grandement.

Photo d’apprentissage N˚5

Figure C-5 – Photo d’apprentissage N˚5

L’individu regarde à gauche.

Photo d’apprentissage N˚6

Figure C-6 – Photo d’apprentissage N˚6

L’individu regarde à droite.

Rédigé par Wilfried NZIWOUE 102 Telecoms & IT Student Engineer - FGI
 Annexe C : Procédure de prise de photo lors de l’apprentissage d’un individu

Photo d’apprentissage N˚7

Figure C-7 – Photo d’apprentissage N˚7

L’individu ferme les yeux.

Photo d’apprentissage N˚8

Figure C-8 – Photo d’apprentissage N˚8

L’individu ouvre grandement ses yeux.

Photo d’apprentissage N˚9

Figure C-9 – Photo d’apprentissage N˚9

L’individu rit en ouvrant la bouche.

Rédigé par Wilfried NZIWOUE 103 Telecoms & IT Student Engineer - FGI
 Annexe C : Procédure de prise de photo lors de l’apprentissage d’un individu

Photo d’apprentissage N˚10

Figure C-10 – Photo d’apprentissage N˚10

Sur cette photo, l’individu peut porter des lunettes s’il généralement il en met.

Rédigé par Wilfried NZIWOUE 104 Telecoms & IT Student Engineer - FGI
 Annexe D

Code source du service Identification

Ici, nous présentons les codes sources permettant de réaliser l’identification d’un indi-
vidu au niveau du serveur et de l’échange des résultats avec le client.

1 Code au niveau Serveur

1.1 Codes Matlab

2 function n o r m a l i z e d P i c t u r e = NormalizeOnePicture ( p i c t u r e P a t h )
%by W i l f r i e d NZIWOUE : w i l n z i @ y a h o o . f r
4 n o r m a l i z e d P i c t u r e = imread ( p i c t u r e P a t h ) ;

6 normalizedPicture = imresize ( normalizedPicture , [112 9 2 ] ) ;

8 size ( normalizedPicture , 3 ) ;
i f ( s i z e ( n o r m a l i z e d P i c t u r e ,3)==3)
10 normalizedPicture = rgb2gray ( normalizedPicture ) ;
end
12 normalizedPicture = histeq ( normalizedPicture ) ;
normalizedPicture = medfilt2 ( normalizedPicture ) ;
14 imwrite ( normalizedPicture , picturePath ) ;

105
 Annexe D : Code source du service Identification

16 end

Listing D.1 – Fonction permettant de normaliser une image

2 function weight = W e i g h t C a l c u l a t i o n ( p i c t u r e , usedEigenFace , meanImage )

%by W i l f r i e d NZIWOUE : w i l n z i @ y a h o o . f r
4 photo = c o l o n n i s e z _ m a t r i x ( p i c t u r e ) ;
photo_normalise = photo − meanImage ;
6

nbreWeight = s i z e ( usedEigenFace , 2 ) ;
8 we ig ht = s i n g l e ( zeros ( nbreWeight , 1 ) ) ;
for i =1: nbreWeight
10 we ig ht ( i ) = usedEigenFace ( : , i ) ’ ∗ s i n g l e ( photo_normalise ) ;
end
12

end

Listing D.2 – Fonction permettant de calculer les différents poids d’une image

2 function i n d i x = R e c o g n i t i o n ( weight , p o i d s )
matrix = s i n g l e ( zeros ( s i z e ( weight , 2 ) , 1 ) ) ;
4 for i =1: s i z e ( weight , 2 )
% m a t r i x ( i , 1 ) = norm ( p o i d s −w e i g h t ( : , i ) ) ;
6 matrix ( i , 1 ) = norm( mahal ( p oids , weight ( : , i ) ) ) ;
% m a t r i x ( i , 1 ) = mean ( mahal ( p o i d s , w e i g h t ( : , i ) ) ) ;
8 end
[ s o r t e d M a t r i x , i n d i x ] = sort ( matrix , ’ ascend ’ ) ;
10 end

12 end

Rédigé par Wilfried NZIWOUE 106 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

Listing D.3 – Fonction permettant de calculer la distance entre l’image d’entrée et les images
de la base

2 function t a k e n V a l i d P e r s o n = TakenValidPerson ( p e r s o n I d )
%by W i l f r i e d NZIWOUE : w i l n z i @ y a h o o . f r
4 table1 = 0;
for i = 1 : s i z e ( p e r s o n I d , 1 )
6 i f p e r s o n I d ( i , 1 ) > 40
table1 = [ table1 ; personId ( i , 1 ) ] ;
8 end
end
10 table1 = table1 ( 2 : size ( table1 , 1 ) , 1 ) ;
number = 0 ;
12 t a b l e 2 = unique ( t a b l e 1 ) ;
table2 = [ table2 , table2 ] ;
14 for i =1: s i z e ( t a b l e 2 , 1 )
for j =1: s i z e ( t a b l e 1 , 1 )
16 i f t a b l e 1 ( j , 1 ) == t a b l e 2 ( i , 1 )
number = number +1;
18 end
end
20 t a b l e 2 ( i , 2 ) = number ;
number = 0 ;
22 end
table3 = table2 ( : , 2 ) ;
24 t a b l e 3 = sort ( unique ( t a b l e 3 ) , ’ descend ’ ) ;
offset = 1;
26 t a k e n V a l i d P e r s o n = s i n g l e ( zeros ( s i z e ( t a b l e 2 , 1 ) , 1 ) ) ;
for i =1: s i z e ( t a b l e 3 , 1 )

Rédigé par Wilfried NZIWOUE 107 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

28 for j =1: s i z e ( t a b l e 2 , 1 )
i f t a b l e 3 ( i , 1 ) == t a b l e 2 ( j , 2 )
30 takenValidPerson ( o f f s e t , 1 ) = table2 ( j , 1 ) ;
offset = offset + 1;
32 end
end
34 end
end

Listing D.4 – Fonction permettant de déterminer les personnes

2 function p e r s o n I d = P e r s o n D e t e r m i n a t i o n ( v e c t o r I d )

4 p e r s o n I d = s i n g l e ( zeros ( s i z e ( v e c t o r I d , 1 ) , 1 ) ) ;
for i =1: s i z e ( v e c t o r I d , 1 )
6 id = vectorId ( i , 1 ) ;
r e s t = mod( id , 1 0 ) ;
8

i f ( r e s t ==0)
10 personId ( i , 1 ) = id /10;
else
12 p e r s o n I d ( i , 1 ) = ( ( id−r e s t ) / 1 0 ) + 1 ;
end
14

end
16 personId = personId ( 1 : 1 0 0 , 1 ) ;
p e r s o n I d = TakenValidPerson ( p e r s o n I d ) ;
18

20 end

Rédigé par Wilfried NZIWOUE 108 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

Listing D.5 – Fonction permettant de déterminer les individus les plus proches de l’individu
d’entrée

2 function p e r s o n I d = I d e n t i f i c a t i o n ( p i c t u r e P a t h )
filename = ’ VariableFile \ identificationVariable ’ ;
4 S = load ( f i l e n a m e ) ;
usedEigenFace = S . usedEigenFace ;
6 meanImage = S . meanImage ;
we ig ht = S . weight ;
8

picture = NormalizeOnePicture ( p i c t u r e P a t h ) ;
10 p o i d s = W e i g h t C a l c u l a t i o n ( p i c t u r e , usedEigenFace , meanImage ) ;
i n d i x = R e c o g n i t i o n ( weight , p o i d s ) ;
12 f i n a l =’ ; ’ ;
personId = PersonDetermination ( indix ) ;
14 for i =1: s i z e ( p e r s o n I d , 1 )
f i n a l = s t r c a t ( f i n a l , num2str ( p e r s o n I d ( i , 1 ) ) , ’ ; ’ ) ;
16 end
personId = f i n a l
18 end

Listing D.6 – Fonction réalisant l’identification

Remarque : le fichier "identificationVariable.mat" est la résultante de l’apprentissage

des différents individus.

1.2 Codes JAVA

2 /∗ ∗

Rédigé par Wilfried NZIWOUE 109 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

∗ <b> C l a s s e de lancement du s e r v i c e I d e n t i f i c a t i o n </b>

4 ∗ <i >C o p y r i g h t ( c ) 2015 , A l l r i g h t s r e s e r v e d .</ i >
∗ @author W i l f r i e d NZIWOUE
6 ∗ @ version 1.0
∗
8 ∗/
package o rg . w i l n z i . c l i e n t r e q u e s t ;
10

12 import o r g . w i l n z i . development . ∗ ;
import o r g . w i l n z i . s h a r e d c l a s s . ∗ ;
14 import o r g . w i l n z i . development . mvc . ∗ ;
import o r g . w i l n z i . i n f o r m a t i o n . ∗ ;
16 import o r g . w i l n z i . o b j e c t . ∗ ;
import j a v a . i o . ∗ ;
18 import j a v a . u t i l . ∗ ;
import j a v a . ne t . ∗ ;
20

public c l a s s I d e n t i f i c a t i o n {
22

Model model ;
24 int p o r t ;
Controller controller ;
26 ServerSocket server ;
public I d e n t i f i c a t i o n ( int port , Model model , C o n t r o l l e r c o n t r o l l e r ) {
28 this . port = port ;
t h i s . model = model ;
30 this . c o n t r o l l e r = c o n t r o l l e r ;
try {
32 s e r v e r = new S e r v e r S o c k e t ( p o r t ) ;

Rédigé par Wilfried NZIWOUE 110 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

34 while ( true ) {
Socket s o c k e t I d e n t i f i c a t i o n = server . accept ( ) ;
36 Thread th = new Thread (new I d e n t i c a t i o n P r o c e s s ( s o c k e t I d e n t i f i c a t i o n ) ) ;
th . s t a r t ( ) ;
38 }
} catch ( E xc ept io n e ) {
40 e . printStackTrace ( ) ;
}
42

44 }

46 private c l a s s I d e n t i c a t i o n P r o c e s s implements Runnable {

48

private S o c k e t s o c k e t ;
50

private ObjectOutputStream oos ;

52 private ObjectInputStream o i s ;
private FileOutputStream f o s = null ;
54 private F i l e I n p u t S t r e a m f i s = null ;
private byte [ ] data = null ;
56 private F i l e i n d i v i d u P i c t u r e = null ;
private int i =0;
58 private S t r i n g pseudo ="" ;
public I d e n t i c a t i o n P r o c e s s ( f i n a l S o c k e t s o c k e t ) {
60 try {
this . socket = socket ;
62 oos = new ObjectOutputStream ( s o c k e t . getOutputStream ( ) ) ;

Rédigé par Wilfried NZIWOUE 111 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

o i s = new ObjectInputStream ( s o c k e t . ge tI np ut St re am ( ) ) ;
64 } catch ( E xc ept io n e ) {
e . printStackTrace ( ) ;
66 }
}
68

public void run ( ) {

70 try {

72 // Début de l a phase d ’ a u t h e n t i f i c a t i o n

74 S t r i n g c h a l l e n g e M e s s a g e = newChallengeMessage ( ) ;
oos . w r i t e O b j e c t ( sendMessage ( c h a l l e n g e M e s s a g e ) ) ;
76 String clientHashValue = receiveMessage (( String ) o i s . readObject ( ) ) ;
pseudo = r e c e i v e M e s s a g e ( ( S t r i n g ) o i s . r e a d O b j e c t ( ) ) ;
78 S t r i n g hashValue = getHashValue ( pseudo , c h a l l e n g e M e s s a g e ) ;
boolean c l i e n t A u t h e n t i c a t e d = hashValue . e q u a l s ( c l i e n t H a s h V a l u e ) ;
80 S t r i n g l o gM ess age = s o c k e t . t o S t r i n g ()+ "␣ i s ␣ a u t h e n t i c a t e d ␣on␣ I d e n t i f i c a t i o n
␣ p o r t ␣ ?? ␣\ t "+c l i e n t A u t h e n t i c a t e d ;
82 model . w r i t e E n t r y L o g F i l e ( l ogM es sag e ) ;
oos . w r i t e O b j e c t ( sendMessage ( ""+c l i e n t A u t h e n t i c a t e d ) ) ;
84

i f ( c l i e n t A u t h e n t i c a t e d == true ) {
86

S t r i n g p a r e n t F o l d e r P a t h = " F i l e / TemporyFile /"+pseudo+

88 new D a t e S t r i n g ( ) . g e t D a t e S t r i n g ( ) ;

90 F i l e p a r e n t F o l d e r = new F i l e ( p a r e n t F o l d e r P a t h ) ;
p a r e n t F o l d e r . mkdirs ( ) ;
92

Rédigé par Wilfried NZIWOUE 112 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

int s i z e = I n t e g e r . p a r s e I n t ( ( S t r i n g ) o i s . r e a d O b j e c t ( ) ) ;
94 byte [ ] data = ( byte [ ] ) o i s . r e a d O b j e c t ( ) ;
f o s = new FileOutputStream ( p a r e n t F o l d e r . g e t A b s o l u t e P a t h ()+
96 "/ r e c e i v e P i c t u r e . j p g " ) ;
f o s . w r i t e ( data , 0 , data . l e n g t h ) ;
98 try {
fos . close ();
100 } catch ( E xc ept io n e ) {
e . printStackTrace ( ) ;
102 }
boolean a u t o m a t i c F a c e D e t e c t i o n = Boolean . valueOf ( r e c e i v e M e s s a g e ( ( S t r i n g )
104 o i s . r e a d O b j e c t ( ) ) ) . b oo l e a n Va l u e ( ) ;

106 F i l e r e c e i v e P i c t u r e = new F i l e ( p a r e n t F o l d e r . g e t A b s o l u t e P a t h ()+

"/ r e c e i v e P i c t u r e . j p g " ) ;
108

A r r a y L i s t <I n d i v i d u > d e t e c t e d I n d i v i d u = model . f a c e R e c o g n i t i o n (

110 receivePicture , parentFolder , automaticFaceDetection ) ;
int d e t e c t e d I n d i v i d u S i z e = d e t e c t e d I n d i v i d u . s i z e ( ) ;
112 oos . w r i t e O b j e c t ( sendMessage ( ""+d e t e c t e d I n d i v i d u S i z e ) ) ;

114 i f ( d e t e c t e d I n d i v i d u S i z e > 0) {
model . w r i t e E n t r y L o g F i l e ( " User ␣ : ␣"+pseudo+"␣ S t a t u t ␣ o f ␣ i d e n t i f i c a t i o n ␣ : ␣ t r u e
116 ␣\ t ␣Number␣ o f ␣ f i n d e d ␣ p e r s o n ␣ : "+d e t e c t e d I n d i v i d u S i z e ) ;
for ( I n d i v i d u i n d : d e t e c t e d I n d i v i d u ) {
118

oos . w r i t e O b j e c t ( sendMessage ( i n d . g e t D e s c r i p t i o n ( ) ) ) ;
120 i n d i v i d u P i c t u r e = new F i l e ( in d . g e t I n d i v i d u P i c t u r e P a t h ( ) ) ;
data = new byte [ ( int ) ( i n d i v i d u P i c t u r e . l e n g t h ( ) ) ] ;
122 f i s = new F i l e I n p u t S t r e a m ( i n d i v i d u P i c t u r e ) ;

Rédigé par Wilfried NZIWOUE 113 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

f i s . r e a d ( data , 0 , data . l e n g t h ) ;
124 oos . w r i t e O b j e c t ( data ) ;
try {
126 f i s . close ();
} catch ( E xc ept io n e ) {
128 e . printStackTrace ( ) ;
}
130 }

132 } else {
model . w r i t e E n t r y L o g F i l e ( " User ␣ : ␣"+pseudo+"␣ S t a t u t ␣ o f ␣ i d e n t i f i c a t i o n ␣ :
134 \t␣ false " );
}
136

138

}
140 } catch ( E xc ept io n e ) {
e . printStackTrace ( ) ;
142 } finally {
try {
144 i f ( f o s != null ) f o s . c l o s e ( ) ;
i f ( f i s != null ) f i s . c l o s e ( ) ;
146 i f ( oos != null ) oos . c l o s e ( ) ;
i f ( o i s != null ) o i s . c l o s e ( ) ;
148 i f ( s o c k e t != null ) s o c k e t . c l o s e ( ) ;

150 } catch ( IOException e ) {

e . printStackTrace ( ) ;
152 }

Rédigé par Wilfried NZIWOUE 114 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

}
154 }
}
156

158 private S t r i n g sendMessage ( f i n a l S t r i n g s t r ) {

return S t r i n g N o r m a l i z a t i o n . sendMessage ( s t r ) ;
160 }

162 private S t r i n g r e c e i v e M e s s a g e ( f i n a l S t r i n g s t r ) {
return S t r i n g N o r m a l i z a t i o n . r e c e i v e M e s s a g e ( s t r ) ;
164

}
166

private S t r i n g newChallengeMessage ( ) {
168 double number = Math . random ( ) ;
S t r i n g message = "mes"+number+" s a g e " ;
170 return message ;
}
172

private S t r i n g getHashValue ( S t r i n g pseudo , S t r i n g c h a l l e n g e M e s s a g e ) {

174 return S t r i n g N o r m a l i z a t i o n . hash ( pseudo+I n f o r m a t i o n .KEY+c h a l l e n g e M e s s a g e ) ;
}
176

178 }

Listing D.7 – Code du service Identification au niveau du serveur

Rédigé par Wilfried NZIWOUE 115 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

2 Code au niveau des applications clientes

2.1 Application PC

2 private boolean i d e n t i f i c a t i o n E x i t ;
public A r r a y L i s t <I n d i v i d u > i d e n t i f i c a t i o n ( F i l e i d e n t i f i e d P i c t u r e ,
4 S t r i n g pseudo , boolean a u t o m a t i c F a c e D e t e c t i o n ) {

6 i d e n t i f i c a t i o n E x i t = true ;
S o c k e t s o c k e t = null ;
8 I n e t A d d r e s s i n e t A d d r e s s = null ;
ObjectOutputStream oos = null ;
10 ObjectInputStream o i s = null ;
FileOutputStream f o s = null ;
12 A r r a y L i s t <I n d i v i d u > r e c o g n i z e d I n d i v i d u = null ;
try {
14 i n e t A d d r e s s = I n e t A d d r e s s . getByName ( I n f o r m a t i o n .SERVER_ADDRESS) ;
s o c k e t = new S o c k e t ( ) ;
16 S o c k e t A d d r e s s s o c k e t A d d r e s s = new I n e t S o c k e t A d d r e s s ( i n e t A d d r e s s ,
I n f o r m a t i o n . IDENTIFICATION_PORT ) ;
18 socket . connect ( socketAddress , 10000);
o i s = new ObjectInputStream ( s o c k e t . ge tI np ut St re am ( ) ) ;
20 oos = new ObjectOutputStream ( s o c k e t . getOutputStream ( ) ) ;

22 // Début phase d ’ a u t h e n t i f i c a t i o n ! ! !
String challengeMessage = receiveMessage (( String ) o i s . readObject ( ) ) ;
24 oos . w r i t e O b j e c t ( sendMessage ( getHashValue ( pseudo , c h a l l e n g e M e s s a g e ) ) ) ;
oos . w r i t e O b j e c t ( sendMessage ( pseudo ) ) ;
26 boolean i s A u t h e n t i c a t e d = Boolean . valueOf ( r e c e i v e M e s s a g e ( ( S t r i n g )
o i s . r e a d O b j e c t ( ) ) ) . b oo l e a n Va l u e ( ) ;

Rédigé par Wilfried NZIWOUE 116 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

28

30 i f ( i s A u t h e n t i c a t e d == true ) {
int s i z e = ( int ) i d e n t i f i e d P i c t u r e . l e n g t h ( ) ;
32 byte [ ] data = new byte [ s i z e ] ;
oos . w r i t e O b j e c t ( "" +s i z e ) ;
34 F i l e I n p u t S t r e a m f i s = new F i l e I n p u t S t r e a m ( i d e n t i f i e d P i c t u r e ) ;
f i s . r e a d ( data , 0 , data . l e n g t h ) ;
36 oos . w r i t e O b j e c t ( data ) ;
f i s . close ();
38 oos . w r i t e O b j e c t ( sendMessage ( "" + a u t o m a t i c F a c e D e t e c t i o n ) ) ;
s i z e = Integer . parseInt ( receiveMessage ( ( String ) o i s . readObject ( ) ) ) ;
40 r e c o g n i z e d I n d i v i d u = new A r r a y L i s t <I n d i v i d u > ( ) ;

42 i f ( s i z e > 0) {

44 I n d i v i d u p a s s I n d i v i d u = null ;
S m a l l I n d i v i d u s m a l l P a s s I n d i v i d u = null ;
46 F i l e i n d i v i d u P i c t u r e F i l e = null ;
S t r i n g message = "" ;
48 for ( int i =0 ; i <s i z e ; i ++) {
message = r e c e i v e M e s s a g e ( ( S t r i n g ) o i s . r e a d O b j e c t ( ) ) ;
50 p a s s I n d i v i d u = I n d i v i d u . c r e a t e I n d i v i d u ( message ) ;
data = null ;
52 data = ( byte [ ] ) o i s . r e a d O b j e c t ( ) ;
i n d i v i d u P i c t u r e F i l e = new F i l e ( FolderManager .USER_FILE_PATH+"/"+
54 p a s s I n d i v i d u . getNumCNIIndividu ()+ " . j p g " ) ;
f o s = new FileOutputStream ( i n d i v i d u P i c t u r e F i l e ) ;
56 f o s . w r i t e ( data , 0 , data . l e n g t h ) ;
p a s s I n d i v i d u . s e t I n d i v i d u P i c t u r e P a t h ( FolderManager .USER_FILE_PATH+"/"+

Rédigé par Wilfried NZIWOUE 117 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

58 p a s s I n d i v i d u . getNumCNIIndividu ()+ " . j p g " ) ;

r e c o g n i z e d I n d i v i d u . add ( p a s s I n d i v i d u ) ;
60 }
i d e n t i f i c a t i o n E x i t = true ;
62 model . goodMessage ( " I d e n t i f i c a t i o n ␣ t e r m i n i n é e ␣ ! !
V e u i l l e z ␣ c o n s u l t e r ␣ l a ␣ l i s t e ␣ des ␣ p e r s o n n e s ␣ i d e n t i f i é e s ! ! ! " ) ;
64 } else {
i d e n t i f i c a t i o n E x i t = true ;
66 model . e r r o r M e s s a g e ( " Pas ␣ de ␣ c o r r e s p o n d a n c e ␣ t r o u v é ! ! ␣\n
␣ V e u i l l e z ␣ r é e s s a y e r ␣ p l u s ␣ t a r d ␣ avec ␣ une ␣ photo ␣ de ␣ peut−ê t r e
68 ␣␣ m e i l l e u r e ␣ q u a l i t é ! ! ! " ) ;
}
70

} else {
72 identificationExit = false ;
model . s e r v e r A u t h e n t i c a t i o n E r r o r ( ) ;
74 }

76 } catch ( ConnectException e ) {
identificationExit = false ;
78 model . s e r v e r N o t C o n n e c t e d ( ) ;
} catch ( SocketTimeoutException e ) {
80 identificationExit = false ;
model . s e r v e r N o t C o n n e c t e d ( ) ;
82 } catch ( UnknownHostException e ) {
identificationExit = false ;
84 model . s e r v e r N o t C o n n e c t e d ( ) ;
} catch ( IOException e ) {
86 identificationExit = false ;
model . s e r v e r N o t C o n n e c t e d ( ) ;

Rédigé par Wilfried NZIWOUE 118 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

88 } catch ( ClassNotFoundException e ) {
identificationExit = false ;
90 model . s e r v e r N o t C o n n e c t e d ( ) ;
} finally {
92 try {
i f ( oos != null ) oos . c l o s e ( ) ;
94 i f ( f o s != null ) f o s . c l o s e ( ) ;
i f ( o i s != null ) o i s . c l o s e ( ) ;
96 i f ( s o c k e t != null ) s o c k e t . c l o s e ( ) ;
} catch ( IOException e ) {
98 identificationExit = false ;
e . printStackTrace ( ) ;
100 }
}
102 return r e c o g n i z e d I n d i v i d u ;
}

Listing D.8 – Code du service Identification au niveau du client PC

2.2 Application ANDROID

2 public I d e n t i f i c a t i o n R e q u e s t ( f i n a l I d e n t i f i c a t i o n H a n d l e r
identificationHandler ,
4 f i n a l F i l e i d e n t i f i e d P i c t u r e , f i n a l S t r i n g pseudo ,
f i n a l FolderManager folderManager ,
6 f i n a l boolean a u t o m a t i c F a c e D e t e c t i o n ) {

8 new Thread (new Runnable ( ) {

@Override
10 public void run ( ) {

Rédigé par Wilfried NZIWOUE 119 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

S o c k e t s o c k e t = null ;
12 I n e t A d d r e s s i n e t A d d r e s s = null ;
ObjectOutputStream oos = null ;
14 ObjectInputStream o i s = null ;
FileOutputStream f o s = null ;
16 try {
i n e t A d d r e s s = I n e t A d d r e s s . getByName ( I n f o r m a t i o n .SERVER_ADDRESS) ;
18 s o c k e t = new S o c k e t ( ) ;
S o c k e t A d d r e s s s o c k e t A d d r e s s = new I n e t S o c k e t A d d r e s s (
20 i n e t A d d r e s s , I n f o r m a t i o n . IDENTIFICATION_PORT ) ;
socket . connect ( socketAddress , 10000);
22 o i s = new ObjectInputStream ( s o c k e t . ge tI np ut St re am ( ) ) ;
oos = new ObjectOutputStream ( s o c k e t . getOutputStream ( ) ) ;
24

// Début phase d ’ a u t h e n t i f i c a t i o n ! ! !
26 String challengeMessage = receiveMessage (
( String ) o i s . readObject ( ) ) ;
28 oos . w r i t e O b j e c t ( sendMessage (
getHashValue ( pseudo , c h a l l e n g e M e s s a g e ) ) ) ;
30 oos . w r i t e O b j e c t ( sendMessage ( pseudo ) ) ;
boolean i s A u t h e n t i c a t e d = Boolean . valueOf (
32 r e c e i v e M e s s a g e ( ( S t r i n g ) o i s . r e a d O b j e c t ( ) ) ) . b oo l e a n V al u e ( ) ;

34

i f ( i s A u t h e n t i c a t e d == true ) {
36 int s i z e = ( int ) i d e n t i f i e d P i c t u r e . l e n g t h ( ) ;
byte [ ] data = new byte [ s i z e ] ;
38 oos . w r i t e O b j e c t ( "" +s i z e ) ;
F i l e I n p u t S t r e a m f i s = new F i l e I n p u t S t r e a m ( i d e n t i f i e d P i c t u r e ) ;
40 f i s . r e a d ( data , 0 , data . l e n g t h ) ;

Rédigé par Wilfried NZIWOUE 120 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

oos . w r i t e O b j e c t ( data ) ;
42 f i s . close ();
oos . w r i t e O b j e c t ( sendMessage ( "" + a u t o m a t i c F a c e D e t e c t i o n ) ) ;
44 s i z e = Integer . parseInt ( receiveMessage ( ( String ) o i s . readObject ( ) ) ) ;
Message msg = Message . o b t a i n ( ) ;
46 msg . a r g 1 = i d e n t i f i c a t i o n H a n d l e r . IDENTIFICATION_SUCCEED ;
msg . a r g 2 = s i z e ;
48 i d e n t i f i c a t i o n H a n d l e r . sendMessage ( msg ) ;
I n d i v i d u A r r a y L i s t r e c o g n i z e d I n d i v i d u = new I n d i v i d u A r r a y L i s t ( ) ;
50

i f ( s i z e > 0) {
52

I n d i v i d u p a s s I n d i v i d u = null ;
54 S m a l l I n d i v i d u s m a l l P a s s I n d i v i d u = null ;
F i l e i n d i v i d u P i c t u r e F i l e = null ;
56 S t r i n g message = "" ;
for ( int i =0 ; i <s i z e ; i ++) {
58 message = r e c e i v e M e s s a g e ( ( S t r i n g ) o i s . r e a d O b j e c t ( ) ) ;
s m a l l P a s s I n d i v i d u = I n d i v i d u . c r e a t e I n d i v i d u ( message ) ;
60 data = null ;
data = ( byte [ ] ) o i s . r e a d O b j e c t ( ) ;
62 i n d i v i d u P i c t u r e F i l e = new F i l e (
f o l d e r M a n a g e r . g e t i n d i v i d u F o l d e r ( ) . g e t A b s o l u t e P a t h ()+
64 "/"+s m a l l P a s s I n d i v i d u . numCNIIndividu+" . j p g " ) ;
f o s = new FileOutputStream ( i n d i v i d u P i c t u r e F i l e ) ;
66 f o s . w r i t e ( data , 0 , data . l e n g t h ) ;
p a s s I n d i v i d u = new I n d i v i d u ( s m a l l P a s s I n d i v i d u ,
68 i n d i v i d u P i c t u r e F i l e . getAbsolutePath ( ) ) ;
r e c o g n i z e d I n d i v i d u . add ( p a s s I n d i v i d u ) ;
70 }

Rédigé par Wilfried NZIWOUE 121 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

Log . e ( " Test ␣ de ␣ message " , r e c o g n i z e d I n d i v i d u .

72 g e t ( 0 ) . getNumCNIIndividu ( ) ) ;
msg = Message . o b t a i n ( ) ;
74 msg . a r g 1 = i d e n t i f i c a t i o n H a n d l e r
. IDENTIFICATION_FINISH ;
76 msg . o b j = r e c o g n i z e d I n d i v i d u ;
i d e n t i f i c a t i o n H a n d l e r . sendMessage ( msg ) ;
78 } else {
msg = Message . o b t a i n ( ) ;
80 msg . a r g 1 = i d e n t i f i c a t i o n H a n d l e r .UNKNOW_INDIVIDU;
i d e n t i f i c a t i o n H a n d l e r . sendMessage ( msg ) ;
82 }

84 } else {
Message msg = Message . o b t a i n ( ) ;
86 msg . a r g 1 = i d e n t i f i c a t i o n H a n d l e r .AUTHENTICATION_ERROR;
i d e n t i f i c a t i o n H a n d l e r . sendMessage ( msg ) ;
88 }

90 } catch ( SocketTimeoutException e ) {
Message msg = Message . o b t a i n ( ) ;
92 msg . a r g 1 = I d e n t i f i c a t i o n H a n d l e r .
SERVER_NOT_PRESENT_ERROR;
94 i d e n t i f i c a t i o n H a n d l e r . sendMessage ( msg ) ;
} catch ( UnknownHostException e ) {
96 e . printStackTrace ( ) ;
} catch ( IOException e ) {
98 e . printStackTrace ( ) ;
} catch ( ClassNotFoundException e ) {
100 e . printStackTrace ( ) ;

Rédigé par Wilfried NZIWOUE 122 Telecoms & IT Student Engineer - FGI
 Annexe D : Code source du service Identification

} finally {
102 try {

104 i f ( oos != null ) oos . c l o s e ( ) ;

i f ( f o s != null ) f o s . c l o s e ( ) ;
106 i f ( o i s != null ) o i s . c l o s e ( ) ;
i f ( s o c k e t != null ) s o c k e t . c l o s e ( ) ;
108 } catch ( IOException e ) {
e . printStackTrace ( ) ;
110 }
}
112

}
114 }). start ();
}

Listing D.9 – Code du service Identification au niveau du mobile (Android)

Rédigé par Wilfried NZIWOUE 123 Telecoms & IT Student Engineer - FGI
Annexe E

Les principaux diagrammes de

conceptions

Dans ce chapitre de l’annexe, nous présentons les principaux diagrammes de conception.

124
 Annexe E : Diagramme d’interaction client-serveur

Figure E-1 – Diagramme de cas d’utilisation de l’application serveur

Rédigé par Wilfried NZIWOUE 125 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

1 Les diagrammes d’interaction client - serveur

Rédigé par Wilfried NZIWOUE 126 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

Figure E-2 – Diagramme d’interaction entre le client et le serveur lors de la connexion du

client
Rédigé par Wilfried NZIWOUE 127 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

Figure E-3 – Diagramme d’interaction entre le client et le serveur lors de l’apprentissage

d’un individu
Rédigé par Wilfried NZIWOUE 128 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

Figure E-4 – Diagramme d’interaction entre le client et le serveur lors de l’identification

d’un individu
Rédigé par Wilfried NZIWOUE 129 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

Figure E-5 – Diagramme d’interaction entre le client et le serveur lors de l’authentification

d’un individu
Rédigé par Wilfried NZIWOUE 130 Telecoms & IT Student Engineer - FGI
 Annexe E : Diagramme d’interaction client-serveur

Figure E-6 – Diagramme d’interaction entre le client et le serveur lors de la recherche d’un
individu
Rédigé par Wilfried NZIWOUE 131 Telecoms & IT Student Engineer - FGI