Utilisation des cartes graphiques pour la vision par ordinateur

Transcription

1 Utilisation des cartes graphiques pour la vision par ordinateur RAPPORT DE STAGE Master 2 Recherche Spécialité Image, Information et Hypermédia par Emmanuel DELAPLACE Directeur : M. Patrice Dalle Professeur d université UPS, Toulouse Rapporteur : Mme Géraldine Morin Maître de conférences INP, Toulouse Encadrants : M. Alain Crouzil Maître de conférences UPS, Toulouse M. Benoît Bocquillon Doctorant UPS, Toulouse Institut de Recherche en Informatique de Toulouse UMR 5505

2

3 Résumé Ce rapport de stage vise à présenter l utilisation des techniques GPGPU pour la vision par ordinateur. Nous présentons tout ce qui permet d exploiter les ressources des cartes graphiques. Ensuite, nous donnons un état de l art sur tous les outils mathématiques qui ont été implémentés sur GPU. Ces outils pouvant être utile pour la vision par ordinateur. Puis, nous présentons un autre état de l art concernant l utilisation des GPU pour la vision par ordinateur. Enfin, nous présentons une implémentation sur GPU d un algorithme mise en correspondance stéréoscopique. Mots-clés : vision par ordinateur, mise en correspondance, carte graphique, GPU, GPGPU, programmation shader. i

4

5 iii «La seul arme que je tolère, c est le tire-bouchon» Jean Carmet

6

7 Remerciements «Un seul mot, usé, mais qui brille comme une vieille pièce de monnaie : merci!» Pablo Neruda Je serai court mais sincère. Je tiens à remercier toute l équipe TCI à travers Monsieur Patrice Dalle et particulièrement Monsieur Alain Crouzil, pour avoir été mon encadrant, et Monsieur Benoît Bocquillon pour avoir été mon coencadrant (et bien sûr, merci pour le café). Merci à Monsieur Mathias Paulin de l équipe VORTEX pour m avoir permis d utiliser les machines de l équipe. Merci les copains et aussi stagiaires : Guigui, Mathieu, Adrien, Julien, Virginie. Merci aux autres stagiaires, faiseurs de mots croisés et aussi amis : Mika, Aurore, François, Sylvain. Merci à DoodooFred, frère de toujours. Merci aux copains qui ne sont pas stagiaires : Théo, Lili, Steph, Olivier, Mike. Merci la famille. Je remercie bien évidemment ceux qui doivent l être et que j oublie.

8

9 Table des matières 1 Introduction Vision par ordinateur Carte graphique Objectifs du stage Programmation du processeur graphique Pipeline graphique DirectX 9 et OpenGL Pipeline graphique DirectX 10 et OpenGL Éléments programmables des cartes graphiques Carte graphique avec pipeline DirectX 9 et Opengl Carte graphique avec pipeline DirectX 10 et OpenGL Programmation shader Introduction Shade trees RenderMan The PixelFlow shading system SSL DirectX HLSL et GLSL Cg RenderMonkey Ashli PyGPU Scout CGiS Bibliothèques : Accelerator, Glift, Brahma Bibliothèques pour la vision par ordinateur : OpenVIDIA, Flog, GPUCV CTM CUDA Résumé des outils pour la programmation GPU Exemple de programmation shader en GLSL Programmation GPGPU Concept Brook et Sh Core Image et Quartz Composer vii

10 3 Utilisation de la carte graphique en vision par ordinateur Introduction Outils mathémathiques sur GPU Opérations sur les flottants Multiplication matricielle Calcul matriciel Résolution d une équation ou d un système d équations LCP Résolution des équations d Euler Diagramme de Voronoï Filtrage Ondelettes Tableau récapitulatif Utilisation de la carte graphique en vision par ordinateur Mise en correspondance et calcul de la carte de disparités Reconstruction 3D à partir d images Mosaïque d images Transformation d image Segmentation d image Détection de contours Reconnaissance d objet Analyse du mouvement et suivi d objet Tableau récapitulatif Mise en correspondance sur GPU Mise en correspondance par corrélation Introduction Mesure de corrélation Mise en correspondance sur GPU en utilisant le langage GLSL Quelques indications sur le langage GLSL Algorithme de mise en correspondance avec GLSL Comparaison CPU/GPU en termes de performance Conclusion 49 viii

11 Table des figures 1.1 Dispositif pour la vision par ordinateur Une carte graphique Pipeline graphique DirectX 9 et OpenGl Pipeline graphique DirectX 10 et OpenGL Pipeline graphique programmable DirectX 9 et OpenGL Pipeline graphique programmable DirectX 10 et OpenGL Architecture PixelFlow (extrait de [Molnar 92]) Structure d un programme GLSL Cg et les API graphique Read Back Copy to Texture Render to Texture Copy to VBO Render to VBO G80 : render to Stream Buffer GPGPU : utilisation de plusieurs noyaux Algorithme ORDP Plans glissants Reconstruction du relief avec un modèle déformable Algorithme 2+1 phase-shifting Algorithme VideoOrbits Correction d une image Segmentation d image SIFT sur GPU SIFT sur GPU Mise en correspondance par corrélation avec une zone de recherche Texture en GLSL Comparatif des cartes graphiques présentent sur le marché RapidMind ix

12

13 Liste des tableaux 2.1 GPUCV Outils pour la programmation GPU Bibliothèques utilisant le GPU Méthodes de programmation GPGPU Outils mathématiques sur GPU Utilisation de la carte graphique en vision par ordinateur Mesures de corrélation croisée Types vecteurs en GLSL et leurs accesseurs Fonctions GLSL prédéfinies Temps de calcul en secondes pour une mise en correspondance stéréoscopique xi

14

15 Liste des Algorithmes 1 Mise en correspondance par corrélation Mise en correspondance avec GLSL : algorithme pour le fichier main.c Mise en correspondance avec GLSL : algorithme pour le fichier fragment.frag Mise en correspondance avec GLSL : algorithme pour la mesure NCC Mise en correspondance avec GLSL : algorithme pour la mesure ZNCC Mise en correspondance stéréoroscopique avec le CPU xiii

16

17 Chapitre 1 Introduction L utilisation de l informatique dans le monde qui nous entoure est devenue banale. L homme essaie d inculquer à des machines une vision humaine et même une vision plus performante pour permettre à une machine de réaliser ce que l humain ne peut pas faire. Dans le monde de la robotique, de la médecine, de la domotique ou même du ludique, la vision est un domaine de réalisation important. Étant donné que notre vision se fait en «temps réel», c est-à-dire de façon quasi-instantanée, il est alors nécessaire d essayer d obtenir un traitement des images le plus rapide possible. Les organes des machines qui nous permettent de traiter ces images sont un ou plusieurs processeurs et une ou plusieurs cartes graphiques. Le sujet de ce rapport concilie donc la vision par ordinateur et l utilisation des cartes graphiques et des processeurs pour obtenir une amélioration des temps de traitement des images. 1.1 Vision par ordinateur L objectif de la vision par ordinateur, appelée aussi vision artificielle, est de reproduire la vision humaine à l aide d un ordinateur. Le dispositif général pour la vision par ordinateur peut être illustré par la figure 1.1. Fig. 1.1 Dispositif pour la vision par ordinateur. Les éléments importants sont donc : la scène : elle correspond à ce qui est vu ; c est l environnement qui est perçu ; le capteur : c est le dispositif matériel qui permet d obtenir les images. Par analogie, c est ce qui correspond à l œil humain. Le capteur peut être une ou plusieurs caméras, un ou plusieurs 1

18 2 Chapitre 1. Introduction appareils photographiques, etc. l unité de traitement : c est là où est réalisé le traitement des données. C est dans cette unité de traitement que se trouve la carte graphique. 1.2 Carte graphique Fig. 1.2 Une carte graphique. La carte graphique est un composant d une unité de traitement qui permet de convertir des données numériques en données graphiques pouvant être affichées sur un périphérique de sortie (écran, rétroprojecteur, etc.). La carte graphique possède les composants suivants : le processeur graphique : il est aussi appelé GPU (Graphical Processing Unit), c est le cœur de la carte graphique. C est là où sera réalisé tout le traitement d une image. Il comporte le pipeline graphique mais aussi des unités de calcul arithmétiques et logiques ; la mémoire vidéo (frame buffer) : c est la mémoire qui permet de stocker l image avant qu elle ne soit affichée ; le RAMDAC : il correspond aux initiales de Random Access Memory Digital-Analog Converter. Ce composant permet de transformer les données numériques d une image, stockée dans la mémoire vidéo, en signal analogique pour être affiché ; le bios vidéo : cette mémoire contient des informations propres à la carte graphique ; le bus : c est le connecteur qui permet de relier la carte graphique à une carte mère. Le bus AGP était un bus créé à cet effet, mais il est aujourd hui remplacé par le bus PCI Express ; les connectiques : elles permettent de relier la carte graphique à un écran, à un téléviseur, etc. 1.3 Objectifs du stage On va donc s intéresser à l utilisation des GPU dans le domaine de la vision par ordinateur. Les principaux objectifs de ce travail de recherche sont donc les suivants : effectuer un état de l art sur la programmation des GPU ; effectuer un état de l art sur les outils mathématiques qui ont été implémentés sur GPU et qui peuvent servir à la vision par ordinateur ; effectuer un état de l art sur l utilisation des GPU pour la vision par ordinateur ; proposer l implémentation d un algorithme de vision par ordinateur permettant de tirer le meilleur parti du parallélisme GPU/CPU.

19 1.3. Objectifs du stage 3 Le CPU (Central Processor Unit) est le processeur central d un ordinateur. Il permet d effectuer divers traitements et de gérer les ressources d un ordinateur.

20

21 Chapitre 2 Programmation du processeur graphique 2.1 Pipeline graphique DirectX 9 et OpenGL 2.0 DirectX et OpenGL sont des API graphiques. Une API (Application Programming Interface) définit la manière dont un programme peut communiquer avec d autres programmes. OpenGL et DirectX offrent une spécification qui permet l affichage d une scène 3D. Le pipeline graphique est la représentation d une suite de plusieurs unités de traitement ayant pour but d afficher une scène 3D à l écran (voir figure 2.1). Les constructeurs de cartes graphiques implémentent physiquement le pipeline graphique. Vertex Culling Fragment Tests Frame processor Clipping processor Traitements buffer Assemblage Rasterization Textures Fig. 2.1 Pipeline graphique DirectX 9 et OpenGl 2.0. Les éléments qui constituent le pipeline sont : vertex processor : il reçoit une série de coordonnées qui correspond au sommets (vertices) d une scène. Le vertex processor exerce une série de transformations sur les coordonnées des sommets (changements de repère) et c est dans cette unité que va être calculé le niveau l éclairage de chaque sommet (vertex) ; culling : cette opération permet d éliminer certains polygones d une scène qui sont cachés par d autres polygones (back-face culling) et de supprimer des objets (ensemble de polygones) d une scène qui sont cachés par un autre objet (occlusion culling) ; clipping : cette opération permet d éliminer les parties de la scène qui ne sont pas dans le cône de vision ; assemblage : c est l assemblage des sommets pour former des primitives (segments, polygones, etc.) ; rasterization : cette opération construit une image 2D de la scène du point de vue de la caméra. Les éléments de la scène sont projetés sur l image de la caméra, puis discrétisés pour former les fragments (futurs pixels). L éclairage des sommets (projetés et discrétisés sur l image) est extrapolé aux autres fragments ; 5

