Rapport TL gestes SIR .pdf



Nom original: Rapport_TL_gestes_SIR.pdf

Ce document au format PDF 1.5 a été généré par LaTeX with hyperref package / pdfTeX-1.40.16, et a été envoyé sur fichier-pdf.fr le 06/04/2016 à 14:47, depuis l'adresse IP 194.51.x.x. La présente page de téléchargement du fichier a été vue 350 fois.
Taille du document: 299 Ko (10 pages).
Confidentialité: fichier public


Aperçu du document


Rapport de TL
Commande de robot par gestes

Par :
Catherine Tran
Mouna Khammar

Encadrant :
M. Jean-luc Collette

2 Février 2016

Table des matières
1 Introduction

3

2 Programme d’acquisition de geste

4

2.1

2.2

Segmentation de la main - Traitement d’images . . . . . . . . . . . . . . . . . . .

4

2.1.1

Prétraitement - Filtrage Gaussien . . . . . . . . . . . . . . . . . . . . . . .

4

2.1.2

Identification de la main - Seuillage de composantes (R,G,B) . . . . . . .

4

2.1.3

Identification de la main - Détection du contour de la main . . . . . . . .

5

Génération d’attributs à partir des gestes - Descripteurs de Fourier

. . . . . . .

3 Apprentissage et reconnaissance des gestes

5

7

3.1

Apprentissage non-supervisé : k-moyennes . . . . . . . . . . . . . . . . . . . . . .

7

3.2

Apprentissage supervisé : k-plus-proches-voisins . . . . . . . . . . . . . . . . . . .

8

4 Conclusion

9

1

Table des figures
1

Robot Koala . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3

2

GaussianBlu(0.5, 0.5)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

3

GaussianBlu(1.5, 1.5)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

4

GaussianBlu(3, 3)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

5

Les prototypes générés par k-moyennes

. . . . . . . . . . . . . . . . . . . . . . .

7

6

Fonctionnement de K-n-n pour un geste : Avance . . . . . . . . . . . . . . . . . .

8

2

1

Introduction

Le sujet de ces Travaux de Laboratoire est la "Commande de robot Koala par gestes". Le Koala
est un robot disposant d’une caméra et de roues motrices. L’objectif est d’écrire un programme
permettant au robot de reconnaître les gestes qui lui sont soumis et d’en déduire un ordre à
exécuter.
Le robot devra reconnaître quatre gestes qui correspondront aux ordres "avance", "stop", "gauche"
et droite.
Ce TL se divise en 4 parties : la détection de la main, la génération d’attributs appropriés, la
déduction du geste à partir de ces attributs, et l’envoi de l’ordre correspondant au robot.
Nous n’avons malheureusement pas eu le temps d’aborder la dernière partie concernant le contrôle
du robot avec ROS.
Ce TL mobilise essentiellement, le lanuage C++, la bibliothèque OpenCV et l’utilisation de
Matlab.
Ce TL nous a permis de mettre en pratique les divers notions étudiées dans le cadre de la majeure
SIR dans le cadre d’un projet long. Les différents domaines parcourus sont le traitement d’images,
machine learning et programmation C++.

Figure 1 – Robot Koala

3

2
2.1
2.1.1

Programme d’acquisition de geste
Segmentation de la main - Traitement d’images
Prétraitement - Filtrage Gaussien

FONCTION : detection.cpp
En premier lieu, il faut acquérir le geste de l’utilisateur et plus précisément, on acquiérera le
contour de sa main, au moyen d’une caméra.
Nous avons séparés cette partie traitement des images en deux étapes. Nous avons remarqué
que la détection de contours (avec la méthode findContour d’OpenCV) est très sensible aux
conditions d’éclairage, à la sensibilité de la caméra, aux reflets, i.e à tout type de bruit. En effet,
la méthode findContour enregistre souvent les petits contours générés par les bruits et donne de
nombreux contours chaotiques.
Afin de limiter l’impact de ce bruit sur notre mesure du contour de la main, nous ajoutons une
étape de prétraitement de l’image. Ce prétraitement se fait à l’aide d’un filtre gaussien (fonction
GaussainBlur d’OpenCv). A l’issue de nos tests dans la smartroom, nous choisissons de prendre
les coefficients (σx , σy ) = (1, 5; 1, 5)

