Calibration automatique d`une caméra

DÉPARTEMENT DE GÉNIE ÉLECTRIQUE
Calibration automatique d’une caméra
Rapport de projet de fin d'études soumis
comme condition partielle à l'obtention du
diplôme de baccalauréat en ingénierie.
Présenté par:
Guillaume Scott
Matricule:
1248895
Directeur de projet: Paul Cohen
Co-directeur:
Date: _29 novembre 2007_
Julien Beaudry
i
Sommaire
Ce projet a été développé dans le cadre du projet de fin d’études et a pour but de
concevoir une solution logicielle qui permet de calibrer automatiquement une caméra afin
de fournir à un robot joueur de soccer une bonne vision de l’environnement dans lequel il
évolue. Les robots en question ont été conçus par la société technique Robofoot et ils ont
grandement besoin d’amélioration pour redevenir compétitifs et avoir la chance de
gagner, un jour, la coupe du monde de soccer robotisé. La bonne perception de
l’environnement de jeu est un atout important en vue de l’obtention d’un robot joueur de
soccer compétitif et performant. Comme les sources de lumière et leurs intensités peuvent
être variées et dynamiques dans l’environnement du robot, un système qui s’adapte
automatiquement aux changements est très avantageux. C’est ce que ce projet tente de
faire en utilisant différentes approches.
L’algorithme de calibration de la caméra qui est développé dans ce projet est une balance
des blancs. Cette technique est utilisée en imagerie pour ajuster les couleurs par rapport à
une couleur de référence blanche. L’algorithme qui a été développé est innovateur et
utilise des techniques de traitement d’images complexes pour permettre une calibration
efficace de l’image, peu importe les conditions initiales du système de vision. Le résultat
du filtre de calibration permet de converger vers une solution stable en très peu
d’itérations.
ii
Table des matières
Listes des figures................................................................................................................ iv
Liste des abréviations .......................................................................................................... v
Remerciements ................................................................................................................... vi
Introduction ......................................................................................................................... 1
Problématique...................................................................................................................... 4
Méthodologie ...................................................................................................................... 6
Approche initiale ............................................................................................................. 6
Choix de l’environnement de développement................................................................. 7
Choix du modèle de couleur............................................................................................ 8
Traitement d’image ....................................................................................................... 10
Correction de la luminosité ........................................................................................... 17
Correction de la chrominance ....................................................................................... 18
Intégration avec un robot............................................................................................... 20
Résultats ............................................................................................................................ 22
Essais avec le modèle logiciel....................................................................................... 22
Essais avec le modèle de la caméra............................................................................... 24
Discussion ......................................................................................................................... 27
Justification de la méthodologie utilisée ....................................................................... 27
Explication des résultats obtenus .................................................................................. 29
Limitation de l’algorithme développé ........................................................................... 31
iii
Amélioration possible ................................................................................................... 33
Retour sur le fonctionnement du système ..................................................................... 34
Bibliographie..................................................................................................................... 36
Annexe .............................................................................................................................. 38
iv
Listes des figures
Figure 1 : Plan du filtre de correction lumineuse .............................................................. 10
Figure 2 : Système de vision d’un robot et image perçue par le robot.............................. 16
Figure 3 : Première itération dans le filtre logiciel avec une faible luminosité ................ 22
Figure 4 : Première itération dans le filtre logiciel avec une forte chrominance bleue..... 23
Figure 5 : Première itération dans le filtre logiciel avec une forte luminosité et une forte
chrominance ...................................................................................................................... 24
Figure 6 : Image initiale pour effectuer les tests de comparaison entre les deux modèles.
........................................................................................................................................... 25
Figure 7 : Différence entre le modèle logiciel et celui de la caméra après une itération. . 25
Figure 8 : Différence entre le modèle logiciel et celui de la caméra après dix itérations. 26
Figure 9 : Résultat de la calibration sans la détection des lignes. ..................................... 27
v
Liste des abréviations
API :
Interface de programmation, elle permet de faire le lien entre une
application et un module externe.
BMP :
Format d’image Bitmap, il est utilisé pour observer les résultats obtenus
sur le système d’exploitation Windows.
GCC :
Compilateur utilisé sous le système d’exploitation Linux
FIFA :
Fédération Internationale de Football Association.
HSI :
Espace de couleur définissant une couleur par sa teinte, son niveau de
saturation et son intensité lumineuse.
PNG :
Format d’image Portable Network Graphics, il est utilisé pour observer
les résultats obtenus sur le système d’exploitation Linux.
RGB :
Espace de couleur formé de trois composantes représentant le rouge, le
vert et le bleu respectivement.
SSH :
Système de communication sécurisé utilisé pour communiquer avec les
robots.
YUV :
Espace de couleur formé de trois composantes où Y représente la
luminance et UV représentent la chrominance.
YUV420p :
Représentation planaire de l’espace de couleur YUV.
vi
Remerciements
Je tiens à remercier M. Paul Cohen, mon directeur de projet, d’avoir accepté d’appuyer
mon projet. J’aimerais également remercier Julien Beaudry, co-directeur de mon projet et
fondateur de Robofoot, pour son appui dans ma démarche de développement.
De plus, un grand merci à Jean Christophe Roy et Simon Pelletier-Thibault, deux
membres de Robofoot, qui m’ont permis de voir certains aspects pratiques de la vision
par ordinateur sous différents angles.
J’aimerais aussi remercier ma mère qui a accepté de relire ce document.
1
Introduction
Depuis les dernières décennies, la robotique a connu une croissance fulgurante. Des
simples automates programmables jusqu’aux humanoïdes derniers cris, l’évolution des
robots se fait en suivant la demande des besoins de l’industrie et en voulant amener le
développement technologique vers de nouvelles limites. Les dernières générations de
robots possèdent souvent un système de vision intégré afin qu’ils puissent interagir avec
leur environnement le plus efficacement possible. Cette méthode d’interaction vient
s’ajouter à la panoplie de capteurs disponibles pour permettre au robot de percevoir
l’environnement dans lequel il se trouve. Afin de trouver une solution qui permettrait de
relier les recherches qui sont faites dans le domaine de la robotique mobile avec des
applications de la vie courante, des chercheurs japonais ont décidé de créer une
compétition d’envergure internationale qui utilise des robots pour jouer au soccer. Cette
compétition, la Robocup1, a vite pris de l’ampleur par le fait qu’elle est une application
très intéressante de la robotique et elle permet aux chercheurs d’essayer directement leur
dernière création, tout en attirant plusieurs catégories de personnes, des plus jeunes aux
plus vieux. C’est à cette compétition que la société étudiante Robofoot2 participe. Cette
dernière a développé une équipe de six robots joueurs de soccer qui participe dans la
catégorie Middle-Size3. Cette ligue décide d’imposer des modifications aux règlements
chaque année afin de favoriser le développement de nouvelles solutions qui permettent de
résoudre les différents problèmes afin d’arriver au principal objectif de la compétition.
1
Site internet de la compétition : http://www.robocup.org/
Site internet de Robofoot : http://robofoot.polymtl.ca/
3
Site internet de la ligue : http://www.er.ams.eng.osaka-u.ac.jp/robocup-mid/
2
2
Cet objectif est d’être capable de développer une équipe de robots joueurs de soccer qui
va être capable, d’ici 2050, de battre l’équipe de soccer humaine qui sera championne du
monde. Pour ce faire, les dirigeants de la compétition établissent des règlements qui se
rapprochent de plus en plus à ceux établis par la FIFA.
Dans la ligue où Robofoot participe, les derniers changements apportés sont
principalement des défis pour le système de vision des robots. D’abord, les buts de soccer
seront modifiés. La couverture de bois coloré qui était utilisée sera remplacée par un filet
standard. Ensuite, les balises situées aux extrémités du terrain seront enlevées.
Actuellement, les buts et les balises sont les seuls éléments qui sont utilisés pour pouvoir
établir la position des robots sur le terrain. Il faut donc trouver une alternative à ce
système de repérage pour détecter la position des robots. Finalement, la compétition
propose des défis techniques que toutes les équipes doivent relever chaque année. Pour
cette année, un des défis est d’être capable de jouer un match sur un terrain extérieur.
Ceci implique que le système de vision des robots doit être capable de s’ajuster à un
éclairage extérieur et intérieur. Comme l’éclairage extérieur est uniquement composé de
la lumière du soleil et que celle-ci est très différente d’une lumière provenant de
différentes sources artificielles intérieures, il faut avoir un algorithme qui sera capable de
s’ajuster aux modifications de l’éclairage. C’est le principal problème auquel ce projet
apporte une solution.
Dans un premier temps, le problème à résoudre sera bien défini et certains critères de
conception seront définis afin de permettre de cibler une piste de solution. Il est important
3
de bien identifier une démarche à suivre puisque le problème à résoudre est relativement
complexe. Dans un deuxième temps, les méthodes utilisées pour arriver à résoudre le
problème seront présentées. Ces méthodes incluent les différents choix de conception qui
ont dû être faits et comparent les différentes approches possibles afin de choisir la plus
appropriée pour résoudre le problème. Troisièmement, les résultats obtenus avec les
algorithmes qui ont été développés seront présentés. Finalement, une discussion entourant
les divers résultats obtenus sera faite pour bien les expliquer. Quelques recommandations
sur la méthode utilisée seront proposées et des propositions d’améliorations du système
seront définies afin de permettre de réutiliser le système dans d’autres applications.
4
Problématique
La société technique Robofoot conçoit des robots joueurs de soccer qui participent à une
compétition internationale. Le système de vision qui a été développé initialement est
capable de fournir des performances acceptables lorsqu’il est correctement calibré.
Lorsqu’il a été développé, l’environnement de la compétition était très bien défini, les
sources lumineuses étaient disposées de façons optimales. Or, depuis l’année passée, les
organisateurs de la compétition ont décidé d’introduire différentes conditions lumineuses
dans l’environnement de jeu, c’est-à-dire, qu’il peut y avoir des fenêtres avec de
l’éclairage naturel du soleil en plus des différentes sources d’éclairages artificielles. Ces
nouvelles sources de lumière modifient considérablement les couleurs qui sont perçues
par les robots. De plus, dans un avenir rapproché, le terrain de jeu risque d’être à
l’extérieur, où les conditions lumineuses ne sont pas du tout contrôlées. Comme la
méthode de calibration des caméras est présentement tout à fait manuelle, c’est-à-dire,
qu’il faut calibrer les gains en couleur de la caméra un à un et ensuite définir des plages
acceptables pour classifier les différentes couleurs, le paramétrage de la caméra est long
et fastidieux. De plus, il ne peut pas se faire durant une partie. Lorsqu’il est possible de
calibrer le système, le temps requis pour analyser les images et ajuster les gains jusqu’à
obtenir une image claire est relativement long. Le problème est que durant une
compétition, chaque minute est importante. Si le temps de calibration des caméras peut
être réduit, cela permettra de mieux investir ce temps dans d’autres tâches. De plus,
comme l’ajustement est basé sur la perception de l’œil humain, des erreurs sont toujours
possible. Comme, le système de vision actuel n’est pas fait pour être soumis à divers
5
environnements lumineux en un cours laps de temps, il y a un problème. Le but de ce
projet est de prendre le système de vision actuelle et d’y ajouter un module de calibration
automatique pour permettre à la caméra de se calibrer automatiquement face aux divers
changements lumineux qui peuvent se présenter dans l’environnement où le robot évolue.
Le module de calibration agira comme un filtre de correction lumineuse qui modifiera les
paramètres de la caméra pour que l’image perçue soit de la bonne couleur et que les
divers objets recherchés par le robot lors d’un match de soccer soient bien trouvés dans
l’image. Pour cela, le filtre doit idéalement converger vers une solution unique, peu
importe les conditions lumineuses de l’environnement. Le filtre devra également
converger vers une solution fonctionnelle, peu importe le niveau de bruit et d’interférence
présente dans l’image captée. De plus, le temps requis par le filtre pour converger vers
une solution devra être le plus court possible afin d’avoir un impact négligeable sur les
autres composantes nécessitant les images du système de vision des robots. Ces
caractéristiques sont les principaux défis qu’il faut relever dans la conception de ce filtre
de correction lumineuse. La principale difficulté qui risque d’être rencontrée dans le
développement de ce projet est de faire une relation entre l’image observée et l’image
idéale qui devrait être observée. Cette relation se traduit en équations qui caractérisent le
filtre de correction, mais pour répondre aux critères de conception qui ont été établis, ces
équations seront probablement complexes.
6
Méthodologie
L’approche utilisée pour aborder le problème est de concevoir un modèle entièrement
logiciel qui effectue un traitement d’image pour corriger la couleur d’une image. Ce
modèle va permettre de développer les algorithmes de traitements d’images requis pour
l’application du filtre de correction lumineuse. Une fois que les algorithmes seront
implémentés et qu’ils fonctionneront, il suffira de les intégrer dans le robot pour pouvoir
les essayer directement avec la caméra. Pour ce faire, il faudra revoir l’interface de
communication entre le logiciel et la caméra pour pouvoir modifier les paramètres de
celle-ci. Ensuite, il suffira d’effectuer des tests pour valider que tout fonctionne
correctement et de prendre des mesures de temps pour calculer le temps d’exécution du
filtre.
Approche initiale
La calibration des couleurs d’une caméra se fait principalement par l’ajustement de trois
paramètres, soit l’intensité lumineuse, le niveau de rouge et le niveau de bleu. Le gain de
l’intensité lumineuse sert à niveler le signal de rétroaction de la caméra et est directement
lié à la luminosité de l’image captée. Le niveau de rouge et le niveau de bleu servent à
définir la chrominance de l’image captée. Afin d’automatiser le processus de calibration
de la caméra, il faut pouvoir ajuster la luminosité et la chrominance de l’image. Dans
l’approche utilisée, la calibration de ces paramètres se fait séparément puisqu’ils sont
complètement indépendants pour la caméra. Afin de développer un modèle fonctionnel, il
7
est plus facile de travailler sur des images statiques prises à partir du robot. Pour pouvoir
concevoir un modèle efficace, un jeu d’images prises à partir de la caméra avec
différentes valeurs de paramètres est requis. Ces images vont pouvoir servir d’entrée au
modèle initial qui sera conçu pour répondre aux besoins du projet.
Choix de l’environnement de développement
Le développement du filtre de correction peut se faire dans plusieurs langages de
programmation, mais comme les robots sont programmés en C++, il va de soit que, pour
être intégré au robot, le filtre devra également être programmé en C++. En ce qui
concerne l’environnement de développement, il y a deux possibilités. La première
solution est de développer le code dans Visual Studio sur le système d’exploitation
Windows et la deuxième solution est de le développer dans une console en utilisant un
éditeur de texte comme Emacs ou nano. La deuxième solution permettrait de faire le
design sur un robot directement puisque ceux-ci fonctionnent sur une distribution Linux
qui n’a pas d’interface graphique. Bien qu’il peut être avantageux de développer une
solution directement sur la plate-forme d’utilisation afin de s’assurer qu’il n’y ait pas de
problème de compatibilité, il est beaucoup plus difficile de se retrouver dans un projet qui
contient plusieurs fichiers lorsqu’il n’y a aucun moyen de les visualiser tous en même
temps. De plus, les robots ne possèdent pas de clavier et d’écran, ce qui oblige
l’utilisateur à se connecter au robot en utilisant des consoles SSH. Un autre problème
relié à l’utilisation de cette solution est, que les robots sont dans le local de Robofoot et
que le développement de l’algorithme ne se fait pas nécessairement dans ce local. Donc,
la première solution est mieux appropriée. En effet, l’interface de développement Visual
8
Studio permet de créer un projet qui rassemble tous les fichiers, ce qui les rend facilement
accessibles. De plus, l’interface de développement reconnait les mots clés du langage et il
fait une bonne indentation du code, ce qui facilite considérablement sa lisibilité. Bien
que, dans cette solution, il faudra faire un travail supplémentaire à la fin pour porter le
code du système d’exploitation Windows vers Linux, l’estimation du temps de
développement requis pour arriver à une solution fonctionnelle est meilleure dans ce casci. Donc, l’interface de développement sera Visual Studio pour ce qui a trait au
développement des algorithmes du filtre de calibration lumineuse. En ce qui concerne
l’intégration du code dans le robot, si tout est fait correctement, aucune modification ne
sera nécessaire. Si toutefois des modifications sont nécessaires, ceux-ci pourront se faire
directement dans une console puisqu’elles risquent d’être mineures. De plus, le fait que le
développement se fait dans un environnement comportant une interface graphique, il est
possible de générer des images et de les afficher directement à l’écran pour observer plus
rapidement les résultats obtenus. C’est en observant ces résultats que la validité du filtre
développé peut être vérifiée.
Choix du modèle de couleur
Ensuite, avant même de commencer à trouver des solutions à la calibration de la caméra,
il faut définir quel sera le modèle de couleur qui sera utilisé. Il existe plusieurs modèles
de couleurs qui sont utilisés dans le système de Robofoot. Le plus connu est le modèle
RGB. Dans ce modèle, chaque pixel d’une image est défini par son niveau de couleur
rouge, vert et bleu. Ce modèle est le plus intuitif, mais il ne permet pas de classer les
couleurs selon leur intensité lumineuse facilement. Un autre modèle, le HSI, est utilisé
9
pour classer les couleurs. C’est ce modèle de couleur qui est présentement utilisé par les
algorithmes de localisation du robot. Ce modèle définit une couleur par sa teinte, son
niveau de saturation et son intensité. Bien que les couleurs puissent être classifiées en
intensité facilement dans ce modèle, l’obtention de la chrominance des couleurs à partir
des autres paramètres de ce modèle n’est pas vraiment aisée. Afin de calibrer la caméra, il
faut trouver la couleur qui a la plus forte probabilité d’être le blanc dans l’image. Or,
dans le modèle HSI, le blanc ainsi que le noir et les différents niveaux de gris sont
caractérisés par un faible niveau de saturation et ils n’ont aucune teinte de définie.
N’ayant aucune teinte, il devient difficile de trouver un blanc qui n’est pas balancé et de
l’ajuster correctement. Ce modèle est déjà plus proche des caractéristiques qu’il faut
ajuster pour calibrer la caméra, mais il existe un autre modèle de couleur, le modèle
YUV, qui définit une couleur par son intensité et sa chrominance. De plus, ce modèle de
couleur est généralement celui qui se retrouve à la sortie des caméras, ce qui implique
qu’aucune conversion n’est nécessaire avant de traiter l’image. Comme ce modèle
caractérise une couleur par les paramètres qu’il faut ajuster pour calibrer une image, il
s’avère un bon choix pour le développement des filtres de corrections de couleurs. Dans
le cas de l’application des robots, le format de sortie des caméras est le YUV420p. Ce
format est une représentation planaire du format YUV, c’est-à-dire, que chacun des
paramètres Y, U et V sont définis séquentiellement. Donc, les valeurs de Y de tous les
pixels de l’image sont regroupées linéairement au début des données représentant
l’image, suivi de toutes les valeurs du paramètre U et, ensuite, de toutes les valeurs du
paramètre V. De plus, il y a une valeur de Y pour chaque pixel de l’image tandis qu’il y a
une valeur de U et de V pour chaque quatre pixels. Les groupes de quatre pixels
10
représentent des carrés de deux pixels par deux pixels. La réduction du nombre de
données nécessaires pour former les canaux U et V est possible puisque l’œil humain est
plus sensible aux changements d’intensités qu’aux changements de couleur.
Traitement d’image
Dans cette section, la méthodologie utilisée pour faire la conception du filtre de
correction lumineuse est présentée. Voici une représentation sommaire du plan qui sera
suivi pour obtenir le filtre :
Entrée
Sortie
Caméra
Image caméra
ImageY UV
Transformation en ImageYUV
ImageY UV
ImageY UV
Image calibrée
Observation du résultat
ImageY UV
Affichage des lignes
Calcul du masque en Y
masque Y
Nouv eau paramètre
masque Y
Ligne blanche
v aleur moy enne Y UV du blanc
Traitement d'image
v aleur moy enne Y UV du blanc
Ajustement des paramètres YUV
Figure 1 : Plan du filtre de correction lumineuse
Premièrement, il faut convertir l’image de la caméra dans un format acceptable pour
travailler efficacement. Comme il faut travailler sur l’image pixel par pixel, il est
préférable d’avoir un format qui représente chacun des pixels par ses composantes Y, U
et V. Pour obtenir ce format, il faut faire une boucle qui déduit la valeur des composantes
U et V de chaque pixel à partir du format yuv420p. Une fois que l’image à traiter est dans
ce format, il est plus facile de rechercher des valeurs spécifiques. Le format qui décrit ce
modèle de couleur est le modèle YUV et les images qui seront utilisées dans le traitement
11
seront toutes dans ce format particulier. Le but recherché dans la conception du filtre est
d’être capable d’isoler les sections d’une image qui sont potentiellement blanches. C’est
grâce à ces sections que la calibration des couleurs est possible. Pour ce faire, la méthode
la plus simple pour trouver les sections blanches dans une image est d’effectuer un
seuillage sur la composante Y. Afin d’ajouter de la robustesse au système, il est possible
d’ajouter des critères à la technique de seuillage pour isoler plus efficacement les
candidats potentiels pour la couleur blanche. Cette technique est utilisée pour faciliter la
détection des lignes blanches dans l’image, lesquelles seront ensuite utilisées pour
déterminer les valeurs moyennes actuelles de la couleur blanche dans l’image. La
technique de seuillage est utilisée pour isoler les données qui ont la plus forte probabilité
d’être effectivement blanches. La méthode la plus simple de procéder est de choisir des
conditions initiales fixes qui représentent le mieux possible le cas moyen. Ce cas se
produit lorsque l’image perçue par la caméra est relativement proche de l’image qui
devrait être obtenue. Alors, c’est lorsque les valeurs moyennes du blanc qui devraient être
observées sont proches des valeurs moyennes idéales. Dans le cas où l’image est moins
bien calibrée, il est possible de modifier les conditions de seuillage pour tenter d’isoler
plus efficacement les zones recherchées dans l’image. Une modification des paramètres
de seuillage implique qu’il faut faire une itération supplémentaire pour obtenir une
représentation binaire de l’image. Les paramètres peuvent être modifiés tant que le
résultat obtenu n’est pas satisfaisant. Comme le processus de seuillage se fait sans
intervention, il faut trouver une méthode pour décider lorsque l’image obtenue n’est pas
satisfaisante et qu’une itération de seuillage supplémentaire est nécessaire. La méthode
qui est utilisée ici utilise la densité du groupe de candidat potentiel blanc dans l’image
12
binaire pour décider si une autre itération est requise. Si la densité est trop grande ou trop
faible par rapport à ce qui devrait normalement être observé dans l’environnement de jeu,
la valeur de seuil peut être modifiée pour converger vers une densité acceptable. Afin
d’ajouter de la robustesse à cette technique, pour permettre de cibler plus efficacement le
blanc et pour éliminer le bruit présent dans l’image, il est possible d’ajouter des
conditions de seuillage sur les paramètres de la chrominance. En effet, dans le modèle de
couleur YUV, la couleur blanche a une chrominance nulle donc, les couleurs recherchées
doivent avoir des valeurs de chrominance qui se rapprochent de 0. En tenant compte de
plusieurs paramètres pour calculer le niveau de seuillage, l’image binaire résultante
ciblera plus précisément les candidats potentiellement blancs. L’utilisation des
paramètres de chrominance pour effectuer le seuillage permet d’éliminer les sections de
l’image qui sont saturées. En effet, lorsqu’une donnée possède à la fois une grande
intensité lumineuse et une forte chrominance, la probabilité que cette donnée soit du bruit
ou un artefact dû à la compression utilisée dans le transfert des données de la caméra à
l’application est grande. Donc, il est préférable d’éliminer ces données de la liste des
données potentiellement blanches, quitte à réduire légèrement la densité de candidats
probable. Ainsi, les données utilisées pour calculer les valeurs moyennes seront peut-être
en plus petit nombre, mais la probabilité d’erreur est diminuée. Dans le cadre de la
conception de ce filtre-ci, les paramètres de seuils initiaux utilisés se rapprochent des
paramètres idéaux avec un certain delta pour considérer les imperfections qui sont
présentes dans l’image. Si la densité de blanc trouvé n’est pas satisfaisante, il suffit de
modifier le delta et de réappliquer le seuillage sur l’image.
13
Une méthode qui peut être utilisée pour améliorer la détection des couleurs
potentiellement blanches est d’effectuer un traitement sur l’image afin de réduire le bruit
présent. Bien qu’il ne soit pas nécessaire d’appliquer cette méthode avant le seuillage,
son application peut permettre d’éliminer certaines imperfections isolées dans l’image.
L’élimination de ces imperfections va simplifier le travail des algorithmes subséquents
dans le sens où le bruit présent qui peut être considéré comme un candidat potentiel pour
la couleur blanche rallonge le temps de traitement requis pour détecter les vraies sections
blanches présentes dans l’environnement de jeu. Une des méthodes les plus simples pour
appliquer un algorithme d’élimination de bruit dans une image est de regarder la valeur
de chaque pixel et la comparer avec celle de ses voisins immédiats pour voir s’il y a des
différences locales qui ne concordent pas avec l’environnement. Si la valeur de tous les
voisins est identique, mais différente de celle du pixel courant, il faut changer la valeur
du pixel courant. Ceci permet d’obtenir un meilleur échantillonnage des pixels
potentiellement blancs. Une telle technique est nécessaire puisque l’image à laquelle le
seuillage est appliqué n’est pas nécessairement calibrée donc, le blanc ne ressort pas
nécessairement blanc, d’où l’importance d’éliminer le bruit dans l’image.
Dans l’image générée par le seuillage, il se peut qu’il y ait plusieurs sources de couleurs
blanches qui soient indésirables. Ces sources peuvent engendrer des problèmes lors de la
calibration puisqu’ils ne sont pas la couleur blanche qui est recherchée. Il faut donc,
trouver une solution pour tenter de ne pas les prendre en considération lors du calcul des
paramètres du blanc. Dans l’environnement de jeu où les couleurs sont réglementées, les
seules sources blanches qui se retrouvent sur le terrain de jeu sont les lignes et il peut y
avoir d’autres sources blanches à l’extérieur du terrain. Lors du design de ce projet,
14
l’environnement est celui du local de Robofoot et il y a beaucoup plus de sources
blanches dans celui-ci que dans un environnement de jeu réglementaire. Les sources
présentent dans le local de Robofoot sont les lignes du terrain, les murs, le plancher et les
fluorescents. Les trois derniers types de sources sont indésirables. Si la caméra est
capable de se calibrer correctement dans l’environnement du local de Robofoot qui
comprend plusieurs sources indésirables alors, la calibration devrait normalement
s’effectuer sans problème dans l’environnement de jeu. Donc, il faut trouver une
technique pour ne pas considérer les sources indésirables lors de la calibration de la
caméra.
Une première approche est d’utiliser un algorithme pour trouver les lignes. La méthode
utilisée ici est inspirée d’une technique développée par une autre équipe de la Robocup
Middle Size Ligue4. Cette technique recherche les lignes dans une image en suivant des
lignes radiales prédéfinies. Afin de trouver les lignes, il faut rechercher les transitions de
couleur sur les lignes de recherche. Cette approche est intéressante puisqu’elle permet de
trouver rapidement les transitions sans utiliser une grande puissance de calcul, ce qui
laisse le temps au robot d’effectuer d’autres tâches durant un match. Dans le cas de la
calibration, la recherche des lignes se fait sur l’image binaire générée à partir du
seuillage. Pour trouver ce qui a la plus haute probabilité d’être une ligne, il faut
rechercher deux transitions d’intensités rapprochées, c’est-à-dire, une transition d’un
niveau 0 vers un niveau 1 suivi d’une transition d’un niveau 1 vers un niveau 0. Il ne faut
pas considérer les transitions qui sont trop éloignées puisqu’il pourrait s’agir d’une source
indésirable. Une fois que les transitions ont été trouvées sur toutes les lignes de
4
Équipe allemande Brainstormers Tribots.
15
recherche, il faut assembler tous les résultats et former les lignes potentielles. Pour ce
faire, un algorithme qui recherche des points qui forment des lignes droites est utilisé. Cet
algorithme classe premièrement tous les points qui ont été trouvés dans un ordre continu
afin de rendre la recherche linéaire. Ensuite, l’algorithme prend deux points et recherche
tous les autres points qui se trouvent approximativement sur la même pente. Un calcul
approximatif est nécessaire puisque les lignes ont une certaine largeur et qu’il faut
considérer celle-ci pour identifier une ligne. Donc, si plusieurs points sont effectivement
sur la même pente, il y a une forte probabilité qu’une ligne ait été trouvée. Il est peu
probable que ce qui a été trouvé soit une source indésirable puisque ces sources ne sont
généralement pas représentées par une ligne. Ces sources indésirables sont plutôt des
masses difformes relativement larges comparées à une ligne. Comme elles sont larges, le
premier algorithme pour trouver les transitions n’a pas retenu les points de la source
comme un candidat potentiel. Alors, comme les résultats de l’algorithme qui recherche
les lignes avec une pente ont une forte probabilité d’être ce qui est effectivement
recherché, ils sont considérés comme des bons candidats pour la calibration lumineuse.
Les valeurs des pixels correspondants sont alors utilisées pour calculer la valeur moyenne
de l’intensité lumineuse et de la couleur qui est observée. Une fois que les valeurs
moyennes des pixels retenues comme les meilleurs candidats pour la calibration sont
obtenues, la correction des paramètres de l’image peut s’effectuer.
Une deuxième approche qui peut être utilisée pour trouver la valeur moyenne de la
couleur blanche est un principe de calibration similaire à ce qui a été utilisé pour les
robots d’exploration du sol martien. Dans cette approche, une cible de référence est
utilisée pour obtenir les valeurs des différents paramètres des couleurs de bases. Dans le
16
cas de la calibration de la luminosité et de la chrominance pour les robots joueurs de
soccer, seule la couleur blanche est nécessaire. En effet, la calibration de la caméra peut
se faire uniquement en ajustant le blanc, c’est ce qui s’appelle la balance des blancs.
Donc, dans cette approche, il suffit d’utiliser une cible blanche pour pouvoir obtenir des
valeurs moyennes sur les différents paramètres du blanc. Afin de simplifier la tâche de ce
calcul, la cible peut être fixe par rapport à la caméra du robot. Le seul problème qui se
pose avec cette solution est qu’il n’y a pas d’endroit fixe sur le robot qui est visible par la
caméra puisque la vis qui tient le miroir omnidirectionnel cache le robot entièrement
comme l’illustre la figure 2 :
Figure 2 : Système de vision d’un robot et image perçue par le robot.
Cette deuxième solution ne peut pas être utilisée facilement puisqu’il n’existe pas
d’endroit fixe dans le champ de vision du robot qui permet d’utiliser une balise blanche
pour calculer les paramètres moyens du blanc. Cette solution ne sera donc pas retenue.
17
Correction de la luminosité
La première partie de la correction de la couleur d’une image est l’ajustement de
l’intensité lumineuse de celle-ci. Pour corriger la luminosité, ce qui est proposé est de
faire une différence entre la valeur courante du blanc dans une image et la valeur désirée.
Pour ce faire, la luminosité moyenne du blanc observé a été calculée selon la méthode
présentée précédemment. En ce qui concerne une couleur blanche parfaite, sa luminosité
se définit par une valeur maximale. Dans le modèle de couleur utilisé, le paramètre de
luminance Y est donc maximal pour une couleur blanche parfaite. Lors du calcul de
différence entre l’image observée et l’image idéale, un facteur de correction est utilisé.
Ce facteur vient limiter la différence entre les deux valeurs afin qu’il n’y ait pas de
changement trop radical. L’utilisation d’un tel facteur est requise puisque l’image
observée peut avoir n’importe quel paramètre si les conditions lumineuses sont
différentes de la dernière configuration utilisée. Dans l’optique où le filtre de calibration
est appliqué plusieurs fois successivement pour corriger parfaitement l’image,
l’utilisation d’un tel facteur va simplement ralentir le processus de calibration.
Dans le premier modèle développé, la différence obtenue entre la valeur moyenne
observée et la valeur idéale est appliquée à chaque pixel de l’image pour effectuer la
transformation. Ceci permet de voir le résultat du calcul effectué sur la correction de la
luminosité de l’image et d’ajuster le facteur en conséquence. L’ajustement de ce facteur
se fait à la main comme dans le cas de la calibration des gains d’un contrôleur PID dans
un système asservi. Bien qu’il existe des techniques de calibration plus sophistiquées,
elles ne sont pas employées dans le cadre de la calibration de ce facteur puisque celui-ci
18
peut être obtenu relativement facilement en quelques essais. La méthode de validation du
choix du facteur est l’observation à l’œil de la différence entre l’image de départ, l’image
obtenue et une image calibrée correctement préalablement.
Dans le deuxième modèle développé, la différence obtenue entre la valeur moyenne
observée et la valeur idéale doit être transformée en un paramètre de la caméra. Pour
obtenir le paramètre de la caméra, il faut d’abord avoir la valeur du paramètre courant et
lui appliquer la différence avec le même facteur qui a été calculée dans le premier
modèle. Il faut ensuite appliquer le nouveau paramètre à la caméra. La méthode de
validation de ce modèle est de capturer une image avant la calibration et une autre après
la calibration pour observer le résultat.
Correction de la chrominance
La deuxième partie de la correction de la couleur d’une image est l’ajustement de la
chrominance de celle-ci. Pour corriger la chrominance, une approche similaire à ce qui a
été utilisé pour corriger la luminosité est utilisée. Comme les valeurs moyennes de la
couleur blanche observée ont déjà été obtenues, il suffit d’utiliser les deux paramètres du
modèle de couleur YUV qui définissent la couleur pour effectuer la correction. Dans le
cas de la correction de la chrominance, il faut calculer la différence entre les valeurs
moyennes du blanc observée dans l’image et les valeurs idéales du blanc. Les différences
sur les paramètres U et V sont calculées séparément. Comme dans le cas de la correction
de la luminosité de l’image, des facteurs de corrections sur les différences entre la valeur
observée et la valeur idéale sont requis pour permettre aux systèmes de se stabiliser plus
19
facilement. En effet, si les variations des paramètres sont trop élevées dès la première
itération du filtre de correction, il se peut que la correction soit trop forte. Une correction
trop forte ne permet pas d’obtenir le résultat désiré puisque les paramètres ne seront pas
ajustés correctement. Les paramètres vont seulement avoir une différence de signe
opposé entre la valeur observée et la valeur désirée. L’application de ce facteur permet de
converger plus facilement vers la solution désirée, mais il faudra un peu plus de temps
pour y arriver.
Dans le modèle logiciel, la correction s’effectue sur l’image en appliquant la différence
obtenue entre la valeur observée et la valeur idéale à la valeur des paramètres U et V de
chaque pixel. Le résultat peut être observé en affichant l’image corrigée. L’observation
du résultat permet de calibrer les facteurs de correction de chaque paramètre pour
permettre au système d’arriver à une solution calibrée stable en effectuant le moins
d’itérations possible. Il faut prévoir plusieurs cas où les paramètres initiaux sont
différents pour s’assurer que le système est stable dans tous les cas. Dans le modèle avec
la caméra, il s’agit de transformer les différences obtenues pour obtenir une différence sur
les paramètres de calibration de la caméra. Les mêmes facteurs de corrections sont
utilisés dans ce modèle puisque la transformation entre la différence des couleurs vers la
différence des paramètres de la caméra est linéaire. C'est-à-dire qu’un simple facteur peut
être utilisé pour effectuer la transformation.
20
Intégration avec un robot
Une fois que le modèle logiciel de la calibration des couleurs est fonctionnel, la
prochaine étape est d’intégrer le tout dans le logiciel du robot et faire des essais
directement avec la caméra. Pour ce faire, il faut faire quelques modifications dans le
logiciel pour des raisons techniques.
Premièrement, le logiciel a été développé sous le système d’exploitation Windows et le
système d’exploitation des robots est la distribution Debian de Linux. Comme le
compilateur de ce dernier (gcc) est plus sévère en ce qui concerne la syntaxe du code,
quelques modifications ont dû être apportées à celui-ci. De plus, la méthode de
vérification qui a été développée dans la première version utilisait des fonctions et des
structures spécifiques au système d’exploitation Windows pour créer des images sous le
format BMP. Sous Linux, ces fonctions et structures n’existent pas, mais il existe une
alternative relativement simple qui est intégrée au système, soit le format PNG. Donc, il
suffit simplement de créer une fonction qui peut faire la sauvegarde des images dans les
deux formats dépendamment du système d’exploitation qui est utilisé pour contourner ce
problème.
Deuxièmement, au lieu de faire la correction sur l’image et observer le résultat, il faut
faire le changement sur les paramètres de la caméra et tenter d’obtenir le même résultat.
Pour ce faire, il faut d’abord mettre à jour l’API qui s’occupe des communications avec la
caméra pour pouvoir avoir une rétroaction sur la valeur des paramètres actuels. Ensuite, il
faut construire une boucle qui va s’occuper de faire l’acquisition des images et des
paramètres de la caméra et qui va pouvoir modifier les paramètres afin de calibrer cette
21
dernière. Ceci est différent du premier modèle dans le sens où il peut y avoir plusieurs
itérations pour arriver à un résultat satisfaisant. Par contre, le filtre de correction a été
désigné dans l’optique d’atteindre une couleur corrigée avec le moins d’itération possible
afin de ne pas trop prendre de temps de calcul.
Troisièmement, afin de ne pas briser la fonctionnalité du code du robot actuel, le modèle
de correction lumineuse a été implanté dans une branche séparée. Un avantage
d’implanter le modèle dans une branche séparée est qu’il est beaucoup plus simple de se
retrouver puisqu’il y a moins de fichiers. Un autre avantage est qu’il est plus facile de
suivre le développement et de trouver les erreurs potentielles. Le principal inconvénient à
cette méthode est qu’il va falloir refaire l’intégration dans la branche principale lorsque le
modèle sera complètement terminé, ce qui implique qu’il y aura du travail qui sera fait en
double. Par contre, c’est une bonne option puisque l’estimation de temps requis pour
corriger les erreurs potentilles est plus petite sur la branche séparée.
22
Résultats
Essais avec le modèle logiciel
Pour concevoir le premier modèle de filtre de correction de couleur d’une image,
plusieurs images ont été prises à partir de la caméra du robot. Les images illustrent toutes
la même scène sauf que les paramètres de la caméra diffèrent d’une image à l’autre. Ceci
a permis d’avoir plusieurs situations différentes pour calibrer l’image. La panoplie
d’images disponible a permis de concevoir une première version du filtre de correction
lumineuse.
Dans un premier temps, voici une image qui représente un environnement avec des
conditions lumineuses faibles et dont les paramètres de couleurs sont également faibles.
C'est-à-dire que le niveau de contraste dans l’image est faible.
Figure 3 : Première itération dans le filtre logiciel avec une faible luminosité
Dans cette figure, l’image de gauche représente l’image initiale capturée par la caméra et
l’image de droite représente le résultat du filtre de correction logiciel. Il est possible de
23
remarquer qu’une seule itération n’est pas suffisante pour obtenir une image parfaitement
calibrée, mais que l’intensité lumineuse des couleurs s’est améliorée.
Ensuite, voici une image prise dans des conditions d’intensité lumineuses normales, mais
avec un niveau de bleu beaucoup trop élevé. Ce cas est pour modéliser l’impact de la
lumière artificielle qui a normalement une teinte bleutée.
Figure 4 : Première itération dans le filtre logiciel avec une forte chrominance bleue
L’image de gauche représente l’image initiale capturée par la caméra et l’image de droite
représente le résultat du filtre de correction logiciel après une itération. Cette fois-ci, il
faut remarquer que les valeurs de la chrominance s’ajustent légèrement pour converger
vers une solution qui est calibrée correctement. Il y a encore une légère teinte bleutée qui
est présente après une itération donc, il faut appliquer quelques autres itérations pour
converger vers une solution viable.
Le troisième cas présenté est une image prise avec des paramètres aléatoires. Dans
l’image capturée, la luminosité, le niveau de rouge et le niveau de bleu sont trop élevés.
24
Figure 5 : Première itération dans le filtre logiciel avec une forte luminosité et une forte
chrominance
Dans la dernière figure, l’image de gauche présente l’image initiale capturée à l’aide de la
caméra et l’image de droite représente le résultat du filtre de correction lumineuse du
modèle logiciel. Il faut remarquer que l’image converge vers une image similaire aux
deux autres présentés précédemment et qu’une seule itération n’est pas suffisante pour
avoir une image bien calibrée. Dans la prochaine section, des images obtenues avec plus
qu’une itération seront présentées afin de les comparer avec le modèle intégré dans le
robot.
Essais avec le modèle de la caméra
Une fois que l’intégration du filtre dans le logiciel du robot est terminée, des tests
peuvent être faits pour déterminer s’il y a des différences entre le modèle purement
logiciel et le modèle qui modifie les paramètres de la caméra. Pour effectuer cette
comparaison, les paramètres initiaux de la caméra présentent une intensité lumineuse
légèrement trop élevée et une couleur beaucoup trop bleutée comme l’illustre la figure
suivante :
25
Figure 6 : Image initiale pour effectuer les tests de comparaison entre les deux modèles.
En appliquant le filtre de correction logiciel et le filtre de correction de la caméra, les
résultats observés après une itération sont les suivants :
Figure 7 : Différence entre le modèle logiciel et celui de la caméra après une itération.
L’image de gauche est le résultat du modèle logiciel et celle de droite est le résultat du
modèle avec la caméra. Il est à noter que les résultats obtenus avec le modèle qui
modifient les paramètres de la caméra sont nettement plus encourageants que prévu et
viennent confirmer la validité du modèle développé. Maintenant, voici le résultat obtenu
à partir de la même image initiale, mais après dix itérations du filtre de correction :
26
Figure 8 : Différence entre le modèle logiciel et celui de la caméra après dix itérations.
Dans cette dernière figure, l’image de gauche est celle du modèle logiciel et celle de
droite est celle du modèle de la caméra. Les deux résultats sont très similaires et
convergent vers la même solution qui semble correcte de prime abord.
27
Discussion
Justification de la méthodologie utilisée
La méthode utilisée pour développer le filtre de correction lumineuse s’est avérée une
bonne solution puisque les résultats obtenus sont relativement bons. Par contre, il y a des
petits problèmes qui ont été éprouvés lors du développement de la solution qui a nécessité
que des modifications soient apportées au plan de conception initial. Suite aux premiers
résultats observés, des techniques supplémentaires ont dû être utilisées pour ajouter de la
robustesse au système puisque la couleur blanche qui est recherchée provient de plusieurs
sources dont certaines sont indésirables pour obtenir une bonne calibration. À titre
d’exemple, voici une image qui a été prise avec une première version du filtre logiciel
lorsqu’il n’y avait pas encore d’algorithme pour calculer uniquement la couleur blanche
des lignes.
Figure 9 : Résultat de la calibration sans la détection des lignes.
En observant cette image, il est facile de remarquer que la couleur blanche qui a été
utilisée pour faire la calibration vient de l’affiche blanche à gauche de l’image. Comme le
28
blanc de cette affiche n’est pas exactement le même blanc que celui des lignes du terrain,
la calibration ne s’est pas effectuée correctement. En observant la couleur rougeâtre de
l’image, il est possible de déduire que l’affiche possède une légère teinte rouge qui n’est
pas visible à l’œil nu, mais qui vient fausser les résultats de l’algorithme logiciel. Suite à
ce problème, une technique pour différencier les types de blanc dans une image a dû être
utilisée afin d’ajouter de la robustesse au système de calibration. Ce résultat était
initialement imprévisible puisque l’œil humain ne peut pas détecter ces différences de
couleurs. Donc, des problèmes comme celui-ci ont entrainé des changements dans la
procédure à suivre pour obtenir un filtre de correction qui est fonctionnel dans plusieurs
environnements lumineux.
Puisqu’il est difficile d’évaluer la validité de la méthode utilisée tant qu’il n’y a pas de
résultat concret obtenu, une grande partie des développements ont été faits à l’aveuglette
en espérant obtenir le résultat désiré. Bien que plusieurs documents techniques aient été
utilisés à titre de référence pour rechercher les différentes approches possibles pour
résoudre le problème, ceux-ci n’ont apporté qu’une piste de solution sur la méthode qui a
été utilisée. Les différents algorithmes utilisés lors de la conception du filtre ont été
développés en tentant d’apporter une solution aux différents sous problèmes
intermédiaires. Afin de trouver une solution viable aux problèmes initiaux, le design a dû
être séparé en plusieurs sous étapes. Ce choix s’est avéré une bonne chose puisqu’il a
permis d’introduire facilement des algorithmes supplémentaires dans la solution pour
augmenter la robustesse du système. De plus, le fait de séparer le problème en plusieurs
petits problèmes permet de valider chaque partie plus facilement en effectuant des tests
29
sur chacune d’entre elles. La séparation en sous-problèmes permet également au logiciel
d’être plus lisible pour une tierce personne et elle permet de rendre le code réutilisable
pour d’autres applications.
Explication des résultats obtenus
En ce qui concerne les résultats obtenus avec le modèle logiciel du filtre de correction
lumineuse, il faut remarquer que l’ajustement des différents facteurs de correction sur les
différences entre l’image observée et l’image désirée fait en sorte qu’une seule itération
ne permet pas d’obtenir une solution qui est parfaitement calibrée. Plusieurs itérations
sont nécessaires dans ce modèle pour obtenir une solution stable qui se rapproche du cas
idéal. Il faut noter qu’il est important d’avoir ces paramètres pour que le système puisse
converger vers une solution, peu importe les conditions lumineuses de l’environnement
dans lequel le robot se trouve. Sans ces paramètres, le filtre peut être instable, c’est-àdire, que dans certaines conditions initiales, le filtre ne converge pas vers une solution.
Dans cette situation, l’image oscillerait autour de la bonne solution et aurait des
paramètres qui alterneraient entre des valeurs trop petites et des valeurs trop grandes.
Dans les trois cas qui sont présentés avec le modèle logiciel, il faut remarquer que le gain
de luminosité de l’image s’ajuste relativement correctement en une seule itération, mais
que les paramètres de chrominance sont plus longs à ajuster. Ceci s’explique par le fait
qu’il est difficile de prévoir une bonne chrominance à partir de la couleur blanche
rapidement. En effet, comme l’image n’est pas calibrée correctement, il se peut que le
seuillage qui s’effectue pour détecter la couleur blanche soit trop fort et qu’il élimine des
bonnes régions de l’image qui auraient pu être utilisées pour effectuer la calibration.
30
C’est pourquoi il est préférable d’ajuster les paramètres de la chrominance moins
rapidement pour permettre aux itérations subséquentes de pouvoir prendre en
considération les régions qui ont potentiellement été ignorées initialement. Donc, en
utilisant plusieurs itérations pour converger vers une solution viable, le système devrait
toujours donner une bonne solution. Il faut également considérer le fait que le système est
calibré une seule fois dans un environnement inconnu et que cette calibration peut
prendre tout le temps qui est requis puisqu’elle ne s’effectue pas durant la période
critique où le robot a besoin de toutes la puissance de calcul disponible. Les calibrations
durant un match de soccer ne nécessitent pas beaucoup d’itérations du filtre puisque les
variations lumineuses dans un environnement de jeu ne sont pas brusques. En effet, il est
très improbable de passer d’un environnement très lumineux à un environnement très
sombre en un court laps de temps. Donc, comme les conditions lumineuses ne changent
pas rapidement dans l’environnement, le filtre peut corriger les paramètres lumineux de
l’image en très peu d’itérations pour permettre au robot d’avoir toujours la même vision.
En ce qui concerne la comparaison des résultats obtenus entre le modèle logiciel et le
modèle intégré à la caméra, il faut remarquer que la calibration des paramètres de la
caméra permet d’obtenir une solution qui se rapproche du cas idéal beaucoup plus
rapidement. Ceci peut s’expliquer par le fait que l’image obtenue de la caméra après une
itération est une image capturée avec les nouvelles valeurs de paramètres tandis que
l’image obtenue par le modèle logiciel est le résultat d’un traitement sur l’image
originale. Comme il y a un certain pourcentage d’erreur qui peut se présenter lors du
calcul des paramètres à appliquer pour corriger l’intensité lumineuse et la chrominance
31
d’une image, le modèle logiciel a une plus grande probabilité de contenir des erreurs. De
plus, la probabilité qu’un tel phénomène se produise est plus grande lorsque l’image
originale diffère beaucoup de l’image idéale qui est recherchée. Donc, c’est pour cela que
le modèle prend plus de temps pour s’ajuster vers une solution correcte puisqu’au début
les paramètres oscillent légèrement autour de la solution recherchée.
Limitation de l’algorithme développé
Au cours du développement du modèle logiciel, une première limitation a été rencontrée.
En effet, en observant des images qui ont une très forte luminosité, il se peut que
l’algorithme qui effectue un seuillage de l’image n’arrive pas à différencier correctement
la couleur blanche de l’environnement. Une forte luminosité peut être associée à une
exposition directe au rayon du soleil. Dans le cas du robot, lorsqu’il est exposé aux
rayons lumineux du soleil, il est complètement aveuglé à cause des reflets dans le tube de
polycarbonate qui sert à protéger la caméra et le miroir du système de vision. Une
méthode de contournement du problème serait de ne pas utiliser de protection pour la tour
de vision. Par contre, il faut quand même qu’il y ait un obstacle entre la caméra et le
miroir afin de pouvoir maintenir ce dernier en position. Il y a aussi une autre piste de
solution afin d’éviter ce problème, celui d’ajuster le temps d’exposition de la caméra afin
de limiter la luminosité. Quelques essais ont été effectués pour vérifier que la solution est
viable et, bien que l’image n’est plus saturée, il y a une grande perte d’informations qui
se produit en ce qui concerne la chrominance. En effet, lorsque le temps d’exposition est
moins élevé, l’image est sous-exposée, ce qui engendre une diminution entre les teintes
de couleurs. En ayant moins de teintes pour représenter les différentes couleurs de
32
l’image, il y a moins d’informations disponibles pour bien identifier les objets qui sont
identifiés à partir d’une teinte.
Un autre problème concernant le développement du filtre en deux étapes distinctes est le
fait qu’il n’y avait aucune garantie que le modèle de modification des paramètres de la
caméra allait réagir identiquement au modèle logiciel. En effet, comme il a pu être
observé, il y a bien une différence entre les deux modèles, mais heureusement, la
différence est à l’avantage de la deuxième méthode, c’est-à-dire, à l’avantage du modèle
utile final. Concernant la détection des lignes blanches, il peut y avoir un facteur de
risque de ne pas les détecter si l’image à traiter est trop saturée. En effet, si les couleurs
perçues sont vraiment différentes de ce qui devrait être observé dans une situation idéale,
il se peut que, même en ajustant les paramètres de seuillage, il soit impossible de détecter
les lignes blanches. C’est pourquoi l’utilisation d’une balise blanche fixe par rapport à la
caméra aurait un net avantage dans ce cas puisqu’il ne serait pas nécessaire de la
localiser.
La dernière limitation, qui est présente dans l’algorithme développé, est le fait que les
différents paramètres du filtre de correction qui ont été calculés dépendent de
l’environnement. En effet, le système a été calibré pour avoir la meilleure réponse
possible dans un environnement défini. Dans le cas de ce projet, le but était de
développer un système de calibration automatique pour le système de vision des robots.
Comme ceux-ci évoluent dans un environnement défini, le système de calibration
fonctionne. Par contre, il faudrait procéder à une nouvelle calibration des paramètres pour
33
que le système fonctionne dans un autre environnement puisqu’il y aurait des contraintes
lumineuses différentes.
Amélioration possible
Il existe quelques améliorations qui pourraient être apportées à la solution développée
afin d’obtenir une robustesse encore plus grande et d’avoir des meilleurs temps de
réponse du filtre. Premièrement, l’algorithme de détection de ligne peut être amélioré. En
effet, la détection des lignes se fait selon des normes assez précises et, dans certains cas,
il se peut que des objets autres que des lignes soient trouvés par l’algorithme. Bien que
plusieurs méthodes aient été implémentées pour éviter ce problème, il y a toujours une
faible probabilité que ceci se produise. Dans le développement actuel, comme cette
probabilité est relativement faible, elle a été négligée puisque l’apport d’une seule
mauvaise détection sur la globalité du système est négligeable. Par contre, dans le cas où
l’image captée par le robot ne comporte pas de ligne, il se peut qu’une mauvaise
détection occasionne une dérivation des paramètres du système de vision. Une protection
supplémentaire qui pourrait être apportée au système est d’ajouter d’autres méthodes de
détection pour calibrer les paramètres de la caméra. Une option qui a été étudiée, mais
qui a été rejetée, serait à reconsidérer. En effet, l’utilisation d’une balise blanche sur le
robot pour effectuer la calibration serait une bonne option si un endroit convenable et
réglementaire peut être trouvé pour la placer.
Une autre amélioration possible du système serait d’optimiser le code pour qu’il
s’exécute plus rapidement. Dans le cadre de ce projet, la solution développée a été codée
34
sans se soucier des performances puisque le temps n’était pas un facteur qui influençait le
processus de calibration. Par contre, dans l’application du robot joueur de soccer, le
temps d’exécution du programme est important puisque celui-ci doit rouler en temps réel.
L’utilisation du filtre de correction lumineuse n’a pas besoin de s’effectuer en tout temps,
mais il doit quand même être optimisé pour ne pas venir entraver le travail des autres
algorithmes de contrôles du robot.
Retour sur le fonctionnement du système
Suite au développement de ce filtre de correction lumineuse, le système de vision de
l’équipe de robot de Robofoot va pouvoir être amélioré. En effet, l’ajout de l’algorithme
de calibration automatique des couleurs va permettre de rendre les robots beaucoup plus
performants. Premièrement, une calibration automatique du système de vision lorsque le
robot est mis dans un nouvel environnement va permettre de faire le travail
manuellement. Ce travail était auparavant fait à la main en utilisant une méthode itérative
de calibration et d’observation des résultats. Cette calibration manuelle pouvait prendre
beaucoup de temps et devait être refaite toutes les fois que les conditions lumineuses
changeaient. Avec cet algorithme, ce travail ne sera plus nécessaire. Deuxièmement, la
calibration automatique des couleurs va permettre aux robots de modifier en temps réel
les paramètres de la caméra dans l’éventualité où les conditions lumineuses de
l’environnement changeraient subitement. Ceci peut se produire si une partie du terrain
de jeu est éclairé par de la lumière naturelle provenant d’une fenêtre et une autre partie
est éclairée avec de l’éclairage artificiel. Ce cas se produit lors des compétitions et la
technique de calibration automatique développée dans ce projet va permettre d’apporter
35
une solution au problème. Donc, ce projet va être utile pour la société technique Robofoot
puisqu’il apporte une solution à différents problèmes concernant le système de vision de
leurs robots.
36
Bibliographie
DEITEL, DEITEL. Comment programmer en C++, 3e édition, Les éditions Reynald Goulet
inc., 2001, 1178p.
GOURDEAU, Richard. ELE4203 – Robotique : Introduction à la vision industrielle par
ordinateur, Département de génie électrique, École Polytechnique de Montréal,
novembre 2005.
KETILL, Vorgelegt. The Color and the Shape, Automatic On-line Color Calibration for
Autonomous Robots, Freien Universität Berlin, novembre 2005. [http://robocup.mi.fuberlin.de/docs/ketill.gunnarson.diploma-thesis.pdf]
LAUER, M., LANGE, S. et RIEDMILLER, M.. Calculating the Perfect Match: an Efficient
and Accurate Approach for Robot Self-Localization, Universität Osnabrück, 2005.
Levin, R., Levin, G.. Solving the color calibration problem of Martian lander images,
[http://mars.spherix.com/spie2003/SPIE_2003_Color_Paper.htm], 2003.
MARLEAU, Sylvain Système embarqué de localisation et de perception pour un robot
mobile, Département de génie électrique et informatique, École Polytechnique de
Montréal, Montréal, février 2006.
[http://robofoot.polymtl.ca/publications/memoire_smarleau.pdf]
MERKE, A., WELKER, S. et RIEDMILLER, M.. Line Based Robot Localization under
Natural Light Conditions, Universität Dortmund, Universität Osnabrück, 2004.
MSL Technical Committee. Middle Size Robot League Rules and Regulations for 2007.
janvier 2007.
37
SGI. Standard Template Library Programmer's Guide, [http://www.sgi.com/tech/stl/],
visité le 27 octobre 2007.
SLABAUGH, G. Writing out bitmap files to disk, in C,
[http://home.comcast.net/~greg_slabaugh/personal/c/bmpwrite.html], visité le 27 octobre
2007.
THE C++ RESOURCES NETWORK. C Library.
[http://www.cplusplus.com/reference/clibrary/], visité le 27 octobre 2007.
WIKIPEDIA. YUV color space, [http://en.wikipedia.org/wiki/Yuv], visité le 22 septembre
2007.
WIKIPEDIA. HSL color space, [http://en.wikipedia.org/wiki/HSV_color_space], visité le
22 septembre 2007.
38
Annexe
Contenu du CD-ROM :
•
Bibliographie : Documents utilisés comme référence dans ce projet.
•
Code :
benchmark_camera : Logiciel pour caractérisé une caméra
calibration_camera : Logiciel de calibration de la caméra. Comprend la
version logicielle et matérielle du filtre de correction lumineuse. C’est la
solution finale qui est intégrée dans un robot.
calibration_logiciel : Ensemble de logiciels utilisés dans le développement
de ce projet.
•
Image : Image de test utilisée dans ce rapport
•
Rapport : Ce document