22 6 Chapitre 2. Programmation du processeur graphique pixel processor ou fragment processor : le fragment processor a pour rôle d appliquer les textures sur chaque fragment de l image. On associe une couleur à chaque fragment en prenant en compte l éclairement calculé précédemment et la couleur du texel à appliquer ; tests et traitements : dans cette unité du pipeline, on réalise divers tests comme le test alpha (transparence), le test de profondeur, le test du stencil, etc. ; on trouve aussi le traitement du brouillard, l alpha blending, etc. ; frame buffer : c est la mémoire vidéo ; texture : une texture est une image qui a vocation à être «collée» sur un polygone. 2.2 Pipeline graphique DirectX 10 et OpenGL 2.1 Depuis novembre 2006, une nouvelle architecture logique (voir figure 2.2) est apparue [Blythe 06]. Elle reprend l architecture logique du pipeline graphique DirectX 9 et Opengl 2.0 avec l ajout de l unité geometry processor. Cette unité permet l ajout de sommet dans un maillage. Vertex processor Assemblage Geometry processor Culling Clipping Fragment processor Tests Traitements Frame buffer Rasterization Textures Fig. 2.2 Pipeline graphique DirectX 10 et OpenGL Éléments programmables des cartes graphiques Carte graphique avec pipeline DirectX 9 et Opengl 2.0 Aujourd hui, il est possible de programmer les cartes graphiques. L idée est d injecter des programmes dans les différentes parties du pipeline graphique. On écrit le code de ces programmes que l on appelle vertex shader et fragment shader. Ces programmes, sont exécutés respectivement par le vertex processor et le fragment processor (voir figure 2.3). Vertex shader Culling Clipping Fragment shader Tests Traitements Frame buffer Assemblage Rasterization Textures Fig. 2.3 Pipeline graphique programmable DirectX 9 et OpenGL 2.0.

23 2.4. Programmation shader Carte graphique avec pipeline DirectX 10 et OpenGL 2.1 L idée reste la même que celle du pipeline DirectX 9 et OpenGL 2.0 auquel est rajouté le geometry processor qui est, lui aussi, programmable (geometry shader) (voir figure 2.4). Vertex Assemblage Geometry shader shader Culling Clipping Rasterization Fragment shader Tests Traitements Frame buffer Textures Fig. 2.4 Pipeline graphique programmable DirectX 10 et OpenGL Programmation shader Introduction De nombreux langages de programmation shader ont été développés [McCool 04a, Mitrovíc 03] [Proudfoot 01, Owens 05] pour la réalisation de scène 3D. Le but de ces langages est de : permettre de faire un traitement particulier d une surface pour la rendre réaliste ; permettre de créer des procédures pour traiter des surfaces et permettre d éliminer des effets indésirables ; rendre la texture directement applicable sur une surface ; prendre en compte le «temps réel» : la couleur d un point d une surface peut changer en fonction du temps, de la distance et de l angle de la vue Shade trees L idée des langages shader vient de Robert L. Cook [Cook 84]. Il existait des modèles qui permettaient de représenter les ombres. Ce sont les modèles de Gouraud, Phong, Blinn, Turner, etc. Il a proposé un nouveau modèle pour le calcul des ombres en utilisant une structure arborescente, ainsi qu un langage pour décrire ce nouveau modèle. Avant les travaux de Cook, le calcul des ombres se faisait en deux étapes : on déterminait les paramètres qui modélisent l apparence d une surface ; on utilisait ces paramètres avec une fonction qui permettait de créer les ombres et qui était prédéfinie. L idée de Cook est de supprimer cette fonction. Il représente, par un nœud d un arbre, des opérations élémentaires (produit scalaire, normalisation de vecteur, etc.). Le calcul de l ombre en un point se fait en parcourant l arbre en allant des feuilles à la racine. La valeur finale du point se trouve donc à la racine de l arbre.

24 8 Chapitre 2. Programmation du processeur graphique RenderMan RenderMan a été développé par la société Pixar [Pixar 07a]. Son utilisation commence avec le film Young Sherlock Holmes en RenderMan [Pixar 07b, Pixar 05] est composé de : une interface (The RenderMan Interface), qui permet la communication entre un logiciel de modélisation et un programme de rendu 3D ; un langage shader (The RenderMan Shading Language) qui permet d implémenter les fonctionnalités définies par l interface. Le langage de programmation RenderMan ressemble beaucoup au langage C-ANSI. Ce langage propose la programmation de trois types de shader : un shader qui permet de définir la couleur d un point d une surface en fonction des sources lumineuses ; un deuxième shader qui permet de définir la couleur d un point d une surface en fonction des propriétés de cette surface ; un dernier type de shader qui permet de gérer la couleur d une lumière à travers un volume. L interface ne prend pas en compte la notion de rendu «temps réel». Mais aujourd hui, grâce à la technologie, on peut tout à fait faire du «temps réel» avec RenderMan The PixelFlow shading system Dans les années 1990, on voit l apparition d un système appelé PixelFlow [Olano 98, Molnar 92]. Ce système avait pour objectif d être «temps réel». Il utilise l API OpenGL. L idée avec PixelFlow est de décomposer une image (opération appelée «tiling») et de traiter les différentes décompositions en parallèle. On a donc une architecture du système basée sur la parallélisation du traitement (voir figure 2.5). Fig. 2.5 Architecture PixelFlow (extrait de [Molnar 92]). Avec ce système, un langage shader a été créé : the pfman shading language. Ce langage de programmation est proche de la syntaxe du C et il est également très proche de RenderMan.

25 2.4. Programmation shader SSL Le langage SSL (Stanford Shading Language) est à l origine des autres langages shader qui l ont suivi. Il a été développé à partir de La première version était très proche du langage Lisp mais, aujourd hui, il ressemble au C-ANSI et utilise l API OpenGL [Mark 01]. Le langage permet de développer deux shaders : un qui gère les sources lumineuses et un autre qui gère les surfaces. Ces deux shaders sont alors compilés dans un autre langage intermédiaire produisant des pipeline programs. Ces pipeline programs sont de trois sortes : ceux qui opèrent sur les sommets, ceux qui opèrent sur les polygones et ceux qui opèrent sur les applications des textures. Ces pipeline programs seront alors compilés en code de bas niveau pour le CPU ou le GPU. Cette décomposition en pipeline programs et à l origine de la programmation actuelle DirectX HLSL et GLSL DirectX HLSL (High-Level Shading Language) et GLSL (OpenGl Shading Language) sont des langages shaders qui ont été développés par Microsoft et 3D Lab pour HLSL et l ARB (Architecture Review Board) pour GLSL. Ce dernier était l organisme qui s occupait du standard OpenGL pour GLSL (aujourd hui, c est The Khronos group). Ces deux langages utilisent soit l API graphique DirectX, pour HLSL, et OpenGL pour GLSL. Ces deux langages sont donc indépendants de l architecture de la carte graphique. Il faut donc juste que la carte graphique supporte certaines extensions. Ces deux langages utilisent le pipeline graphique que nous avons présenté précédemment. On crée donc deux types de shader : le vertex shader et le pixel shader (voir figure 2.6). Pour GLSL [Brumme 03, Rost 04], la carte graphique doit supporter quatre extensions qui sont les suivantes : GL ARB shading language, GL ARB shader objects, GL ARB vertex shader et GL ARB fragment shader. Depuis l API graphique OpenGL 2.0, ces extensions font parties de la spécification OpenGL. Donc, une carte graphique supportant l API OpenGL 2.0 peut-être programmée avec GLSL. La syntaxe de GLSL est proche du langage C. Fig. 2.6 Structure d un programme GLSL (extrait de [Ananth 07b]).

26 10 Chapitre 2. Programmation du processeur graphique Pour DirectX HLSL [Mitchell 05, McCool 03a], la carte graphique doit supporter l API graphique DirectX 9. La syntaxe de ce langage est proche du C-ANSI. Il n est pas très utilisé du fait que NVIDIA et Microsoft se sont associés pour créer le langage shader Cg Cg Le langage Cg (C for graphics) a été développé en collaboration avec la société NVIDIA et Microsoft [Mark 03, NVIDIA 07a, Fernando 03]. La syntaxe de Cg est proche du langage de programmation C/C++. Ce langage permet une programmation quelle que soit l API graphique, DirectX ou OpenGL (voir figure 2.7). Il est donc intéressant du fait de sa portabilité. Olivier Nocent [Nocent 07] a écrit des classes en C++, qui utilisent Cg, pour simplifier l écriture des shaders : c est la bibliothèque GLOOSE (Object Oriented Shading Environment for OpenGL). Fig. 2.7 Le compilateur de Cg adapte le code selon l API utilisée (extrait de [Fernando 03]) RenderMonkey RenderMonkey a été développé par la société ATI et par 3D Lab. Il a été proposé à la communauté des développeurs en 2002 [ATI 07]. L utilisation de RenderMonkey est indépendante de l API graphique. RenderMonkey est un environnement de programmation (IDE) avec une interface graphique pour l utilisateur. RenderMonkey se présente donc plutôt comme un éditeur de shader qui permet de créer des shaders GLSL et HLSL Ashli Ashli (Advanced Shading Language Interface) a été aussi développé par ATI [Bleiweiss 03]. Comme RenderMan, il présente une interface qui permet de faire le lien entre une application et un environnement de création 3D. Ashli propose aussi une API qui permet son utilisation dans du code C/C PyGPU PyGPU est un langage de programmation shader basé sur le langage Python [Lejdfors 05] et OpenGL. PyGPU offre des fonctions sur les images qui permettent de travailler dans plusieurs espaces de couleur (RGB, YUV, gray scale, CMYK, etc.). Avec ce langage, on peut spécifier les fonctions Python qui doivent être exécutées par le GPU et celles qui doivent être exécutées par le CPU.