Figure 2 – GaussianBlu(0.5, Figure 3 – GaussianBlu(1.5,
Figure 4 – GaussianBlu(3, 3)
0.5)
1.5)
Test de GaussianBlur avec plusiseurs paramètres

2.1.2

Identification de la main - Seuillage de composantes (R,G,B)

FONCTION : detection.cpp
Pour la détection de la main, on adopte la méthode de détection de couleur pour extraire le
contour de la main. C’est la méthode la plus populaire et c’est aussi celle proposée par l’énoncé.
Cette méthode est simple mais dépends de la couleur de la peau, des conditions d’éclairage et de
l’environnement. Il existe d’autres méthodes indépendantes de la détection de couleur telle que
la détection de convexité, également implémentée sur OpenCV.
On sélectionne les points caractérisés par leur composante couleur (R,G,B). Pour obtenir une représentation RGB de l’image on enregistre l’acquisition de la caméra sous le format OpenCV Mat
8UC 3(8niveauxdecouleurscods, chacuncodssur28 bits). L’image est représentée sous la forme
d’une matrice de pixels, chaque pixels contenant 3 niveaux de couleur (R, G et B, dont les ni4

veaux varient entre 0 et 255) . La matrice est donc de taille W*L*3 avec W et L, les largeurs et
longueurs en pixels de l’image.
De plus, on suppose que la couleur de la peau est caractérisée par une dominante (R,G,B) rouge.
Dans le programme, on introduit un seuil. Si la dominance du rouge est supérieure ou égale à ce
seuil, nous considérerons que le pixels concerné correspond à un point de la peau. Après plusieurs
tests sur nos deux mains, on retient un seuil égal à 20. Les pixels identifiés comme correspondant
à de la peau seront convertis en blanc (0,0,0). Le reste sera convertit en noir (255,255,255).
A partir de cette représentation (R,G,B) et des caractéristiques de la peau, on effectue le seuillage
suivant :
(R,G,B) = (255,255,255) si :
- max(R, G, B) = R
- max(R, G, B) − min(R, G, B) >= seuil
(R,G,B) = (0,0,0) sinon.
Ce seuillage permet de détecter la main sous certaines conditions : - il faut que la luminosité et
que l’environnement correspondent à celle de la salle de TL (fond neutre). - il faut que le visage
soit écarté de la main (sinon le contour est celui de la main et celui du visage se superposent). - il
faut que la main soit plus proche de la caméra que le visage (car on détecte le plus long contour).

2.1.3

Identification de la main - Détection du contour de la main

Après avoir supprimé de l’image les composantes ne correspondant pas à de la peau, nous devons
récupérer le contour de la main. Ceci est fait avec la méthode findContour d’OpenCV. Cette
méthode extrait tous les contours de l’image sous la forme d’un vecteur contenant vecteurs de
contours ( semblable à une matrice dont chaque colonne représente un contour ). On extrait
ensuite le contour le plus long (simple calcul de taille).
Ce programme nous a posé quelques problèmes. Le programme s’interrompt si aucun contour
n’est détecté. Afin d’éviter que le programme ne s’interrompt dès qu’aucun contour n’est détecté
(par exemple quand on tourne la caméra dans une zone neutre), on ajoute à la fonction détection
un booléen existe_contour qui indique si un contour est détecté et évite l’arrêt du programme
lorsqu’aucun contour n’est détecté.

2.2

Génération d’attributs à partir des gestes - Descripteurs de Fourier

FONCTION : coeff_fourier.cpp et coeff_fourier_inverse.cpp
Les descripteurs de Fourier d’un contour permettent de créer un vecteur d’attribut invariant par
translation, rotation et changement d’échelle (homothétie) de ce contour. Ces propriétés sont
cruciales puisque demander à l’utilisateur à positionner sa main au centre de la figure, à une
distance et un angle bien précis par rapport à la caméra, serait trop contraignant.
La classification sera réalisé à partir de ces coefficients.
5