27 2.4. Programmation shader Scout Scout est un langage de programmation conçu pour la visualisation et l analyse de données [McCormick 04]. Il utilise l API OpenGL. Ce langage ne semble pas être très utilisé CGiS Le langage CGiS (Computer Graphics in Scientific programming) [Fritz 04] reprend l idée de la parallélisation du traitement des données et du concept de flux et de noyau de (voir 2.5.2). Lorsque l on programme avec CGiS on définit trois parties : Code, Control et Interface. La partie Code correspond à la déclaration des fonctions à exécuter sur une donnée. La partie Control permet de créer un tableau de toutes les données à traiter en parallèle. Enfin, la partie Interface permet de déclarer les données. Ce langage utilise Cg et C Bibliothèques : Accelerator, Glift, Brahma Accelerator est une bibliothèque développée par Microsoft. Elle permet de créer des programmes qui traitent des données en parallèle [Tarditi 05]. Glift est une bibliothèque dont le but est de faciliter la programmation shader. Elle utilise le C++ et Cg [Lefohn 06]. Brahma est une bibliothèque pour les plateformes.net qui permet d exploiter les ressources GPU [Ananth 07a] Bibliothèques pour la vision par ordinateur : OpenVIDIA, Flog, GPUCV La bibliothèque OpenVIDIA a pour objectif de permettre d utiliser une ou plusieurs cartes graphiques pour pouvoir faire du traitement d images en «temps réel»[openvidia 07]. Cette bibliothèque est basée sur le langage C/C++ et l API OpenGL. Cette bibliothèque propose un détecteur de contours (Canny) et de coin, des outils pour le suivi : de couleur, de coin, de peau, des outils de correction de contraste et de luminosité ainsi que l implémentation de VideoOrbits (algorithme pour créer une mosaïque d images). Flog (Filter Library On GPU ) est une bibliothèque qui permet d implémenter l application de filtre sur des images en utilisant le GPU [Chiara 04]. Cette bibliothèque génère du code source Cg. La bibliothèque GPUCV correspond à l implémentation de la bibliothèque OpenCV sur GPU [Farrugia 06]. Elle utilise le langage GLSL et améliore les performances, en terme de temps d exécution, d OpenCV (voir table 2.1). OpenCV GPU 3 3 érosion 24 ms 3.0 ms 5 5 érosion 31 ms 8.5 ms RGB to XYZ 11 ms 0.6 ms RGB to HSV 18 ms 1.7 ms Binary threshold 1.0 ms 0.7 ms Tab. 2.1 Comparaison entre OpenCV et GPUCV pour une image de (extrait de [Farrugia 06]).

28 12 Chapitre 2. Programmation du processeur graphique CTM CTM (Close To Metal) [Segal 06], anciennement appelé DPVM (Data Parallel Virtual Machine), permet un accès de bas niveau à la carte graphique, c est-à-dire sans passer par l API graphique. CTM est développé par ATI/AMD. CTM est composé de trois parties différentes : la première est la Command Processor qui permet de gérer les commandes envoyées par une application ; la partie Memory Controller permet le contrôle de la mémoire de la carte graphique ; la dernière partie est la Data Parallel Array, qui est chargée de traiter les données en mémoire. Le traitement à réaliser est écrit dans un pseudo-langage d assemblage CUDA CUDA (CompUte Driver API ) n est utilisable qu avec des cartes graphiques NVIDIA GeForce 8 [NVIDIA 07b]. Ce langage permet d accéder au GPU sans passer par l intermédiaire des API graphiques. CUDA propose un SDK (Software Development Kit) qui s utilise avec le langage C. Notons qu avec CUDA il existe deux bibliothèques : CUBLAS (CompUte Basic Linear Algebra Subprogram) et CUFFT (CompUte Fast Fourier Transform). CUBLAS correspond à la bibliothèque BLAS (Basic Linear Algebra Subprogram). CUFFT est une bibliothèque qui implémente des algorithmes de la transformée de Fourier Résumé des outils pour la programmation GPU Le tableau 2.2 donne un aperçu global des outils qui permettent la programmation des cartes graphiques. Les langages RenderMan, GLSL, HLSL et Cg sont actuellement les plus utilisés. Le tableau 2.3 présente les bibliothèques qui font appel au GPU. Ils sont peu utilisés sauf OpenVidia. API graphique Syntaxe Référence Shade trees [Cook 84] RenderMan OpenGL/DirectX C [Pixar 07b] [Pixar 05] PixelFlow OpenGL C [Olano 98] RTSL OpenGL C [Mark 01] HLSL DirectX C [Mitchell 05] [McCool 03a] GLSL OpenGL C [Brumme 03][Rost 04] Cg OpenGL/DirectX C/C++ [Mark 03] [NVIDIA 07a] RenderMonKey OpenGL/DirectX [ATI 07] Ashli OpenGL/DirectX C [Bleiweiss 03] PyGPU OpenGL Python [Lejdfors 05] Scout OpenGL [McCormick 04] CGiS OpenGL/DirectX C++/Cg [Fritz 04] CTM Assembleur [Segal 06] CUDA C [NVIDIA 07b] Tab. 2.2 Outils pour la programmation GPU.

29 2.4. Programmation shader 13 Nom Langage Référence Bibliothèques pour la vision OpenVIDIA C/C++ [OpenVIDIA 07] par ordinateur Flog C,Cg [Chiara 04] GPUCV C/C++ [Farrugia 06] Autres bibliothèques Accelerator C# [Tarditi 05] Glift C++ [Lefohn 06] Brahma.NET [Ananth 07a] Tab. 2.3 Bibliothèques utilisant le GPU Exemple de programmation shader en GLSL L exemple ci-dessous est tiré d un tutoriel disponible sur le Web [Ananth 07b]. Ce programme donne l image, du point de vue de la caméra, d une théière qui a une couleur unie et qui tourne. On a trois fichiers : minimal.ver, minimal.fra et main.c. Le résultat s affiche dans une fenêtre. Le fichier minimal.ver contient le code qui sera exécuté par le vertex processor : void main() { /* Transforme les coordonnées des sommets exprimées dans le repère scène, / en coordonnées exprimées dans le repère caméra */ gl_position = gl_modelviewprojectionmatrix * gl_vertex; } Le fichier minimal.fra contient le code qui sera exécuté par le fragment processor : void main() { /* On donne la couleur voulue aux fragments de la théière */ gl_fragcolor = vec4(0.4,0.4,0.8,1.0); }

30 14 Chapitre 2. Programmation du processeur graphique Le fichier main.c contient diverses fonctions. La fonction setshaders() permet l initialisation des shaders. void setshaders() { char *vs = NULL,*fs = NULL; /* Création des shaders */ v = glcreateshader(gl_vertex_shader); f = glcreateshader(gl_fragment_shader); /* Récupération des codes sources des shaders vertex et fragment */ vs = textfileread("minimal.vert"); fs = textfileread("minimal.frag"); const char * vv = vs; const char * ff = fs; /* Attachement des codes sources */ glshadersource(v, 1, \&vv, NULL); glshadersource(f, 1, \&ff, NULL); free(vs); free(fs); /* Compilation des shaders */ glcompileshader(v); glcompileshader(f); /* Création d un programme. Un programme contient au plus un vertex shader / et un fragment shader */ p = glcreateprogram(); /* Attachement des shaders au programme */ glattachshader(p,v); glattachshader(p,f); /* Edition des liens */ gllinkprogram(p); /* Fonction qui permet l utilisation du programme */ gluseprogram(p); }

31 2.4. Programmation shader 15 La fonction renderscene() qui trace la théière : void renderscene(void){ /* Initialisation de bit de variable OpenGL */ glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); /* Initialisation de la matrice de transformation */ glloadidentity(); /* Placemment de la caméra */ glulookat(0.0,0.0,5.0,0.0,0.0,-1.0,0.0f,1.0f,0.0f); /* Placement d une source d éclairage */ gllightfv(gl_light0, GL_POSITION, lpos); /* On fait tourner la théière selon un pas a */ glrotatef(a,0,1,1); /* Traçage de la théière */ glutsolidteapot(1); /* Incrémentation du pas de rotation */ a+=0.1; glutswapbuffers(); }

32 16 Chapitre 2. Programmation du processeur graphique La fonction main() : int main(int argc, char **argv) { /* Création de la fen^etre d affichage */ glutinit(&argc, argv); glutinitdisplaymode(glut_depth GLUT_DOUBLE GLUT_RGBA); glutinitwindowposition(100,100); glutinitwindowsize(320,320); glutcreatewindow("exemple simple"); /* Définition de la fonction qui gère le tracé de la scène */ glutidlefunc(renderscene); /* Activation du test de profondeur, affectation de la / couleur blanc au fond de la scène et activation du / back-face culling */ glenable(gl_depth_test); glclearcolor(1.0,1.0,1.0,1.0); glenable(gl_cull_face); /* Initialisation de GLEW (bibliothèque qui permet la gestion / des extensions OpenGL */ glewinit(); /* Initialisation des shaders */ setshaders(); /* Exécution */ glutmainloop(); return 0; } 2.5 Programmation GPGPU Concept La programmation GPGPU (General-Purpose Computation Using Graphics Hardware) [GPGPU 07] consiste à utiliser les différents éléments du GPU pour pouvoir arriver à un résultat recheché. Du point de vue du développeur, la programmation avec la carte graphique revient à traiter un flux de données qui passe par le pipeline graphique. Il peut programmer le vertex, le fragment et le geometry processor. Pour cela, plusieurs méthodes peuvent être mises en œuvre. La première façon de procéder est la méthode du Read Back (voir figure 2.8) : le CPU envoie les données au pipeline qui sont traitées par les différentes unités programmées. Le CPU peut alors récupérer l image stockée dans le frame buffer.

33 2.5. Programmation GPGPU 17 CPU Vertex processor Fragment processor Frame buffer Fig. 2.8 Read Back. La deuxième façon de faire est d utiliser les textures (Copy to Texture) ce qui permet d éviter de repasser par le CPU lors de la réalisation de plusieurs passes (voir figure 2.9). De plus, le débit des données, à la sortie du frame buffer, est supérieur au débit que le bus peut assurer. Le bus est alors un «goulot d étranglement». L image contenue dans le frame buffer est copiée dans l unité de texture. Cette possibilité existe depuis les cartes graphiques de type NV40 (NVIDIA GeForce 6) et R520 (ATI X1300), donc depuis les années Notons que l utilisation du vertex processor est alors «courtcircuitée»lors de l utilisation en plusieurs passes du fragment processor. CPU Vertex processor Fragment processor Frame buffer Textures Fig. 2.9 Copy to Texture. On peut aussi éviter de passer par le frame buffer en copiant l image, restituée par le fragment processor, directement dans une texture : c est la méthode du Render to Texture (voir figure 2.10). Il devient inutile de passer par le frame buffer si on ne veut pas afficher l image à l écran. CPU Vertex processor Fragment processor Textures Fig Render to Texture. Une autre méthode est d utiliser le VBO (vertex buffer object) (voir figure 2.11). Le VBO est très similaire au vertex array mais avec plus de modes de transfert des données. Un vertex array est le tableau des sommets qui sera traité par le vertex processor. Cette méthode permet de réutiliser le vertex processor.

34 18 Chapitre 2. Programmation du processeur graphique CPU Vertex processor Fragment processor VBO Textures Fig Copy to VBO. On peut copier directement l image issue du fragment processor dans le VBO : c est la méthode du Render to VBO (voir figure 2.12). Cette méthode permet d éviter le transfert des données : fragment processor vers textures, puis textures vers VBO. CPU Vertex processor Fragment processor VBO Fig Render to VBO. Avec l arrivée de la carte graphique GeForce 8 de NVIDIA, on a donc le geometry shader en plus. On peut récupérer les données traitées juste après le geometry processor. CPU Vertex processor Geometry processor Fragment processor Stream buffer Fig G80 : render to Stream Buffer. Le tableau 2.4 donne l utilisation des vertex shader, fragment shader, textures, VBO et du frame buffer selon les méthodes qui ont été presentées.

35 2.5. Programmation GPGPU 19 Méthodes Plusieurs Vertex Geometry Fragment Textures VBO Frame Stream passes processor processor processor buffer buffer Read non x x x Back Copy oui x x x to Texture Render oui x x to Texture Copy oui x x x x to VBO Render oui x x x to VBO Render to oui x x x x Stream Buffer Tab. 2.4 Méthodes de programmation GPGPU. La programmation GPGPU offre le concept de flux (stream) et de noyau (kernel) : le Stream Computing Model. Le flux correspond à l ensemble des données qui vont être traitées. Les données du flux sont indépendantes entre elles. Le noyau correspond au traitement à appliquer à chaque donnée. Pour parvenir au résultat recherché, il est souvent nécessaire d utiliser plusieurs noyaux (voir figure 2.14). Les données vont être chargées souvent dans une texture ou dans le VBO. Le noyau sera exécuté par le fragment processor et le vertex processor. Données Noyaux 1 Données intermédiaires Noyaux n Résultat Fig GPGPU : utilisation de plusieurs noyaux Brook et Sh Brook et Sh sont deux métalangages de programmation. Ils permettent une programmation sans avoir une connaissance de l architecture logique des GPU, et utilisent les concepts de noyau et de flux. Brook [Buck 04] est un métalangage du langage C. Sh a été conçu par Michael MCool à l université de Waterloo [Sh 07, McCool 04b]. Il est basé sur le langage C++. L avantage de ces langages est de pouvoir programmer sans connaître la structure d un pipeline graphique. leur inconvénient est de rajouter encore une «couche» : Brook ou Sh HLSL ou GLSL DirectX ou OpenGL pilote de la carte graphique. Les performances obtenues ne sont donc pas optimales.

36 20 Chapitre 2. Programmation du processeur graphique Core Image et Quartz Composer Core Image [Apple 07] est une bibliothèque disponible sur la plateforme MAC OS X tiger. Elle fournie trois classes : ClImage, ClKernel, ClFilter. La classe ClImage permet de manipuler les images. Ces images seront traitées par un ou plusieurs noyaux contenus dans la classe ClFilter. Un noyau est declaré grâce à la classe ClKernel. Core image analyse les différents noyaux et les exécute selon l ordre le moins coûteux. Quartz Composer est un logiciel avec une interface graphique qui permet de créer des noyaux. Ce logiciel utilise Core Image.

37 Chapitre 3 Utilisation de la carte graphique en vision par ordinateur 3.1 Introduction Ce chapitre a deux objectifs. Le premier est de répertorier les outils mathématiques qui ont été implémentés sur GPU. Le deuxième est de dresser un état de l art de l utilisation du GPU pour la vision par ordinateur. Pour les outils mathématiques sur GPU, on peut établir les catégories suivantes : opérations sur les flottants ; multiplication matricielle ; calcul matriciel ; résolution d une équation ou d un système d équations ; LCP (Linear Complementarity Problem) ; résolution des équations d Euler ; diagramme de Voronoï ; convolution ; ondellettes. De même, concernant les outils de vision faisant appel au GPU, on peut définir les catégories suivantes : mise en correspondance, calcul de la carte de disparités ; reconstruction 3D à partir d images ; création de mosaïque d images ; transformation d image ; segmentation d image ; détection de contour ; reconnaissance d objet ; analyse du mouvement et suivi d objet. 3.2 Outils mathémathiques sur GPU Opérations sur les flottants Guillaume de Gracca et David Defou [Gracca 06] proposent l implémentation, sur GPU, d opérations flottantes en utilisant Brook. Ils utilisent les théorèmes de «split» et de multiplication de Dekker [Dekker 72] ainsi que le théorème de Knuth [Knuth 98] pour l addition. Ils implémentent aussi les algorithmes proposés par Lauter [Lauter 05] pour les opérations d addition et de multiplication. 21

38 22 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur Multiplication matricielle E. Scoot Larsen et David McAllister [Larsen 01] proposent une implémentation sur GPU de la multiplication matricielle. Les matrices sont chargées en mémoire comme des textures. Par exemple, soient : A = [ ] et B = [ ] [ 19 22, on a AB = Les auteurs utilisent une méthode par tranches (slice). La première tranche est obtenue par la multiplication terme-à-terme des éléments de deux matrices (multiplication de Hadamard). Cette opération se réalise sur GPU. La première matrice est obtenue par duplication de la première colonne de A et la duplication de la première ligne de B. On obtient ainsi la première tranche : première tranche = [ ] [ ] = [ On calcule de même la deuxième tranche en prenant la seconde colonne de A et la seconde ligne de B. On obtient : [ ] deuxième tranche = La multiplication matricielle de A par B est alors obtenue en additionnant les deux tranches, opération réalisée sur GPU. [ ] [ ] [ ] AB = + = L utilisation de cette méthode nécessite plusieurs passes dans le GPU. Dans [Fatahalian 04], les auteurs implémentent la méthode précédente, mais utilisent les canaux des textures (rouge, vert, bleu, alpha) pour faire de la multiplication matricielle par bloc. Dans [Hall 03], les auteurs proposent une implémentation de la multiplication matricielle «classique» sur GPU. On a donc une seul passe dans le GPU. Ils améliorent l algorithme en calculant le produit matriciel par bloc. Ils utilisent les canaux des textures (rouge, vert, bleu, alpha) Calcul matriciel Ádám Moravánszky [Moravánszky 03] utilise DirectX 9 pour implémenter sur GPU diverses opérations matricielles. Les opérations sont les suivantes : assignation : chargement d une matrice sur GPU ; addition de deux matrices : A = B + C ; multiplication deux matrices : A = BC ; multiplication transposée de deux matrices : A = C T B ; opérateur dot : opérateur qui correspond à un produit scalaire : dot(a, b) = a T b ; norme au carré d un vecteur ; multiplication de matrice par un scalaire ; addition des éléments d une matrice au produit scalaire ; élément maximun d une matrice ; élément minimum d une matrice ; opérateur mad (multiply add) : A = A + Bc ou A = B + Cd ou A = A + BC ; opérateur madad : A = B + (C + D)D. Dans [Krüger 03], les deux auteurs proposent aussi l implémentation sur GPU de divers opérateurs sur les vecteurs ainsi que sur les matrices : addition, multiplication, maximum, minimum, etc. ]. ]

39 3.2. Outils mathémathiques sur GPU Résolution d une équation ou d un système d équations Nico Galoppo, Naga K. Govindaraju, Michael Henson et Dinesh Manocha [Galoppo 05] proposent une implémentation sur GPU de la décomposition LU d une matrice ainsi qu une résolution d un système linéaire de la forme Ax = b par la méthode de Gauss-Jordan. Une décomposition LU consiste à mettre une matrice A sous la forme du produit de deux matrices de forme bien particulière. La première matrice L, (pour low), est une matrice triangulaire inférieure à diagonale unité. La deuxième U est une matrice triangulaire supérieure. Par exemple, pour une matrice de taille 3 3 : A = LU = l l 31 l 32 1 u 11 u 12 u 13 0 u 22 u u 33 La résolution de Ax = b par la méthode Gauss-Jordan consiste à calculer la matrice A 1. Les auteurs posent une matrice A sous la forme [A b]. Par itérations successives, en faisant des combinaisons linéaires entre les lignes du système (pivot de Gauss), ils cherchent à avoir A sous la forme : A = x y z où (x, y, z) est la solution recherchée. Les matrices sont chargées comme des textures. Les opérations se font à l aide du fragment shader. Jens Krüger et Rüdiger Westermann [Krüger 03] implémentent diverses opérations sur les matrices et sur les vecteurs qu ils utilisent pour réaliser la résolution d un système de la forme Ax = b par la méthode du gradient conjugué. La matrice A doit être une matrice symétrique positive et creuse. Les auteurs donnent aussi une petite description de la résolution sur GPU de la méthode itérative de Gauss- Seidel. Leur objectif est de résoudre les équations de Navier-Stokes qui modélisent le mouvement d un fluide. Ádám Moravánszky [Moravánszky 03] utilise les opérateurs qu il a implémentés, sur GPU, pour résoudre un système linéaire Ax = b avec la méthode du gradient conjugué. Dans [Goodnight 03], les auteurs veulent résoudre l équation suivante : k 2 T = S (équation de Poisson), où T est la température, k une constante et S une source de chaleur. Cette équation permet de modéliser la température dans un espace comportant une source de chaleur. Pour résoudre cette équation, ils utilisent la méthode de multigrilles. Ils discrétisent l espace en une grille et ils cherchent la température en chaque point de la grille. Ils appliquent de façon itérative le laplacien ( 2 ) sur cette grille jusqu à l obtention de la convergence. Le laplacien est approché par une opération de convolution qui est réalisée par le GPU : 2 U i,j U i 1,j + U i,j 1 + U i,j+1 4U i,j. Pour étudier la convergence, ils utilisent le résidu 2 T + S. Ils appliquent un certain nombre de fois le laplacien, puis calculent une grille de résidus. Cette grille est interpolée en une grille de résolution supérieure. Ils appliquent ensuite le laplacien (n fois) sur cette grille des résidus. Ils interpolent de nouveau cette grille avec la résolution de départ et l utilisent pour affiner la grille de départ. L opération se répète jusqu à l obtention de la convergence. Dans [Bolz 03] les auteurs implémentent une résolution du système Ax = b, où A est une matrice creuse. Ils utilisent la méthode du gradient conjugué d une part et la méthode multigrilles d autre part.