Principe des descripteurs de Fourier Soit un contour, représenté par un vecteur de points
(xm , ym ) de taille N.
La représentation complexe associée est la suite zm = x + iy.
La décomposition de Fourier associée à cette suite est :
ak =

(
1 X
−2πjkm
N − 1)(zm − z¯) exp(
)
N m=0
N

(1)

z¯ correspond à la valeur moyenne de la suite complexe. On garde les coefficients les plus significatifs. Dans nos mesures, celles-ci coïncident avec les coefficients de faible indice, nous prenons
|k| = 10
Il convient de réaliser des opérations de normalisation sur nos attributs afin de leur conférer les
propriétés désirées.
Normalisation vis-à-vis du sens de parcours Si |a1 | < |a−2 | on permute les coefficients, i.e
ak ⇐⇒ a−k .
Normalisation vis-à-vis de l’échelle Après la première permutation, le plus grand coefficient
est a1 . On normalise les coefficients en amplitude en divisant tous les coefficients par |a1 .
Normalisation vis-à-vis de la rotation Pour rendre les coefficients invariants vis-à-vis de la
rotation, on effectue les transformations suivantes :
φ = Arg{a−1 × a1 }/2
ak = ak × exp(−iφ)
θ = Arg{a1 }
ak = ak × exp(−iθk)
Les coefficients récupérés sont ainsi indépendants de l’orientation du contour.
Nous nous sommes basés sur le code Matlab fourni par l’énoncé. Nous avons d’abord testé ce
code sur nos contours et nous avons choisis de travailler avec |k| = 10 donc 21 coefficients, ce qui
suffisait largement à ce que la reconstruction des contours soient identifiable à l’oeil nu.
L’approximation du contour reconstruit est donnée par la formule suivante :

zˆm = z +

kX
max


ak exp

k=kmin

2πjkm
N


(2)

Le code Matlab nous a permis de déterminer les coefficients adoptés. Nous avons traduit ce code
Matlab en c++ pour extraire les coefficients des contours acquits par la caméra et les reconstruire.

6

Figure 5 – Les prototypes générés par k-moyennes

3

Apprentissage et reconnaissance des gestes

Afin de classifier nos gestes, nous avons choisi d’implémenter un algorithme d’apprentissage
supervisé : k plus proches voisins, mais pour obtenir les prototypes auxquels comparer nos gestes
en temps réel, nous avons du générer des prototypes en utilisant l’algorithme k-moyennes.

3.1

Apprentissage non-supervisé : k-moyennes

Nous avons implémenté l’algorithme de K-moyennes fourni avec l’énoncé du TL sous Matlab .
Après avoir caractérisé chaque contour de main présent sur l’image binaire par ses descripteurs de
Fourier, nous avons choisi de prendre autant d’échantillons pour chaque signe à savoir 40 images
par signe ce qui nous donne une base de données équilibrée, afin d’y appliquer notre algorithme
de Clustering.
Il y a des choix de paramètres à faire dans le code Matlab, notamment au niveau de l’échantillonnage de la reconstruction (pour la visualisation des prototypes) et du nombre d’itérations
de l’algorithme. Nous avons retenus 21 coefficients pour chaque prototype et 50 itérations de
l’algorithme des K- moyennes.
Le principe consiste à définir les quatre barycentres des différents signes, et à vérifier que les vecteurs représentant les mêmes signes se trouvent dans le même cluster. En appliquant k-moyennes,
on choisit quatre prototypes aléatoires au début et et en calculant pour chaque vecteur du dataset
ses distances par rapport à ces quatre prototypes, on peut l’attribuer dans un premier temps à
un cluster précis. Après avoir obtenu une disposition initiale des quatres clusters, on met à jour
les prototypes en calculant les barycentres des quatres groupes et on réitère la procédure jusqu’à
obtenir une situation stable. Nous avons remarqué que l’on obtient cela après 50 itérations, donc
même en augmentant le nombre des itérations, on obtenait toujours les mêmes prototypes.
Les coefficients de Fourier normalisés des prototypes étant alors calculés sous Matlab, il ne reste
plus qu’à les exporter vers notre programme. Pour ce faire, Nous avons enregistré dans un fichier
7