40 24 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur LCP Ádám Moravánszky [Moravánszky 03] utilise des opérateurs, implémentés sur GPU, pour résoudre le problème de complémentarité linéaire Linear Complementarity Problem. Pour cela, il utilise la méthode de Jacobi. Le LCP est un problème d optimisation. Il se présente sous la forme : x 0 (3.1) Ax + b 0 (3.2) x T (Ax + b) = 0 (3.3) A et b sont donnés et x est à trouver. A doit être une matrice définie positive. Il utilise l algorithme de la méthode itérative de Jacobi Résolution des équations d Euler Dans [Hagen 06], les auteurs proposent une implémentation sur GPU de la résolution des équations d Euler qui modélisent la dynamique des gaz parfaits (conservation de la masse, de l énergie et de la quantité de mouvement). Soit, dans un espace à trois dimensions : ρ ρu ρv ρw E + t ρu ρu 2 + p ρuv ρuw u(e + p) x + ρv ρuv ρv 2 + p ρvw v(e + p) y + ρw ρuw ρvw ρw 2 + p w(e + p) Avec ρ la densité, (u, v, w) le vecteur vitesse, p la pression, g l accélération gravitationnelle et E l énergie totale. La notation [ ] t correspond à la dérivée partielle par rapport au temps. La résolution est effectuée comme pour l équation de Poisson (voir 3.2.4) en utilisant la méthode multigrilles. z = gρ gρw z Diagramme de Voronoï Soit S un ensemble de points, de segments ou de polygones (appelés aussi sites) d un espace de dimension d. La cellule de Voronoï V (p) d un site p est l ensemble des points de l espace dont p est le site le plus proche. Le diagramme de Voronoï correspond à la partition de l espace formé par les cellules de Voronoï. Dans [Hoff III 99], les auteurs implémentent le calcul de la distance entre divers types de site et les points de l espace sur le GPU. La dimension de l espace est de deux ou trois Filtrage Matthias Hopf et Thomas Ertl [Hopf 00] utilisent le GPU pour accélérer l application d opérateurs morphologiques sur des images. Ces opérateurs peuvent être une érosion, une dilatation, une ouverture ou une fermeture. L image est chargée sur le GPU comme une texture et l opération est effectuée par le fragment processor. L opération consiste en l application de filtres qui sont donc non linéaires. Les mêmes auteurs dans [Hopf 99a], proposent une méthode pour faire une opération sur GPU de convolution 3D sur un volume. La convolution discrète 3D peut s écrire sous cette forme : f(x, y, z) = i 1,i 2,i 3 k(i 1, i 2, i 3 )f(x + i 1, y + i 2, z + i 3 )),

41 3.2. Outils mathémathiques sur GPU 25 où f est la donnée à convoluer, k est un filtre et f, le résultat. Les auteurs se placent dans le cas d un filtre séparable, on a donc k(i 1, i 2, i 3 ) = k(i 1 ) k(i 2 ) k(i 3 ). On peut donc écrire la suite d opérations suivante : f 1 (x, y, z) = i1 k(i 1 )f(x + i 1, y, z) (3.4) f 2 (x, y, z) = i2 k(i 2 ) f 1 (x, y + i 2, z) (3.5) f(x, y, z) = i3 k(i 3 ) f 2 (x, y, z + i 3 ) (3.6) Les deux premières équations sont réalisées par une convolution 2D à réaliser sur les plans du volume discrétisé. La troisième équation est réalisée par une convolution 1D. La réalisation de cette convolution 3D se fait avec le GPU en deux passes Ondelettes Matthias Hopf et Thomas Ertl [Hopf 99b] proposent une implémentation de la décomposition en ondelettes sur GPU. Cette méthode consiste à décomposer une image en d autres images de résolutions inférieures. Pour cela, ils utilisent des filtres passe-haut et passe-bas. Cette opération se fait par convolution et est réalisée par le GPU. Les auteurs utilisent les filtres de Haar ou de Daubechies Tableau récapitulatif Catégories Méthode Implémentation Référence Opérations sur les flottants Brook [Gracca 06] Multiplication matricielle Méthode par tranches SIMD [Larsen 01] [Fatahalian 04] Méthode «classique» Non précisée [Hall 03] Calcul matriciel DirectX 9 [Moravánszky 03] Non précisée [Krüger 03] Résolution d un système Résolution de Gauss-Jordan Non précisé [Galoppo 05] ou d une équation Résolution de Gauss-Seidel Non précisé [Krüger 03] Gradient conjugué Non précisée [Krüger 03] DirectX 9 [Moravánszky 03] Non précisée [Bolz 03] Laplacien, multigrilles Non précisée [Goodnight 03] Multigrilles Non précisée [Bolz 03] Résolution des équations Multigrilles Non précisée [Hagen 06] d Euler LCP Jacobi DirectX 9 [Moravánszky 03] Diagramme de voronoï Non précisé [Hoff III 99] Filtrage Filtre non linéaire 2D Non précisé [Hopf 00] Filtre linéaire 3D Non précisé [Hopf 99a] Ondelettes Non précisé [Hopf 99b] Tab. 3.1 Outils mathématiques sur GPU.

42 26 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur 3.3 Utilisation de la carte graphique en vision par ordinateur Mise en correspondance et calcul de la carte de disparités La carte de disparités est construite dans le cadre de la mise en correspondance stéréoscopique. La disparité est le vecteur déplacement entre un pixel de l image de gauche et son correspondant dans l image de droite. La carte de disparités est calculée par rapport à une image de référence (l image de gauche ou l image de droite). Minglun Gong et Ruigang Yang [Gong 05a] utilisent des images segmentées, selon la couleur, pour guider la mise en correspondance par corrélation. Ils utilisent les méthodes d optimisation WTA (winnertake-all) et SO (scanline optimization) pour déterminer le meilleur correspondant. La carte de disparités est générée par le GPU. Alan Brunton, Chang Shu et Gerhard Roth [Brunton 06] proposent une implémentation, sur GPU, de la méthode de propagation de croyance (belief propagation) de Felzenszwalb and Huttenlocher. Cette méthode utilise le modèle des champs de Markov. La propagation de croyance est une méthode d optimisation globale. Qungxiong Yang, Liang Wang, Ruigang Yang, Shengnan Wang, Miao Liao et David Nistér [Yang 06] ont eux aussi présenté une implémentation sur GPU de la méthode de propagation de croyance pour la stéréovision. Cristopher Zach, Konrad Karner et Horst Bischof [Zach 04] calculent la carte des disparités avec une mise en correspondance hiérarchique des pixels par corrélation. Ils créent des pyramides d images, chaque étage d une pyramide correspond à l image à une résolution différente. La carte de disparités est affinée à chaque étage de la pyramide en fonction de l étage précédent. Les images sont chargées dans la mémoire graphique comme des textures et le calcul des étages des pyramides se fait sur GPU. Le calcul des scores de corrélation se fait également sur GPU. Ils utilisent les mesures SAD (sum of aboslute differences) ou SSD (sum of squared differences). Ruigang Yang et Marc Pollefeys [Yang 03] utilisent la mesure SSD ainsi qu une approche adaptative pour la taille de la fenêtre de corrélation. Dans [Yang 04a] on retrouve la même démarche que précédemment. Ils ajoutent l utilisation de la vérification bi-directionnelle (cross-checking). L idée de la vérification bi-directionnelle est de calculer aussi la carte de disparités en prenant l autre image comme référence. On compare les deux cartes, les pixels avec des disparités contradictoires ne sont pas prise en compte. Cette opération se fait aussi à l aide du GPU. Jan Woetzel and Reinhard Koch [Woetzel 04] calculent une carte de disparités en utilisant plusieurs caméras. Ils utilisent la mesure TSSD (truncated sum of squared difference) et la méthode locale d optimisation WTA. Karl Jonsson [Jonsson 03] fait de la mise en correspondance hiérarchique avec la mesure SSD. Il utilise DirectShow et Direct3D. Direct3D est un composant de l API graphique DirectX qui permet l utilisation des ressources GPU. DirectShow, qui fait partie lui aussi de DirectX, permet l affichage et la capture vidéo ainsi que la création de filtres pouvant être appliqués sur ces vidéos. Minglun Gong et Yee-Hong Yang [Gong 05b] proposent un algorithme qu ils appellent algorithme ORDP (the Orthogonal Reliability-based Dynamic Programming Algorithm). Cet algorithme utilise le CPU et le GPU (voir figure 3.1). Il est basé sur la programmation dynamique. Il s agit tout d abord de calculer une matrice M qui contient les coûts des correspondances possibles entre les pixels et de rechercher le chemin de coût minimal dans M. Pour cette étape, ils utilisent le GPU.

43 3.3. Utilisation de la carte graphique en vision par ordinateur 27 Fig. 3.1 Algorithme ORDP (extrait de [Gong 05b]). Ruigang Yang, Greg Welch et Gary Bishop [Yang 02] reconstruisent une image d un point de vue à partir d images issues de cinq points de vue différents. Pour cela, ils utilisent la méthode des plans glissants (sweep plane). L idée est de discrétiser l espace 3D en plusieurs plans parallèles à une image de référence (voir figure 3.2). Fig. 3.2 Plans glissants (extrait de [Yang 02]). Cette image de référence est projetée sur ces plans. On cherche le meilleur correspondant, dans les images projetées, des pixels des images des autres points de vue. Cette recherche est effectuée avec une mesure de corrélation de type SSD. Cette sélection et le calcul des scores sont réalisés par le GPU.

44 28 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur Dans [Cornelis 05], les auteurs reprennent la méthode des plans glissants, mais avec la prise en compte des problèmes d occultation, de zone homogène, et d ambiguïté. Ils intégrent la contrainte de voisinage au problème en imposant que les voisins d un point doivent être à une profondeur voisine. Ils utilisent aussi une approche hiérarchique. Ces problèmes sont résolus à l aide de l application d un filtre qui est implémenté sur GPU. Indra Geys, Thomas P. Kininckx et Luc Van Gool [Geys 04a] utilisent les plans glissants et les coupures de graphes (graph cut). Le CPU est utilisé pour les coupures de graphes et le GPU pour les plans glissants Reconstruction 3D à partir d images La reconstruction 3D consiste à reconstruire le relief d une scène 3D à partir d une ou de plusieurs images. Julien Mairal, Renaud Keriven et Alexandre Chariot [Mairal 05b, Mairal 05a] utilisent un modèle déformable avec une méthode variationnelle. Leur objectif est de pouvoir faire une reconstruction du relief avec des vidéos issues de deux ou trois caméras. Ils créent un maillage qu ils déforment jusqu à obtenir la forme de l objet. La déformation finale est obtenue grâce à une minimisation d une fonction d énergie (critère). Ce critère est, ici, la somme des carrés des différences entre les niveaux de gris. La minimisation est obtenue par la méthode de la descente de gradient. Pour accélérer les temps de calcul, ils utilisent le GPU. Fig. 3.3 Reconstruction du relief avec un modèle déformable : à gauche le maillage obtenu, à droite le maillage avec une texture de l objet (extrait de [Mairal 05b]). Cristopher Zach, Andreas Klaus, Bernard Reitinger et Konrad Karner [Zach 03] utilisent eux aussi un maillage dont les positions des sommets sont estimées à l aide d un carte de profondeur. L estimation des positions des sommets du maillage est itérative. Ils utilisent la multirésolution, le nombre de sommets du maillage et la résolution des images étant augmentés à chaque itération. Pour le calcul de la carte de profondeur, la mesure de corrélation SAD est utilisée. Ruigang Yang, Marc Pollefeys, Hua Yang et Greg Welch [Yang 04b] font de la reconstruction du relief avec plusieurs caméras (jusqu à cinq). Ils calculent une carte de disparités pour estimer la profondeur. La mise en correspondance se fait par corrélation avec une fenêtre adaptative et la mesure SSD. Cette mise en correspondance est réalisée par le GPU. Dans [Labatut 05] les auteurs font de la reconstruction du relief sur GPU avec la méthode de shape reconstruction [Pons 05]. Ils utilisent une séquence vidéo. Ils font de la mise en correspondance en utilisant la mesure de corrélation NCC (normalized cross-correlation). Cette opération est réalisée par le GPU.

45 3.3. Utilisation de la carte graphique en vision par ordinateur 29 Pour chaque caméra la carte de profondeur est calculée avec la par triangulation sur GPU. Chaque pixel et son correspondant sont projetés dans l espace selon le point de vue. Cela permet d obtenir la position du point de la scène correspondant à un pixel et donc de déterminer sa profondeur. Song Zhang, Dale Royer et Shing-Tung Yau [Zhang 06] proposent une implémentation, sur GPU, de l algorithme 2+1 phase-shifting pour estimer le relief. Cet algorithme permet à partir de trois images (deux images où l on a projeté sur l objet l ombre d une grille et une image de l objet) de reconstruire le modèle en 3D (voir figure 3.4). Fig. 3.4 Algorithme 2+1 phase-shifting (extrait de [Zhang 06]) Mosaïque d images Une mosaïque d images correspond à une image construite avec plusieurs images. Dans [Fung 05a, Fung 02, Fung 04a], les auteurs reconstruisent un panoramique à partir d images. Ils utilisent l algorithme VideoOrbits. La relation entre les pixels des images est donnée par une homographie. L estimation de cette homographie revient à résoudre un système d équations linéaires. Cette résolution ce fait sur le GPU (voir figure 3.5) et ils utilisent une approche multirésolution Transformation d image La transformation d une image consiste à corriger une image selon une déformation géométrique ou photométrique. Dans [Fung 05a], James Fung présente un exemple d un fragment shader qui permet de corriger une image qui a subi une distorsion radiale due au capteur. Dans [Johnson 06], l auteur propose une correction d image sur GPU selon le schéma de la figure 3.6. Il propose la correction perspective d une image, la correction photométrique et la correction d une distorsion due à l utilisation d une lentille d objectif photographique.

46 30 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur Fig. 3.5 Algorithme VideoOrbits. En noir, les étapes qui sont traitées sur GPU (extrait de [Fung 05a]). La création de la pyramide d images multirésolution est faite sur GPU. L estimation des paramètres et la comparaison de ces paramètres selon la résolution est elle aussi faite avec le GPU. Fig. 3.6 Correction d une image (extrait de [Johnson 06]).

47 3.3. Utilisation de la carte graphique en vision par ordinateur Segmentation d image La segmentation d image correspond à l obtention d une partition de l image en régions, suivant un certain critère. Joseph Kider et Liming Zhao [Kider 05] représentent une image par une matrice dont les éléments de la matrice expriment la relation entre les pixels. Une matrice peut aussi être la répresentation d un graphe. Pour partitionner le graphe en plusieurs sous-graphes (ce qui revient à segmenter l image), ils utilisent l algorithme des coupes normalisées. La mise en œuvre de cet algorithme nécessite de nombreuses multiplications matricielles qui sont réalisées par le GPU. Dans [Griesser 05], Andreas Griesser segmente les images selon l arrière plan et le premier plan avant d une image. L auteur propose une implémentation de la méthode de Mester [Mester 01] en utilisant le GPU. Indra Geys at Luc Van Gool [Geys 04b] segmentent aussi les images selon l arrière plan et le premier plan. Ils utilisent une séquence vidéo, la méthode des plans glissants et la méthode d optimisation des coupures de graphes (voir figure 3.7). Fig. 3.7 Segmentation en premier plan et arrière plan avec la méthode des plans glissants et des coupures de graphes. La méthode des plans glissants est exécutée sur le GPU et la méthode d optimisation des coupures de graphes est effectuée par le CPU (extrait de [Geys 04b]).

48 32 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur Détection de contours La détection de contours consiste à identifier les contours des objets présents dans une image. Cynthia Bruyns and Bryan Feldman [Bruyns 03] utilisent la transformée de Fourier pour filtrer les images : R conv = I F = F F T 1 (F F T [I] F F T [F ]) où I est l image, F un filtre et F F T une transformée de Fourier. Ils utilisent ensuite R conv pour identifier les limbes des objets. Le calcul de la transformée de Fourier est exécutée par le GPU. Dans [Fung 05a], James Fung propose une implémentation du détecteur de Canny sur GPU. Cris Aimone, Steve Mann et James Fung, dans [Fung 05b], donnent la méthode de l implémentation de la tranformée de Hough sur GPU. C est cette implémentation qui est utilisée dans la bibliothèque OpenVIDIA. Robert Strzodka, Ivo Ihrke et Marcus Magnor [Strzodka 03] utilisent une implémentation du détecteur de Canny pour détecter les contours des objets. La détection des contours est faite par le GPU. Puis ils réalisent une approximation polygonale des contours à l aide d une transformée de Hough implémentée, elle aussi, sur GPU Reconnaissance d objet La reconnaissance d objet consiste à identifier un objet de forme particulière dans une image. James Fung and Steve Mann [Fung 04b] utilisent un espace propre (eigenspace) pour reconnaître l objet dans une image. Un espace propre est un ensemble de vecteurs propres qui ont une valeur propre commune. Cet espace est déterminé à l aide d une base d images qui représente l objet sous divers angles de vue. Ils créent une matrice A avec les vecteurs propres. A peut s écrire sous la forme UΣV T (décomposition en valeurs singulières (singular value decomposition)). Ces valeurs singulières permettent de définir une signature de l objet, et de le reconnaître ensuite dans une image Analyse du mouvement et suivi d objet Robert Strzodka et Cristoph Garbe [Strzodka 04] proposent une méthode d estimation du flux optique sur GPU. Cette méthode est appliquée au suivi d un groupe de personnes et à l analyse du sanguin dans une angiographie. Ils utilisent l équation de contrainte du flux optique (équation des gradients) et ils font l hypothèse de champs de déplacements localement constants. Pour chaque pixel, ils disposent d un système surdéterminé d équations linéaires pour lequel ils procèdent à une estimation au sens des moindres carrés totaux. Le vecteur déplacement est alors déterminé en calculant les vecteurs et les valeurs propes du tenseur de structure spatio-temporel. Ce calcul est réalisé en utilisant la méthode de Jacobi que les auteurs ont implémenté sur GPU. La visualisation du résultat est aussi effectuée par le GPU en superposant une carte de couleurs sur les images initiales. Dans [Sinha 06], les auteurs implémentent deux algorithmes sur GPU. Le premier est l algorithme SIFT (Scale Invariant Feature Transform) qui extrait des points qui restent invariants, selon la translation, la rotation, le changement d échelle et les variations photométriques, dans les images (voir figure 3.8). Le deuxième est l algorithme KLT qui suit des points dans un flux d images (voir figure 3.9). Francis Kelly et Anil Kokaram [Kelly 04] utilisent la mise en correspondance par corrélation pour faire une interpolation d image afin d estimer le mouvement. Pour cela, ils utilisent la mesure SAD ainsi qu une minimisation de la fonction DFD (Displaced Frame Difference) pour trouver le vecteur qui représente le mouvement. James Fung [Fung 05a] propose une implémentation du suivi d une main sur GPU. Le GPU est utilisé pour l application de filtres de convolution et pour le calcul des moments sur les images.

49 3.3. Utilisation de la carte graphique en vision par ordinateur 33 Fig. 3.8 SIFT sur GPU (extrait de [Sinha 06]). Fig. 3.9 KLT sur GPU (extrait de [Sinha 06]).

50 34 Chapitre 3. Utilisation de la carte graphique en vision par ordinateur Tableau récapitulatif Catégorie Technique utilisée Code Référence Carte de disparités Image des gradients Non précisé [Gong 05a] Carte de profondeur Propagation de croyance HLSL [Brunton 06] Non précisé [Yang 06] Corrélation GLSL [Zach 04] Non précisé [Yang 03] [Yang 04a] Cg [Woetzel 04] Non précisé [Jonsson 03] ORDP HLSL [Gong 05b] Plans glissants Non précisé [Yang 02] [Cornelis 05] Plans glissants Non précisé [Geys 04a] Coupures de graphes Reconstruction Maillage Cg [Mairal 05b] 3D à partir GLSL [Zach 03] d images Estimation de la profondeur : GLSL [Yang 04b] corrélation Shape measurement Non précisé [Labatut 05] [Labatut 06] 2+1 phase-shifting Cg [Zhang 06] Mosaïque d images VideoOrbits GLSL [Fung 02] Cg [Fung 05a] Non précisé [Fung 04a] Transformation image Distorsion radiale Cg [Fung 05a] Correction perspective Cg [Johnson 06] photométrique, distortion Segmentation d image Coupe normalisée Non précisé [Kider 05] Méthode de Mester Non précisé [Griesser 05] Plans glissants, coupures de graphes Non précisé [Geys 04b] Détection de contour Transformation de Fourier Cg [Bruyns 03] Détecteur de Canny Cg [Fung 05a] Transformée de Hough Openvidia [Fung 05b] Détecteur de Canny Non précisé [Strzodka 03] Transformation de Hough Reconnaissances d objets Espace propre Non précisé [Fung 04b] Analyse du mouvement Flot optique Non précisé [Strzodka 04] et suivi d objet KLT, SIFT Cg [Sinha 06] Mise en correspondance Non précisé [Kelly 04] Convolution, moments Cg [Fung 05a] Tab. 3.2 Utilisation de la carte graphique en vision par ordinateur.