Figure 6 – Fonctionnement de K-n-n pour un geste : Avance
texte les parties réelles des coefficients de chaque prototype, de même pour les parties imaginaires.
Nous avons sélectionné deux prototypes pour chaque signe, ce qui nous fait 16 fichiers texte. Ces
fichiers sont ensuite lus par la fonction lire-prototypes de notre programme pour extraire les
coefficients et les stocker dans un vecteur de complexes. Nous avons aussi créé une fonction
regrouper-prototypes pour stocker tous les vecteurs représentant les prototypes dans un seul
vecteur qu’on peut parcourir en utilisant des itérateurs.

3.2

Apprentissage supervisé : k-plus-proches-voisins

Afin de détecter la commande présente dans un signe, nous avons fait appel à un algorithme
d’apprentissage supervisé : k-plus-proches-voisins en prenant k=1.
Quand l’utilisateur fait un geste devant la caméra en temps réel, notre programme traite l’image,
en supprimant les couleurs différentes du rouge, ensuite en sélectionnant le contour le plus long
correspondant à la main. Il reste ensuite à calculer les coefficients de fourier normalisés afin de
les comparer aux prototypes. Nous avons pris soin de réaliser les mêmes calculs et étapes que
veux fait sous Matlab pour que la comparaison ait un sens.
Après avoir obtenu le vecteur contenant les coefficients de fourier correspondant au contour de la
main, le k-plus-proches-voisins consiste à chercher le prototype le plus proche de notre vecteur en
se basant sur un calcul de dimension euclidienne dans l’espace des coefficients de dimension 21.
Nous avons utilisé deux itérateurs, l’un sur le vecteur des coefficients de fourier qu’on chercher à
comprendre et l’autre sur le vecteur contenant tous les prototypes. On attribue alors au contour
l’ordre correspondant au prototype le plus proche. Après plusieurs tests sur des signes présents
dans notre base de données et des signes quelconque, nous avons fixé une distance maximale
entre le vecteur les coefficients de Fourier du signe émis et son prototype le plus proche au dessus
de laquelle notre programme déclare le geste comme non détecté. Nous avons inclus dans notre
programme une boucle Switch pour afficher l’ordre correspondant au signe émis devant la caméra.

8

4

Conclusion

Cette étude de laboratoire nous a permis d’étudier d’une manière plus approfondie toutes les
étapes qui régissent le traitement des images, allant du traitement au niveau pixel (R,G,B)
à la représentation d’une image à l’aide de ses descripteurs de fourier. Et de tester différents
algorithmes d’apprentissage automatique supervisé et non supervisé afin de de clusteriser les
différents signes et de classifier les nouveaux émis en temps réel.
Nous sommes parvenus à créer un programme qui fonctionne correctement dans les conditions
d’expérimentation que nous avons fixés, toutes les images ont été prises dans la salle du TL, avec
une lumière assez blanche. La segmentation des images devra être traitée à l’aide d’une nouvelle
approche si l’on veut rendre notre programme adapté à tout environnement. Nous avons remarqué
que lors des tests dans d’autres salles comme nos chambres, nous observons beaucoup plus de
bruit et de mauvaises détections. Cela est dû à la lumière plus tamisée, à la résolution de la
caméra et aux murs jaunes. Une solution serait de changer les seuils fixés dans la salle du TL
pour la détection de la main ou de procéder d’une façon totalement différente.
Malheureusement, par manque de temps, nous n’avons pas pu implémenter notre programme
sous ROS afin de commander directement les koalas.

9


Aperçu du document Rapport_TL_gestes_SIR.pdf - page 1/10
 
Rapport_TL_gestes_SIR.pdf - page 3/10
Rapport_TL_gestes_SIR.pdf - page 4/10
Rapport_TL_gestes_SIR.pdf - page 5/10
Rapport_TL_gestes_SIR.pdf - page 6/10
 




Télécharger le fichier (PDF)


Télécharger
Formats alternatifs: ZIP Texte




Documents similaires


rapport tl gestes sir
calcul differentiel et integral tome2 n piskounov mir
program ing cna maths phyik
elements de science physique 1
corrige4
masters thesis aic

Sur le même sujet..




🚀  Page générée en 0.037s