51 3.3. Utilisation de la carte graphique en vision par ordinateur 35 Le tableau 3.2 donne un récapitulatif de l utilisation des cartes graphiques en vision par ordinateur. De nombreux travaux ont été réalisés en vision par ordinateur utilisant le GPU. Cela montre bien que l utilisation du GPU est un atout pour la mise en œuvre de diverses techniques pour la vision par ordinateur.

52

53 Chapitre 4 Mise en correspondance sur GPU Dans ce chapitre, nous présentons une stratégie d implémentation d une méthode de mise en correspondance stéréoscopique sur GPU. Nous utiliserons une mise en correspondance stéréoscopique par corrélation [Chambon 05]. 4.1 Mise en correspondance par corrélation Introduction La mise en correspondance stéréoscopique est une opération qui s applique à sur un couple d image : une image de gauche et une image de droite. Il s agit de trouver le correspondant d un pixel de l image de gauche dans l image de droite. La recherche du correspondant dans l image de droite se fait dans une zone de recherche (region of interest) (voir figure 4.1). Image gauche Image droite Zone de Recherche Pixel gauche Correspondant Pixel droit Fig. 4.1 Mise en correspondance par corrélation avec une zone de recherche. Pour estimer la ressemblance de deux pixels, issus de deux images images, ont utilise une mesure de corrélation. Cette mesure de corrélation prend en compte le voisinage des pixels (fenêtre de corrélation) et permet d évaluer leur ressemblance. 37

54 38 Chapitre 4. Mise en correspondance sur GPU Pour mettre les pixels de deux images stéréoscopiques en correspondance, on peut appliquer l algorithme général 1. Pour chaque pixel de l image de gauche p i,j g faire 1. Construire l ensemble E g des pixels voisins de p i,j g et de la zone de recherche faire 2.1 Construire l ensemble E d des voisins de p i,j g 2.2 Effectuer la mesure de corrélation des deux ensembles E g et E d 3. Choisir le pixel de l image de droite qui donne le meilleur score de corrélation 2. Pour chaque pixel de l image de droite p l,k d Mesure de corrélation Algorithme 1 Mise en correspondance par corrélation. La mesure de corrélation permet donc d évaluer la ressemblance de deux ensembles de pixels. Il existe plusieurs familles de mesures [Chambon 05]. Nous utiliserons la famille des mesures de corrélation croisée Notations et opérateurs de base Nous utiliserons les notations suivantes : la taille des fenêtres de corrélation est noté N f. L ensemble E g (respectivement E d ) est stocké dans le vecteur f g (respectivement f d ). Les composantes de ces vecteurs sont des entiers, compris entre 0 et 255 pour exprimer un niveau de gris, ou un vecteur à trois dimensions pour exprimer la couleur dans l espace RVB (Rouge Vert Bleu). Chaque composante de ce vecteur couleur est un entier compris entre 0 et 255. On a donc : pour une image en niveau de gris : f l = (... fl k...) T où f k l est l élément k du vecteur f l et l désigne indifféremment g ou d ; pour une image en couleur : f l = (... c k l...)t où c k l = (rl k, vk l, bk l )T est la couleur RVB du pixel k dans f l. Nous utiliserons les opérateurs suivants : les normes L P avec P N : pour une image en niveau de gris : N f 1 f l P = fl k P k=0 1/P ; pour une image couleur : f l P = N f 1 k=0 c k l P P 1/P avec c k l P P = (r k l )P + (v k l )P + (b k l )P. Nous noterons f l = f l 2 ;

55 4.1. Mise en correspondance par corrélation 39 le produit scalaire : pour une image en niveau de gris : pour une image couleur : le vecteur des moyennes : pour une image en niveau de gris : f g.f d = f g.f d = N f 1 k=0 N f 1 k=0 f k g f k d ; r k g r k d + vk g v k d + bk gb k d ; fg = (moy(f g )... moy(f g ) } {{ } N f colonnes ) T où pour une image en couleur : fg = 1 ( N f } {{ } moy(f g ) = 1 N f 1 fl k N ; f N f colonnes ) T N f 1 k=0 k=0 r k l N f 1 k=0 v k l N f 1 k=0 b k l Caractéristiques des mesures Pour chaque mesure, nous avons les caractéristiques suivantes : l intervalle de variation des mesures ; les invariances par rapport aux changements de luminosité. Nous considérons trois types d invariance : invariance de type gain, notée G : Mes(af g,bf d ) = Mes(f g,f d ) avec a, b R ; invariance de type biais, notée B : Mes(a + f g,b + f d )=Mes(f g,f d ) avec a, b R ; invariance de type gain et biais, notée GB : Mes(af g +b,cf d +d) = Mes(f g,f d ) avec avec a, b, c, d R Mesures de corrélation croisée Les mesures de corrélation croisée, notée CC (Cross-Correlation), sont les suivantes : la mesure de corrélation croisée normalisée, notée NCC (Normalized Cross-Correlation) : NCC(f g,f d ) = f g.f d f g f d. Les valeurs de cette mesure appartiennent à l intervalle [0 ;1]. Cette mesure donne 1 quand les deux ensembles sont identiques. Elle possède une invariance de type gain. la mesure de corrélation croisée centrée normalisée, notée ZNCC (Zero mean Normalized Cross- Correlation) : ZNCC(f g,f d ) = (f g f g ).(f d f d ) f g f g f d f d. Les valeurs de cette mesure appartiennent à l intervalle [-1 ;1]. Cette mesure donne 1 quand les deux ensembles sont identiques. Elle possède une invariance de type gain et biais.

56 40 Chapitre 4. Mise en correspondance sur GPU la mesure de Moravec, notée MOR : MOR(f g,f d ) = 2(f g f g ).(f d f d ) f g f g 2 + f d f d 2 Les valeurs de cette mesure appartiennent à l intervalle [-1 ;1]. Cette mesure donne 1 quand les deux ensembles sont identiques. Elle possède une invariance de type biais. Le tableau (voir table 4.1) résume les mesures évoquée ci-dessus. Nom Notation Définition Intervalle Type Corrélation croisée normalisée Corrélation croisée centrée normalisée Moravec NCC ZNCC MOR f g.f d f g f d [0 ;1] G (f g f g).(f d f d ) f g f g f d f d [-1 ;1] GB 2(f g f g).(f d f d ) f g f g 2 + f d f d 2 [-1 ;1] B Tab. 4.1 Mesures de corrélation croisée. 4.2 Mise en correspondance sur GPU en utilisant le langage GLSL Dans cette partie nous décrivons l implémentation d une mise en correspondance sur GPU en utilisant le langage GLSL [Rost 04] Quelques indications sur le langage GLSL Types de données Le langage GLSL fournit plusieurs types de données. Il offre trois types de bases qui sont : les flottants (float), les entiers (int) et les booléens (bool). Associé à ces types, GLSL propose le type vecteur avec deux, trois et quatre éléments de type flottant, entier ou booléen : vec2, vec3, vec4 pour des vecteurs de type flottant ; ivec2, ivec3, ivec4 pour des vecteurs de type entier ; bvec2, bvec3, bvec4 pour des vecteurs de type booléen. Les éléments des vecteurs sont accessibles de la manière présentée dans le tableau 4.2. Il est possible d accéder directement à plusieurs éléments d un vecteur. Par exemple, soit un vecteur défini de la manière suivante : vec4 V1. On peut écrire : vec2 V2=V1.gb. L initialisation d un vecteur se fait, par exemple, de la manière suivante : vec4 V1= vec4(0.0), vec3 V2= vec3(0.0,1.0,2.0). On obtient V1 = ( ) T et V2 = ( ) T. Type vec2 vect vec3 vect vec4 vect Accesseurs vect.x vect.r vect.s vect.x vect.r vect.s vect.x vect.r vect.s vect.y vect.g vect.t vect.y vect.g vect.t vect.y vect.g vect.t vect.z vect.b vect.p vect.z vect.b vect.p vect.w vect.a vect.q Tab. 4.2 Types vecteurs en GLSL et leurs accesseurs. Le type matrice est lui aussi définie. Les éléments de ce type matrice sont des flottants. Les dimensions possibles des matrices sont de 2 2 (mat2), 3 3 (mat3) et 4 4 (mat4). Soit Mat une matrice de type mat4, l écriture Mat[1][1] permet de récupérer l élément situé à la deuxième ligne et à la deuxième colonne. Si on écrit Mat[2], on récupère la troisième colonne (type vec4).

57 4.2. Mise en correspondance sur GPU en utilisant le langage GLSL Fonctions GLSL prèsdéfinies Le langage GLSL fournit de nombreuses fonctions trigonométriques, exponentielles, géométriques, matricielles,etc. (voir tableau 4.3). La liste présentée ici n est pas exhaustive. Certaines de ces fonctions sont câblées dans la carte graphique et leur utilisation peut alors faire diminuer les temps de calcul. Type Syntaxe Description Trigonométrique float sin(float radians) Calcule le sinus d un angle vec{i} sin(vec{i} x) exprimé en radians. float cos(float radians) Calcule le cosinus d un angle vec{i}cos(vec{i} x) exprimé en radians. float tan(float radians) Calcule la tangente d un angle vec{i} tan(vec{i} x) exprimé en radians. Exponentielle float pow(float x, float y) Calcule x y. vec{i} pow(vec{i} x,vec{i} y) float exp(float x) Calcule e x. vec{i} exp(vec{i} x) float log(float x) Calcule log(x) avec x > 0. vec{i} log(vec{i} x) float sqrt(float x) Calcule la racine carrée de x, vec{i} sqrt(vec{i} x) avec x 0. float inversesqrt(float x) Calcule l inverse de la vec{i} inversesqrt(vec{i} x) racine carré de x, avec x > 0. Géometrique float length(float x) Calcule la norme euclidienne : vec{i} length(vec{i} x) sqrt(x[0]x[0] + x[1]x[1]...). float distance(float x, float y) Calcule la distance euclidienne : vec{i} distance(vec{i} x, float y) length(x y). float dot(float x, float y) Calcule le produit scalaire : vec{i} dot(vec{i} x, float y) (x[0]y[0] + x[1]y[1]...). vec3 cross(vec3 x, vec3 y) Calcule le produit vectoriel. float normalize(float x) Rend x unitaire. vec{i} normalize(vec{i} x) Matricielle mat{i} matrixcompmult(mat{i} X, mat{i} Y ) Calcule le produit matriciel. Autres float abs(float x) Calcule la valeur absolu. vec{i} abs(vec{i} x) float min(float x,float y) Calcule le minimum vec{i} min(vec{i} x,vec{i} y) entre x et y. vec{i} min(vect{i} x, float y) float max(float x,float y) Calcule le maximum vec{i} max(vec{i} x,vec{i} y) entre x et y. vec{i} max(vect{i} x, float y) vec{i} mod(vect{i} x, vec{i} y) Calcule le modulo. Tab. 4.3 Fonctions GLSL prédéfinies. La notation vec{i} a pour signification : vec2, vec3 ou vec4. De même, mat{i} signifie mat2, mat3 ou mat4.

58 42 Chapitre 4. Mise en correspondance sur GPU Textures et les Couleurs en GLSL Les textures sont repre sente es dans l espace [0 ;1] [0 ;1] (voir figure 4.2). h Image l 0 Texture 1 Fig. 4.2 Texture en GLSL : h et l repre sentent la hauteur et la largeur de l image en pixels. Si le vecteur de placement d un pixel a un pixel voisin, dans une image, est e gal a (1, 1) T. Dans une texture ce me me de placement sera e gal a ( 1l, h1 )T. Une composante couleur, en GLSL, est code e sur l intervalle [0 ;1] Algorithme de mise en correspondance avec GLSL E crire un traitement en GLSL peut se re sumer a e crire trois fichiers : vertex.ver, fragment.fra et main.c. Le fichier main.c contient le code ne cessaire pour re aliser l algorithme Initialisation avec GLUT 1.1 Initialisation du contexte OpenGL de la fene tre d affichage 1.2 Attachement des fonctions de rendu, de contro le des touches, etc. 2. Initialisation des extensions OpenGL avec GLEW 3. Cre ation des textures associe es aux images a mettre en correspondance 4. Initialisation des shaders Algorithme 2 Mise en correspondance avec GLSL : algorithme pour le fichier main.c. GLUT (OpenGL Utility Toolkit) est une bibliothe que qui permet de ge rer des fene tres OpenGL et l interaction avec le syste me (clavier, souris, etc.). GLEW (OpenGL Extension Wrangler Library) est une bibliothe que qui permet de ge rer les extensions OpenGL. Pour afficher une texture dans une fene tre, on trace un quadrilate re de la dimension de l image sur lequel on applique la texture de l image. Le fichier vertex.ver contient le code qui permet d effectuer un traitement sur les sommets de la sce ne. Dans notre cas, nous ne re alisons aucun traitement. Le fichier fragment.ver contient le code qui re alise le traitement a effectuer sur chaque e le ment a mettre en correspondance suivant l algorithme 3. Ce code permet de donner la disparite entre les deux

59 4.2. Mise en correspondance sur GPU en utilisant le langage GLSL 43 correspondants. Nous utilisons donc les méthodes : Read Back, Copy to Texture, Render to Texture. Les images sont des textures, le traitement à effectuer est écrit dans un fragment shader et le résultat est affiché soit dans une texture, soit dans le frame buffer. 1. Pour chaque élément de la zone de recherche faire 1.1 Calculer le score de corrélation 1.2 Si le score est le meilleure, garder le correspondant associé 2. Calculer de la disparité 3. Afficher de la disparité Algorithme 3 Mise en correspondance avec GLSL : algorithme pour le fichier fragment.frag. float mesuremax = 0.0 ; vec2 correspondant= vec2(0.0) ; 1. Pour tous les pixels de la zone recherche : Pour i de 0 à tailler faire Calculer offsetr vec3 mesure = vec3(0.0) ; 1.1 Pour chaque pixel de la fenêtre de corrélation : Pour j de 0 à taillec faire Calculer offsetc Récupérer les éléments pour le calcul du score : vec3 tempg = textureimagegauche(coord+offsetc) ; vec3 tempd = textureimagedroite(coord+offsetc+offsetr) ; Calculer le score : score = score+vec3(dot(tempg,tempd), dot(tempg,tempg), dot(tempd,tempd)) ; 1.2 Calculer le score finale : float scorefinal = score.x inversesqrt(score.y,score.z) ; 1.3 Sélectionner le meilleur correspondant : Si (max(scoremax, scorefinal)) > scoremax alors scoremax = scorefinal ; correspondant = coord+offsetr ; 2. Calculer la disparité : float disparité = distance(coord,correspondant) ; 3. Afficher la disparité Algorithme 4 Mise en correspondance avec GLSL : algorithme pour la mesure NCC.

60 44 Chapitre 4. Mise en correspondance sur GPU On définit : taillec : taille de la fenêtre de corrélation ; tailler : taille de la zone de recherche ; offsetc : valeur permettant l accès aux éléments des textures dans la fenêtre de corrélation ; offsetr : valeur permettant l accès aux éléments des textures dans la zone de recherche ; coord : coordonnées de l élément à mettre en correspondance. Pour la réalisation d une mise en correspondance avec la mesure NCC, on utilise l algorithme 4. Les variables utilisées sont : scoremax : permet de stocker le meilleur score ; correspondant : permet de stocker le meilleur correspondant associé au meilluer score ; score : vecteur pour le calcul du score, score = (f g.f d f g f d ) T ; tempg et tempd : stockent la valeur couleur d un pixel de l image de gauche et de l image de droite ; disparité : valeur de la disparité entre le pixel de gauche et son correspondand de l image de droite. De même, pour la réalisation d une mise en correspondance avec la mesure ZNCC, on utilise l algorithme 5. Pour calculer le score de cette mesure, il faut calculer la moyenne de la valeur des pixels dans la fenêtre de corrélation, d où les variables moyennegauche et moyennedroite. Le vecteur score correspond au vecteur ((f g f g ).(f d f d ) f g f g f d f d ) T. Pour l utilisation de la mesure de Moravec, l algorithme est le même que pour la mesure ZNCC sauf que le calcul final du score est différent. Au lieu de : float scorefinal =score.x inversesqrt(score.y,score.z), on a : float scorefinal = 2.0 score.x/(score.y+score.z).

61 4.2. Mise en correspondance sur GPU en utilisant le langage GLSL 45 float mesuremax = 0.0 ; vec2 correspondant= vec2(0.0) ; 1. Pour tous les pixels de la zone recherche : Pour i de 0 à tailler faire Calculer de offsetr vec3 mesure = vec3(0.0) ; 1.1 Calculer les moyennes : vec3 moyennegauche = vec3(0.0) ; vec3 moyennedroite = vec3(0.0) ; Pour chaque pixel de la fenêtre de corrélation : Pour k de 0 à taillec faire Calculer offsetc moyennegauche + = textureimagegauche(coord+offsetc) ; moyennedroite + = textureimagedroite(coord+offsetc+offsetr) ; moyennegauche = moyennegauche/taillec ; moyennedroite = moyennedroite/taillec ; 1.2 Pour chaque pixel de la zone de corrélation : Pour j de 0 à taillec faire Calculer offsetc Récupérer les éléments pour le calcul du score : vec3 tempg = textureimagegauche(coord+offsetc)-moyennegauche ; vec3 tempd = textureimagedroite(coord+offsetc+offsetr) -moyennedroite ; Calculer le score : score + = vec3(dot(tempg,tempd), dot(tempg,tempg), dot(tempd,tempd)) ; 1.4 Calculer la mesure finale : float scorefinal =score.x inversesqrt(score.y,score.z) ; 1.3 Sélectionner le meilleur correspondant : Si (max(scoremax,scorefinal)) > scoremax alors scoremax = scorefinal ; correspondant = coord+offsetr ; 2. Calculer la disparité : float disparité = distance(coord,correspondant) ; 3. Afficher la disparité Algorithme 5 Mise en correspondance avec GLSL : algorithme pour la mesure ZNCC.

62 46 Chapitre 4. Mise en correspondance sur GPU Comparaison CPU/GPU en termes de performance Nous avons mesuré les temps mis pour réaliser un mise en correspondance stéréoscopique en utilisant le CPU et le GPU. La carte graphique utilisée est une NVIDIA GeForce 8800 GTX et le CPU est un AMD 64 X Les tests sont réalisés sur un couple d images couleur de dimension Les tailles des fenêtres de corrélation sont : 5 5, 7 7, 9 9 et Les tailles des zones de recherche sont : 11 11, et Les résultats sont consignés dans le tableau 4.4. Fenêtre de CPU GPU Zone de corrélation recherche NCC ZNCC Moravec Tab. 4.4 Temps de calcul en secondes pour une mise en correspondance stéréoscopique. L algorithme implémenté pour le CPU diffère de celui pour le GPU (voir algorithme 6). Les résultats obtenus pour le CPU sont médiocres. L algorithme peut-être optimisé en utilisant le fait que les processeurs possèdent plusieurs cœurs. Toutefois, les temps de calculs effectués sur le GPU sont extrêmement rapides. 1. Construire un tableau TabGauche contenant tout les pixels de la fenêtre de corrélation de l image gauche 2. Pour chaque pixel de la zone de recherche faire : 2.1 Construire un tableau TabDroite contenant tout les pixels de la fenêtre de corrélation de l image droite 2.2 Calculer les scores en utilisant TabDroite et TabGauche 2.3 Sélectionner le meilleur correspondant 2.4 Calculer la disparité 3. Afficher les diparités Algorithme 6 Mise en correspondance stéréoroscopique avec le CPU.

63 4.2. Mise en correspondance sur GPU en utilisant le langage GLSL 47 Les cartes graphiques NVIDA GeForce 8 ont une capacité de calcul largement supérieur aux autres cartes graphiques que l on trouve sur le marché informatique (voir 4.3). Les temps de calculs seraient sans doute plus importants, mais resteraient quand même meilleur que ceux du CPU. Fig. 4.3 Comparatif des cartes graphiques présentent sur le marché (extrait de : L appelation GX2 correspond à l utilisation de deux cartes graphiques en même temps. La carte graphique de référence est la GeForce 7900 GT.

64

65 Chapitre 5 Conclusion Dans ce rapport, nous avons donc présenté la programmation GPU, un état de l art sur les méthodes de vision par ordinateur utilisant le GPU, ainsi qu une utilisation du langage GLSL pour la mise en correspondance stéréoscopique de pixels par corrélation. L utilisation du GPU permet d effectuer un traitement sur un ensemble de données plus rapidement qu avec un CPU. Dans le domaine de la vision par ordinateur, sont donc concernées de nombreuses applications comme l imagerie médicale, la vision pour la robotique etc. Mais, plus généralement, de nombreux autres domaines sont concernés [GPGPU 07] tels que : les bases de données [Govindaraju 04], l audio [Whalen 04], etc. Fig. 5.1 RapidMind : plateforme de développement pour CPU, GPU et Cell (extrait de [McCool 03b]). La programmation GPGPU est donc propice à toutes les applications qui demande un traitement de données massivement parallèles. Aujourd hui, la programmation GPGPU n est pas une chose aisée, il est difficile de «debugger»un programme réalisé avec ce type de programmation. La programmation GPGPU va considérablement se développer au cours des années qui vont arriver. On voit l apparition 49