dont ceux que je n'ai pas cité, MM. Bertrand ZAVIDOVIQUE

À mes parents, ma famille, mes amis ...

RemerciementsJe tiens à remercier Mme Claire DUPAS pour m'avoir accueilli à l'Institutd'Électronique Fondamentale et M. Alain MÉRIGOT pour son accueil dans le départementd'Architectures et Conception de Circuits Intégrés et de Systèmes, ainsi que pour son rôlede président du jury.Ce travail de thèse n'aurait pu avoir lieu sans le soutien permanent de mon directeurde thèse Mme Edwige PISSALOUX que je remercie de m'avoir guidé. Merci aussi à M.Patrick BONNIN pour avoir assumé pleinement la codirection. Avec votre aide, j'ai aussidécouvert une activité d'enseignement à l'IUT de Villetaneuse au sein du département GÉIIdont je remercie les participants, notamment MM. Homère N'KWAWO et PatriceBERTHAUD. Les deux années d'Attaché Temporaire d'Enseignement et de Recherche ontparticipé pleinement à l'aboutissement de mes travaux.Je remercie l'Établissement Central de l'Armement (Arceuil) pour m'avoir permisd'accéder au système parallèle CM-5 qui a été un point important au tournant de laréalisation du système que je propose. Je remercie aussi le Commissariat à l'ÉnergieAtomique (centre de Bruyère-le-Chatel) et les personnes qui ont suivi mes travaux depuisle commencement : MM. François DURBIN, André TISSOT, Gilles BEZENCENET,Thierry GARIÉ, Pierre LALANDE.Merci à M. Francis DEVOS pour avoir été à l'origine de ce sujet de thèse, ainsi qu'àmes collègues de DEA pour avoir collectivement fait naître une réalisation dont la suite amontré qu'il s'agissait d'un dispositif intéressant pour de nombreuses applications.Merci aux professeurs Kun-Mean HOU et Jack-Gérard POSTAIRE pour avoir étérapporteurs sur mon travail de thèse et pour leur bienveillance. Je remercie aussi M.Georges QUÉNOT pour avoir fait partie du jury, pour m'avoir soutenu et encouragé depuisle début de mes réalisations, et pour m'avoir toujours accueilli lorsque la réflexion sur mestravaux le nécessitait.Je tiens également à remercier l'ensemble des permanents du département AXIS,dont ceux que je n'ai pas cité, MM. Bertrand ZAVIDOVIQUE, Roger REYNAUD, ThierryMAURIN, Samir BOUAZIZ, Michel FAN, Éric BÉLHAIRE, Mlle Samia BOUCHAFA,MM. Hugues MOUNIER, Patrice BRAULT. Merci à Marius VASILIU pour être toujoursde très bon conseil. Merci à M. Antoine DUPRET et à M. Jacques-Olivier KLEIN pourleurs conseils. Je tiens aussi à remercier M. Claude ARCILE avec lequel j'ai poursuivi monperfectionnement dans l'utilisation du système UNIX, et pour sa grande disponibilité. Jeremercie chacun d'entre eux pour avoir porté intérêt au bon déroulement de mes travaux.

Je tiens à remercier M. Jean LOUCHET qui par sa passion pour les dispositifsoptiques a bouleversé ma vision du problème, et m'a guidé vers un énoncé rigoureux de maproblématique.Je remercie les collègues du troisième étage, notamment M. Jean-Pierre RUAUD,Mme Bénédicte DINAND pour m'avoir aidé dans mes recherches bibliographiques, et pouravoir gentiment proposé de corriger la première version de ce manuscrit. Je remercie aussiMlle Annie CHARRIER pour avoir aidé à la touche finale du manuscrit et pour laprésentation orale des travaux.Je remercie chaleureusement Mme Annick GIORDANO, Mme Sylvie BONNOTet M. Guy VERNET pour leur aide dans les démarches d'administration.Merci à Mme Huguette MARÉCHAL pour la reprographie de ce manuscrit et desnombreux autres documents d'avancement au cours de cette thèse.Je remercie Cédric CLERC pour son aide dans mes réalisations électroniques.Merci à Mme Claudine FALCETTA et Mme Élisabeth BOUYSSY pour leurs rôlesincontournables à l'Institut, et que j'ai connues tout au long de mes études.Je remercie mes collègues de l'IEF : Frédéric BIZOUERNE, Franck DHELLIER,Alain NIFLE, Kamel BOUCHEFRA, Saloua GUEZGUEZ, Nicolas LLASER, MingZANG, Fabrice VERJUS, Olivier GEVIN, Nicolas ZEROUNIAN, Frédérique GADOT,Alexandre LABICHE, Nathalie HAZIZA, Didier DULAC, Siamak MOHAMADI, NorrihVALAYDEN, Bertrand GRANADO, Bertrand DUCOURTHIAL, Florence RÉMY, LiHAITAO, Andrei CARDOSO, Martial DESGEORGES, Abdallah NSHARE. Merci à euxtous d'avoir partagé cette expérience de vie d'un doctorant. Merci aux membres du réseaudoctoral en architecture.Merci Kafia ZEMIRLI pour notre parcours commun qui n'a pas été toujours facile,et le soutien permanent que tu es. Merci aussi à Édith LÉAUTEY car tu es d'une bonnehumeur constante, et que tu a assumé pleinement ton rôle de responsable des doctorantsd'AXIS. Je voudrais aussi remercier mes collègues doctorants de l'IEF, et très bons amis,Thierry et Laleh ROCHEBOIS, et les féliciter pour la naissance de leur petit Antoine, quiétait un événement autrement plus important que l'achèvement de mes travaux de thèse.Merci aussi à mes amis Nicolas LE GRAND DES CLOIZEAUX, David ROUSSELet Fabien CHAINTREAU.Je remercie aussi profondément mes parents et mon frère Jean-Baptiste qui m'ontconstamment soutenu, et aidé au cours de ces années.

Sommaire.Introduction..................................................................................................................... 31ère Partie........................................................... 11Chapitre 1. Évaluation qualitative de méthodes d'appariement. ................................... 11Chapitre 2. Contexte de la vision aérienne pour l'appariement d'images...................... 192.1 Vision aérienne et modélisation géométrique........................................................... 212.1.1 Modèle de transformation projective à paramètres implicites. .................. 232.1.2 Modèle de transformation projective plane à paramètres explicites.......... 252.2 Détermination du mouvement spatial de la caméra.................................................. 292.3 Quantification du mouvement spatial de la caméra.................................................. 292.4 Principe pyramidal d'appariement d'images aériennes. ............................................ 312.5 Détails de l'algorithme générique de mise en correspondance d'images. ................. 342.5.1 Gestion de la pyramide d'images. ............................................................. 352.5.2 Modélisation du mouvement global entre images. .................................... 372.5.3 Quantification des paramètresajustement du champ par le modèle projectif.......................................... 392.5.4 Superposition des deux images (mosaïque) - Vérification qualitativede l'appariement. ................................................................................................. 402.5.5 Vérification quantitative de qualité de l'appariement. ............................... 412.5.6 Invariance à la luminosité ambiante constituant le traitementpréalable. ............................................................................................................. 422.6 Contraintes de notre application, le projet SYRAR.................................................. 462.7 Remarques. ............................................................................................................... 47Chapitre 3. Mise en oeuvre d'une méthode d'appariement d'images............................. 493.1 Énoncé de la méthode d'appariement d'images aériennes. ....................................... 513.2 Création de la pyramide d'images............................................................................. 543.3 Programmation dynamique monodimensionelle. ..................................................... 563.3.1 Formulation mathématique. ....................................................................... 563.3.2 Exemples sur des images de synthèsecas monodimensionnel. ........................................................................... 583.3.3 Distance lumineusela fonction de coût. .................................................................................. 633.4 Programmation dynamique orthogonale (bidimensionelle). .................................... 673.5 Modélisation du flot optique par la méthode des moindres carrés. .......................... 693.5.1 Transformation projective explicitée. ........................................................ 693.5.2 Comparaison des modèles projectifs sur des images réelles...................... 713.5.3 Moindres carrés non-linéaires supervisés. ................................................. 74

3.5.4 Critère de sélection des vecteurs du champ de disparité............................ 763.5.5 Initialisation des paramètres de la transformation projective. ................... 773.6 Vérification du résultat par application de la transformée........................................ 803.7 Quantification du résultat de recalage projectif........................................................ 813.8 Rebouclage de l'algorithme....................................................................................... 823.9 Résultats de la méthode. ........................................................................................... 833.10 Conclusion partielle sur la partie algorithmique du mémoire. ............................... 862ème Partie ............................................................ 89Chapitre 4. Modèle et principe fonctionnel du dispositif de micro-programmationdynamique....................................................................................................................... 894.1 Définition d'un modèle de circuit de programmation dynamique. ........................... 924.1.1 Formulation mathématique. ....................................................................... 924.1.2 Analogie mécanique du fonctionnement du système deprogrammation dynamique. ................................................................................ 944.1.3 Simulation séquentielle de la machine systolique...................................... 954.1.4 Algorithme parallèle respectant le modèle................................................. 974.1.5 Validation du modèle fonctionnel.............................................................. 984.2 Mise en oeuvre des calculs de programmation dynamique sur des images. .......... 1024.3 Évaluation temporelle par simulation de la machine de micro-programmationdynamique..................................................................................................................... 1044.4 Commentaires. ........................................................................................................ 107Chapitre 5. Réalisation et évaluation du prototype de processeur de microprogrammationdynamique. .......................................................................................... 1095.1 Architecture proposée du système de mise en correspondance d'images............... 1125.2 Architecture du processeur de micro-programmation dynamique. ........................ 1135.2.1 Optimisation spatiale du calculateur. ....................................................... 1145.2.2 Chemin des données dans le calculateur.................................................. 1165.2.3 Élément de calcul d'un processeur élémentaire........................................ 1185.3 Extensibilité du circuit. ........................................................................................... 1205.3.1 Réseau de calculateurs µPD. .................................................................... 1205.3.2 Processeur virtualisable............................................................................ 1225.4 Réalisation et évaluation d'un prototype................................................................. 1255.4.1 Implantation dans un Xilinx XC4010. ..................................................... 1265.4.2 Portage sur un Xilinx Virtex 300. ............................................................ 1305.5 Conclusion partielle. ............................................................................................... 131Conclusion ................................................................................................................... 133Bibliographie ............................................................................................................... 1412

Introduction.3

La mise en correspondance d'images est un point important pour le domaine de lavision des dispositifs autonomes. Cette problématique apparaît lorsque deux images d'unemême scène étant acquises sous deux points de vue, et à des instants différents, doiventêtre appariées afin de donner une information de position relative (mouvement global) ausystème de navigation. L'information de recalage visuel est alors une information parmid'autres (odomètrie, dispositifs électromécaniques de positionnement, capteurs passifs ouactifs) qui permet le recalage de la trajectoire de navigation. Les domaines d'applicationsdes dispositifs de mise en correspondance d'images sont variés :- robotique autonome aux moyens embarqués : industriel, nucléaire, militaire- médical : Par exemple assistance à la chirurgie opératoire et téléopératoire- protection de l'environnement- robotique aérienne, spatiale- multimédia : stabilisation d'image, vision panoramique etc ...La mise en correspondance est un domaine vaste, où deux approches différentes seconfrontent en traitement des images. Les uns cherchent à mettre en correspondance desprimitives d'images, à la suite d'une segmentation. La méthode consiste alors à trouver despoints d'intérêt dans la séquence d'images, et à déterminer le déplacement de ceux-ci, s'ilsse conservent, d'une image à la suivante. La difficulté qui apparaît alors, est que des scènesréelles s'avèrent toujours difficiles à analyser, et les caractéristiques que l'on extrait semodifient au fil des images par des changements des conditions d'illumination, desphénomènes d'occultation etc ... Ces méthodes de mise en correspondance "éparse" 1 ont unatout, qui est la faible complexité algorithmique au regard de la quantité d'information àtraiter. Les images que nous traitons ont une dimension typique de 256x256 pixels en 256niveaux de gris, ce qui fait que la complexité algorithmique est une caractéristique cruciale,lorsque l'on cherche à obtenir des traitements en temps réel (l'ordre de grandeur du tempsde calcul est alors la seconde).Une deuxième classe d'algorithmes, dont notre méthode fait partie, permet d'obtenird'une information "dense" par l'appariement de la réflectance de tous les éléments de lascène. Lorsque l'on utilise des images en niveaux de gris, c'est la luminance de chaquepixel qui est comparée d'une image à l'autre (avec l'hypothèse que la luminance seconserve). L'avantage majeur de ces méthodes est leur robustesse. Une grande quantitéd'information étant traitée, une erreur n'aura que peu de répercussion à coté de la quantitéde résultats corrects. Le désavantage est la lourdeur de calcul. Toutefois, ces algorithmesont une caractéristique favorable : la très grande régularité de leur formulation. Le flot depixel peut être traité d'une manière régulière, c-à-d identique pour chaque pixel. Cettecaractéristique ouvre le champ à la réalisation matérielle de dispositifs électroniques dédiésqui viennent palier la complexité naturelle de ces méthodes. La réalisation d'un dispositif1 Lorsqu'un faible nombre de primitives, au regard de la taille de l'image, sont mises en correspondance.5

impose que l'on se fixe de nouvelles contraintes, et va souvent de pair avec l'épuration desalgorithmes mis en oeuvre.La plupart des algorithmes "denses" ont recours à un opérateur qui permet lalocalisation d'un voisinage de pixels d'une image à l'autre. Cet opérateur est l'intercorrélationqui indique par son indice (entre 0 et 1) la ressemblance locale des voisinages.Il impose que l'on examine dans une région limitée (le déplacement d'un pixel d'une imageà l'autre est par contrainte borné) le maximum d'un pic (de corrélation entre images) quidonne le déplacement du voisinage d'origine dans la seconde image. Ce calcul constitueune méthode locale permettant d'obtenir un champ de vecteurs de déplacement d'une imagevers l'autre. Cette méthode requiert un calcul en nombres rationnels (flottants) du fait de lanormalisation de l'opérateur (l'indice doit se situer entre 0 et 1). C'est donc un algorithmelocal, complexe mais régulier et nécessitant un calcul rationnel qui a donné lieu à denombreuses réalisations (Algorithme Dauphin de l'IGN, Machine de vision stéréoscopiquede Kanade, C.M.U.).L'algorithme auquel nous avons eu recours, est plus rarement utilisé entraitement des images. Il a surtout donné lieu à des réalisations pour le traitement de laparole. Il s'agit de l'algorithme de programmation dynamique. C'est à l'origine unalgorithme permettant d'apparier des données monodimensionnelles, toutefois, grâce à laséparabilité de l'information portée par les lignes et colonnes d'images, il peut être employésur des données bidimensionnelles (images) pseudo-stationnaires. Il s'agit, lorsque l'onapparie deux lignes d'images, de trouver le chemin de correspondance optimal, qui donneun vecteur de déplacement correct localement, et tel que tous les vecteurs de déplacement(disparité) aient une cohérence globale sur l'ensemble des pixels de la ligne. Il fait appel àun calcul intégral (comme la corrélation), et choisit parmi tous les chemins possibles, lechemin (extrémités des vecteurs) qui donne une cohérence globale aux vecteurs selon uncritère de coût. L'intégrale des coûts locaux selon toutes les trajectoires possibles forme unscore global qui doit être minimisé. Si la pondération par le coût local est optimale, lechemin (champ de vecteurs) est aussi optimal (selon le principe d'optimalité de Bellman).C'est donc un algorithme semi-global, complexe mais régulier et se satisfaisant d'un calculen nombres entiers que nous avons choisi.L'implantation de l'algorithme de programmation dynamique que nousréalisons passe par une transcription sous forme parallèle de celui-ci. Cette formulationparallèle se prête bien au fonctionnement d'un dispositif électronique. De plus lacomplexité de la programmation dynamique séquentielle est O(N 2 ), alors que notreformulation parallèle possède une complexité en O(N) (N étant le nombre de pixels). Cegain en complexité avantage notre réalisation, car le volume de données (image) estimportant. Nous verrons que la complexité spatiale est aussi en O(N).Ces caractéristiques sont favorables à une implantation matérielle, afin deréaliser un appariement en temps réel des images par un système embarqué.6

Les dispositifs matériels basés sur cet algorithme sont répandus en traitementde la parole [Qué88] (cas monodimensionnel), mais peu appliqués au traitement desimages (micro-programmation dynamique µPCD de G. Quénot pour la parole, machined'identification de séquences d'ADN de l'IRISA). Il apparaît que notre formulation del'algorithme permet une réalisation simple, qui n'était pas réalisable jusqu'à présent du faitdu volume des données, et de la structure équivalente à un processeur de traitement designal dédié (DSP) qui était envisagée jusque-là. En effet, le calcul d'une intégrale(nécessaire à l'algorithme) peut être codé par une durée, ce qui favorise une réalisation.Cela rend infini la résolution du terme intégral, quelle que soit la résolution des élémentsde la somme. C'est un résultat impossible à obtenir si l'on conçoit un processeur de calculd'intégrale (DSP dédié) car la complexité spatiale devient un obstacle.La programmation dynamique est à la base de notre algorithme, toutefois, ils'agit d'un problème où les contraintes géométriques sont importantes. Nous nous sommesplacés dans le cadre d'images stéréoscopiques au sens large. Lorsque l'on évoque lastéréoscopie, on fait souvent allusion à des images rectifiées (ou calibrées) qui possèdentdonc une contrainte épipolaire. Nos yeux possèdent cette contrainte (ils sont alignés). Cettedisposition permet la vision en relief, car le cerveau interprète la disparité entre laperception des deux yeux. La stéréovision au sens large, ne pose pas de contrainteépipolaire, et permet, après rectification des images (pour retrouver la contrainte) depercevoir le relief. Une fois effectuée la rectification des images, le relief est un résultat quivient naturellement. L'une des applications immédiates de notre dispositif est lareconstitution tridimensionnelle à partir de deux images dont le contenu (observation) estproche.L'accélération matérielle de l'algorithme de programmation dynamique est untraitement de bas niveau qui s'intègre dans un algorithme élaboré qui permet le recalageprojectif d'un couple d'images. Nous avons pour cela, recours à un processus d'affinementd'un modèle géométrique projectif, au cours d'itérations successives, de faibles résolutionsd'images vers des résolutions plus élevées. Il s'agit d'un processus pyramidald'approximation d'un modèle de transformation géométrique liant les images. Plusieursmodèles ont été expérimentés, dont l'un, de notre conception, possède des paramètres detransformation explicites, pour l'appariement des images.Les modèles géométriques de transformation d'images ne font aucunesupposition sur le contenu de l'image, et modélisent uniquement le mouvementtridimensionnel de la caméra. C’est en ce sens que notre algorithme constitue unerectification stéréoscopique des images, et s'apparente à un problème de calibration decaméras.7

L'algorithme tel que nous l'avons implanté sur différentes plates-formes, dontune machine parallèle (CM5), constitue un simulateur du dispositif matériel. Nous l'avonsformulé en langage séquentiel (C), puis parallèle (C*), pour aboutir à une descriptionmatérielle (en VHDL), qui a été une occasion permanente d'approcher le conceptd'Adéquation entre Algorithme et Architecture en satisfaisant aux Contraintes matérielles(A 3 C) [Pis2000]. Il s'agit d'une validation à chaque étape des caractéristiquesfonctionnelles, bien que l'on aille de plus en plus vers une description structurelle. Il s'agiten fait d'un retour constant des contraintes imposées par la réalisation, vers la descriptionfonctionnelle qui à un haut niveau n'a pas de limitation.Il faut être conscient des capacités et contraintes architecturales, pour réaliserun traitement et concevoir son adéquation matérielle. Les contraintes du traitement, commele temps réel, le coût ou l'embarquabilité, rendent nécessaire une telle adéquation. Leprogrès seul de la technologie ne fait que contribuer partiellement à la réalisationcontraignante des algorithmes complexes de traitement d'images.Ce mémoire de thèse comporte deux parties complémentaires. L'une porte surles principes algorithmiques qui sous-tendent une méthode d'appariement d'imagesaériennes ; l'autre décrit le dispositif matériel qui a été réalisé, qui permet de respecter lescontraintes de temps réel et d'embarquabilité. Le chapitre 1 situe le contexte actuel desméthodes algorithmiques connexes à notre approche. Le chapitre 2 décrit la problématiqued'appariement stéréoscopique d'images dans le cas où les images traitées sont aériennes. Cedeuxième chapitre permet d'énoncer des modèles géométriques de vision qui ont trait à lanature projective des transformations mises en jeu. Il s'agit moins dans ce contexted'étudier le mouvement des constituants de la scène observée, que d'étudier le mouvementglobal induit par le déplacement de l'objectif de prise de vue. Il ne s'agit pas d'un problèmelocal de poursuite d'une cible, mais plutôt de la mesure d'une transformation globaled'image. Nous faisons aussi état du projet de vision (en collaboration avec le Commissariatà l'Énergie Atomique) qui est à l'instigation de notre application. Le chapitre 2 est unsurvol rapide d'une méthode que nous avons analysée et modélisée. Le chapitre 3 découlede l'analyse et de la modélisation, et détaille la mise en oeuvre des concepts énoncés, etprésente des résultats qualitatifs sur des images. Ces trois chapitres aboutissent à uneméthode algorithmique conçue et évaluée. Ils se terminent par une conclusion partielle surla caractérisation de la méthode proposée.La deuxième partie du mémoire porte sur la mise en oeuvre matérielle d'undispositif de vision. La première partie du mémoire aboutit à la conclusion que l'algorithmeest précis dans la mesure robuste qu'il effectue sur les images. Bien que nous ayons eu unsouci constant pour notre algorithme, de faire des choix qui favorisent la réalisabilité entemps réel, les compromis ne permettent pas d'atteindre cet objectif. Les traitements de basniveau, qui vont permettre une décision (grâce à la mesure du déplacement de la caméra),sont très difficiles à réaliser à cause des contraintes de temps réel et d'embarquabilité lié àl'application. Ces contraintes ne peuvent être satisfaites à l'aide des dispositifs matériels8

courants (processeurs généralistes, coprocesseurs, processeurs de traitement de signal,processeurs de traitement d'images etc ...). Il faut avoir recours à la conception dedispositifs dédiés dont l'architecture est très peu conventionnelle. Le chapitre 4 proposeune réflexion sur un modèle architectural qui peut permettre un calcul efficace d'uneprimitive de calcul qui est à la base des traitements effectués par notre algorithme : lamesure du flot optique entre images.Le chapitre 4 ayant permis d'énoncer un modèle de circuit dédié au calcul de laprimitive complexe de bas niveau, c'est à l'optimisation et à l'évaluation d'un prototype quenous consacrons le cinquième chapitre. La deuxième partie de ce mémoire se termine parune conclusion partielle sur l'architecture proposée et son adéquation au problème posé.Enfin une conclusion générale résume nos travaux et ouvre des perspectives quant auxtravaux accomplis dans le cadre de l'application immédiate et des domaines d'applicationproches.9

1ère PartieChapitre 1. Évaluation qualitative de méthodesd'appariement.11

Dans ce qui suit, nous essayons de faire une évaluation qualitative de deuxméthodes d'obtention du champ vectoriel de disparité. Il s'agit, pour obtenir ce champ, dedéterminer à l'aide de deux images, le mouvement individuel de chacun des pixels de l'unedes images (référence) vers l'autre image (à apparier). Deux autres méthodes (la notre, etcelle de Kanade-Okutomi) pourraient être présentées dans cette évaluation. Nous pourrionsprésenter le résultat de notre méthode, mais cela nécessiterait des explications qui serontdétaillées par la suite.La méthode Kanade-Okutomi (http://www.ius.cs.cmu.edu/demo/ko.html) aaussi été évaluée. Cette dernière méthode présente une très faible qualité du résultat. Nousne nous autorisons pas, par conséquent à le présenter. Deux hypothèses peuvent être faitepour cet échec de la méthode. D'une part, nous pourrions avoir utilisé incorrectement lessources qui sont mises publiquement à disposition. D'autre part, les images que nousprésentons sont peut être inadaptées au type de traitement qui est effectué par la méthode"ko".Les deux méthodes présentées sont celles de Changming Sun(http://www.dms.CSIRO.AU/~changs/cgi-bin) et celle de Georges Quénot (qui a bienvoulu mettre à notre disposition un résultat à partir de nos images) que nous remercionstous les deux pour nous avoir guidé dans notre démarche. Les images présentées sontextraites d'une base de couples d'images de l'INRIA (projet SYNTIM), constituée par Jean-Philippe Tarel (http://www-syntim.inria.fr/syntim/analyse/paires-eng.html) etont été corrigées pour obtenir une disparité horizontale (par notre méthode) puisreconstruites par interpolation bilinéaire (qui donne une qualité d'image très conforme àl'original).Ces deux méthodes sont implantées sur des ordinateurs conventionnels, et nous neproposons aucune évaluation temporelle. Il aurait été bien difficile d'évaluer les tempsd'exécution des algorithme, et il n'ont de toute façon pas donné lieu à la réalisation dedispositif d'accélération matériel. Nous ne connaissons pas leur complexité spatiale(nécessité en ressource mémoire), et ils n'ont pas été conçus avec les contraintes de tempsréel et d'embaquabilité qui est notre préoccupation. Ils ne répondent pas au problème dedétermination du mouvement spatial de la caméra que nous élaborons dans les chapitresuivants. Toutefois, par la détermination d'un champ (monodimensionnel) de disparitéentre images, ils constituent une problématique proche de la notre. Ce traitement(bidimensionnel dans notre cas) est rendu nécessaire pour déterminer le mouvement (dansl'espace) du dispositif de prise de vue. Cela sera détaillé par la suite. Il s'agit d'une méthodelocale (Sun) et semi-globale (Quénot) de détermination du champ de disparité.La figure 1.1 présente deux images que l'on a soumises à deux méthodes dedétection du champ de disparité. Ces deux résultats présentent la composante horizontaledu champ de déplacement. Les deux images étant pratiquement alignées horizontalement,le déplacement horizontal représente presque parfaitement le mouvement d'une image à13

l'autre. La composante verticale du champ est très peu prononcée. Plus les pixels desimages des figures 1.2 et 1.3 sont clairs, plus le déplacement horizontal est important(norme du vecteur de disparité).La figure 1.2 présente une méthode de corrélation. C'est une méthode locale. Eneffet, on cherche à identifier des voisinages deux à deux dans les deux images que l'on meten correspondance. Cette méthode consiste à identifier des objets de la scène (grâce aumaximum du pic de corrélation) d'une image à l'autre, en reconnaissant une ressemblancede leur réflectance. Cette méthode de corrélation sera décrite au chapitre suivant,notamment grâce à l'opérateur d'évaluation de ressemblance sur lequel est basé le calcul.La figure 1.3 présente la méthode de Programmation Dynamique Orthogonale(ODP [Qué92]). C'est une méthode semi-globale. En effet, on recherche une ressemblancedes pixels des deux images entre eux (sur une même ligne des deux images), et lacorrespondance locale entre pixels doit être validée globalement grâce à un critère de coûtd'appariement (score global). Plus que l'identification de l'objet en lui-même, il s'agit dereconnaître le contexte dans lequel se trouve un pixel donné. La reconnaissance ducontexte vient apporter à la mise en correspondance une robustesse de calcul, que nepossèdent pas les méthodes locales telles que la méthode de corrélation.Visuellement, le résultat de corrélation (figure 1.2) laisse apparaître des contoursd'objets mal définis comparé à la méthode ODP (figure 1.3). Les zones d'uniformité de laréflectance (zones uniformes des images de la figure 1.1) posent un problèmed'indétermination pour une méthode locale. La robustesse de l'appariement d'un contextevisuel est supérieure à la mise en correspondance isolée de primitives visuelles.Figure 1.1 : Deux images corrigées provenant d'un projet INRIA14

Figure 1.2 : Image de déplacement horizontal obtenue à l'aide de la méthode de corrélationde Changming Sun (CSIRO Australie)Figure 1.3 : Image de déplacement horizontal obtenu à l'aide de la méthode ODP deGeorges Quénot (CNRS IMAG Grenoble)15

Le caractère robuste, grâce à sa globalité, de la méthode de programmationdynamique, étant donné que le problème d'appariement dans notre cas, n'est pasmonodimensionnel, mais bidimensionnel, nous a mis sur la voie de cette méthode. Elle estmieux à même, en terme de précision et de robustesse, de répondre au besoin de mise encorrespondance d'images.La précision intervient dans la détermination juste du vecteur disparité, et donneune image de disparité où l'on peut distinguer, avec une bonne qualité, les objets dans lesdifférents plans où ils se situent.La robustesse intervient par le fait qu'une petite modification du contenu d'imagen'influera que peu sur la précision du résultat d'appariement. Les modifications de contenu,d'un point de vue local, peuvent être constituées des transformations suivantes :- Déplacement dans les deux directions x et y.- Ajout d'un ou plusieurs pixels (un objet apparaît)- Suppression d'un ou plusieurs pixels (élision, un objet disparaît)Ces deux dernières transformations sont naturellement produites parl'occultation d'un objet par un autre.- Modification de luminosité d'un pixel.Cette transformation intervient, car il y a des modifications de contrasteentre images. Les instants de prise de vue peuvent être bien distincts.Toutes ces transformations locales couvrent l'ensemble des transformationsgéométriques de notre application, et du point de vue de l'image globale, se traduisent parles transformations suivantes :- Les transformations modélisables :- Translation- Rotation- Facteur d'échelle- Transformation perspective (Roulis, tangage et lacet)16

- Et les perturbations du champ, non modélisées, auxquelles il faut être rendu non sensible:- Contraste (changement d'illumination de la scène)- Occultation (Ajout et Élision de pixels)- Apparition et disparition d'objets de la scène- Bruit en provenance du capteur.La mise en correspondance d'images aériennes offre, par sa modélisation, un cadrebien défini. Il nous a fallu adapter l'algorithme général pyramidal d'appariement auxcontraintes qui nous sont posées pour l'application. Les contraintes géométriques et dedurée de traitement étant imposées, il faut mettre en oeuvre des choix de réalisation quinous permettent de répondre à ces exigences. La réponse à un tel problème met en oeuvrela conception d'un algorithme de vision, et nécessite aussi la réalisation d'un dispositifmatériel du fait de la complexité algorithmique temporelle des traitements. Il faut bieninterpréter les hypothèses de la méthode de flot optique, et caractériser les contraintes duproblème, pour répondre au mieux aux exigences du projet de vision aérienne auquel nouscontribuons.17

Chapitre 2. Contexte de la vision aérienne pourl'appariement d'images.19

2.1 Vision aérienne et modélisation géométrique.La mise en correspondance d'images dans le contexte de vision aérienne, puisqu'ils'agit du cadre que nous nous sommes fixé, conduit à une définition particulière de laproblématique d'appariement (figure 2.1). Ce que l'on observe à haute altitude (A) estcontenu dans une profondeur de champ (de vision) très réduite. Ce qui est perçu par lacaméra se situe très loin du point focal ( Φ), la formation de l'image sur la rétine constituedonc la projection d'un plan situé dans l'espace (scène plane) sur le plan image. Le relief(H) des constituants de la scène (bâtiments, terrain ...) peut être négligé devant la distancepar rapport au plan image.Le problème que nous nous posons est de mettre en correspondance deux imagesprises dans ces conditions. L'image formée est issue d'une projection spatiale 2 de la scèneobservée sur le plan photosensible. Si l'on considère deux images issue de deux projectionsdistinctes, la transformation projective plane subie d'une image à l'autre peut êtremodélisée. On modélise alors le mouvement de la caméra.Le relief des éléments de la scène étant négligeable, le mouvement de ces élémentspeut être assimilé à une transformation plane, rigide, globale d'image (le mouvement dechaque pixel n'est pas indépendant, mais suit un mouvement d'ensemble que l'on peutdécrire à l'aide de cette transformation).La figure 2.2 donne un exemple d'une scène aérienne (au centre) et de part etd'autre, deux projections de la même scène selon deux angles de vue.Du point de vue géométrique, la projection d'un quadrilatère, dans l'espace, donneun quadrilatère (ou un segment) dans le plan image. Ce quadrilatère projeté, peut subirdiverses transformations :- Des transformations affines- un facteur d'échelle (zoom),- une translation (déplacements transversaux de la caméra),- une rotation (pivotement de la caméra).- Des transformations perspectives- roulis,- tangage,- lacet.Ces transformations définissent pour la caméra 6 degrés de liberté dans l'espace (3degrés de translation et 3 degrés de rotation).2 En fait il s'agit d'une double projection spatiale et temporelle, puisque l'image pour se former sur la rétinephotosensible est projetée spatialement, mais nécessite aussi une intégration temporelle (durée d'acquisition).21

ΦAHA >> HFigure 2.1 : Principe de formation d'une image aérienne prise de l'altitude A (Hypothèse :La hauteur H des éléments de la scène peut être négligée devant l'altitude A de la caméra).22

Figure 2.2 : Projection d'une scène plane sur le plan image.2.1.1 Modèle de transformation projective à paramètres implicites.La scène observée subit toutes les transformations qui sont celles d'un plan(tridimensionnel) projeté sur un autre plan (plan image bidimensionnel). En effet, la scèneest considérée comme plane (1 ère hypothèse) ; sa projection est une transformation noninversible.Si on veut modéliser le mouvement de la caméra dans l'espace, en observant laprojection de la scène sur le plan image, on peut s'aider de la définition de latransformation homographique [Sze93]. Cette transformation associe à tout point M(x,y,z)de l'espace, son projeté M'(x',y') sur le plan image tel que :⎛x' .z' ⎞⎜y' .z' ⎟⎜ ⎟z'⎜ ⎟⎝ 1 ⎠⎛m 00 m 01 m 02 t x ⎞⎛x⎞⎜ m 10 m 11 m 12 t y⎟⎜y⎟= ⎜⎟⎜⎟m 20 m 21 m 22 1z⎜⎟⎜⎟⎝ 0 0 0 1⎠⎝1⎠(2.1)23

M'(x',y',0)X'Y'YXM(x,y,z)Figure 2.3 : Projection d'un point M(x,y,z) de l'espace, dans le plan image, en M'(x',y').Ce modèle est idéal, car il est celui du modèle de sténopé (voir figure 2.3) quiconsidère que l'objectif est un simple trou (idéalement ponctuel) qui laisse passer lesrayons lumineux, en direction du plan photosensible (plan image en z=0). C'est toutefois, lemodèle vers lequel tendent tous les dispositifs de vision, car c'est un modèle sans défautsoptiques 3 .Si on développe le modèle (2.1) on obtient le système (2.2) :Z⎧x' = m x + m y + m z + t 00 01 02 x⎪ mM' = P(M) tel que20x + m 21y + m 22z + 1⎨y' = m x + m y + m z + t 10 11 12 y⎩⎪m 20x + m 21y + m 22z + 1(2.2)C'est un modèle de projection à 11 paramètres qui prend en compte la position(x,y) de chaque point, et son altitude (z). Les paramètres de cette transformation sontdonnés par les caractéristiques optiques de la caméra (calibration).3 Les défauts optiques que l'on cherche à minimiser lorsque l'on construit un dispositif optique sont parexemple le décentrage de l'axe optique par rapport au centre de la zone photosensible, les distorsions radiales(qui sont très apparentes, et de façon voulue sur les objectifs "fish eye") etc ... Tous ces défauts ne sont paspris en compte, car les caméras, et les objectifs actuels tendent à s'en affranchir pour un coût toujoursmoindre.24

Si l'on considère l'ensemble des transformations que peut subir l'image projetée, onse situe dans le plan image, et on pose alors z=0. La transformation projective du planapparaît alors [Dup98]. Cette transformation associe à un point M(x,y) un point M'(x',y')du plan tel qu'il correspond à une transformation projective plane de l'image :⎧x' = m x + m y + t 00 01 x⎪ mM' = T(M) tel que20x + m 21y + 1⎨y' = m 10x + m 11y + t y⎩⎪m 20x + m 21y + 1(2.3)On aboutit à un modèle complet à 8 paramètres qui décrit l'ensemble destransformations que peut subir une scène plane, lorsqu'elle est vue sous deux angles de vuedifférents. Cette transformation est le produit d'une transformation affine par unetransformation perspective. La décomposition en ces deux transformations simples nous aguidé pour élaborer notre propre transformation à paramètres explicites, que nous décrironspar la suite.La définition (2.3) de la transformation projective plane a en effet, l'inconvénientd'avoir des paramètres qui ne sont pas reliés directement aux degrés de liberté dumouvement tridimensionnel de la caméra. Il est plus pratique de pouvoir explicitementdécrire le mouvement de la caméra à l'aide de ses 6 degrés de liberté dans l'espace 3D (3rotations et 3 translations).2.1.2 Modèle de transformation projective plane à paramètres explicites.Si l'on décompose la transformation projective plane implicite de la formule (2.3)on arrive à l'expression (2.4) suivante :⎛M' = T(M) tel quex' ⎞ ⎡⎛m 00 m 01 ⎞⎜ ⎟ = ⎜⎝y'⎠ ⎝ m 10 m 11 ⎠⎟ ⎛⎜ x⎞ ⎝ y ⎠ ⎟ ⎛+ t x⎞⎤⎢⎜⎝t ⎟ ⎥⎣⎢y ⎠ ⎦⎥ / ⎡⎛m 20 ⎞ ⎛x⎜ ⎟. ⎜ ⎞ ⎝ m 21 ⎠ ⎝y⎠ ⎟ ⎤⎢ + 1⎥ (2.4)⎣⎦(2.4) ⇔ M' = T(M) = S(M) / D(M)Le premier crochet (l'expression S(M)) de l'équation est une transformation affineS. La division par le second crochet (scalaire D(M)) correspond donc à la transformationperspective D. La transformation T possède des paramètres implicites (m00, m01, m10,m11 m20 et m21). Au produit (en fait l'opération est une division scalaire) peut êtresubstitué une composition. La similitude S peut s'écrire de façon équivalente, avec desparamètres explicites :25

⎛M' = S(M) tel quex' ⎞⎜⎝y'⎠⎟ = ⎛ zx .cos(α) zy .sin(α) ⎞⎛x − c x ⎞⎜⎝−z x .sin(α) z y .cos(α) ⎟⎜⎠⎝y − c ⎟ y ⎠+ ⎛ t x⎞⎜⎝t ⎟ y ⎠+ ⎛ c x⎞⎜⎝c ⎟ (2.5)y ⎠(2.5) est la composée des transformations affines du plan suivantes :- une rotation d'angle α, et de centre (cx,cy),- une homothétie de rapport zx en x et zy en y,- une translation du vecteur (tx,ty).Les paramètres de S sont donc les suivants :- α angle de rotation- zx facteur d'échelle en x- zy facteur d'échelle en y- cx abscisse du centre de la rotation- cy ordonnée du centre de la rotation- tx translation horizontale- ty translation verticaleLa transformation perspective P du plan peut être énoncée de la façon suivante :⎧x' = (x − N/2).(1+ (y − N/2).tg(λ)/N)+ (y − N / 2).tg(s x ) + N ⎪⎪1 + tg 2 (s x )2M' = P(M) avec ⎨y' = (y − N/2).(1+ (x − N/2).tg(µ)/N)+ (x − N / 2).tg(s y⎪) + N⎪1 + tg 2 (s y )2⎩(2.6)P est une transformation géométrique bilinéaire plane, comportant donc des termespondérés en x, y et xy. Elle est effectuée sur une image dont le système de coordonnées estrapporté au centre de l'image (N/2). Les termes en x et xy pour x', et y et xy pour y',produisent le tangage et le roulis, respectivement. Les termes en y pour x', et x pour y',produisent le lacet en x et y, respectivement. Les termes au dénominateur évitent que lestransformations de lacet ne produisent un facteur d'expansion 4 . L'image est enfin rapportéeaux coordonnées standard (en ajoutant N/2).4 Le modèle de transformation implicite, qui décomposé permet d'énoncer un modèle explicite, possède cettepropriété.26

Les paramètres de la transformation perspective P sont les suivants :- λ angle de tangage- µ angle de roulis- sx angle de lacet en x- sy angle de lacet en yNxN correspond à la taille de l'image (carrée par hypothèse). Les axes de roulis etde tangage sont donc constitués par les deux médianes d'images.La transformation projective du plan est la composée de la transformationperspective P et de la similitude S. Elle est équivalente 5 à l'expression (2.3).(2.3) ⇔ M' = T(M) tel que T = S o P (2.7)Cette transformation équivalente à T de (2.3) est une transformation à paramètresexplicites, comportant 11 paramètres physiques liés au mouvement rigide de la caméraentre les deux prises de vue.Les paramètres de la transformation explicite sont plus nombreux que dans le casimplicite, ils ne sont pas tous indépendants. Déterminer la valeur de ces 11 paramètresconstitue donc un problème de déconvolution.La figure 4 illustre les transformations géométriques élémentaires du modèleexplicite. Elles décrivent la projetée du mouvement dans l'espace de la caméra, et donc lestransformations projectives que peut subir l'image d'un angle de vue à l'autre.5 Ceci n'a pas été formellement démontré ici. Mais les résultats expérimentaux obtenus à l'aide de ce modèle,se correspondent avec les deux formulations.27

RéférenceÉchelle xÉchelle yRotationTranslation xTranslation yTangageRoulisLacet xLacet yFigure 2.4 : Transformations géométriques projectives planes élémentaires.28

2.2 Détermination du mouvement spatial de la caméra.Nous avons défini le contexte de vision aérienne, et le modèle de transformationprojective qui intervient dans la formation des images aériennes. Pour effectuer lamodélisation du déplacement de l'objectif de la caméra, il nous faut mesurer cedéplacement.La caméra est un capteur qui nous donne une information qui peut être représentéesous forme d'une matrice carrée de valeurs d'intensité lumineuse (la réflectance). Chaqueélément de cette matrice est nommé pixel. Dans le problème que nous nous posons, noussommes en présence de deux images proches par leur contenu (la scène observée, dans desconditions particulières où on l'observe). Nous cherchons à établir une transformationprojective du plan, qui permet de lier les deux images.Pour déterminer un mouvement, et obtenir les 11 paramètres de la transformationentre deux images, il nous faut une mesure du déplacement spatial d'un certain nombre depixels d'une image à l'autre. On fait en fait l'hypothèse supplémentaire que le flux lumineuxcapté par la caméra, issu de la réflectance des objets de la scène, est quasi constant.Si l'on modélise le déplacement à l'aide du mouvement estimé de quelques pixels,on dira que l'on a affaire à une méthode éparse [Zha97]. Si au contraire, nous utilisons lemouvement de tous les pixels d'une des images (l'image de référence), pour modéliser ledéplacement, nous nommerons une telle méthode dense [Rob92]. C'est grâce à une mesure(de déplacement) sur les données obtenues par le capteur optique (caméra) que nouspouvons modéliser le mouvement de ce capteur dans l'espace.2.3 Quantification du mouvement spatial de la caméra.Pour effectuer une mesure de ressemblance entre images, nous pouvons le faire àl'aide de quelques opérateurs qui comparent les intensités lumineuses, en effectuant unemesure de déplacement bidimensionnel des pixels. L'un de ces opérateurs (le plus usuel)est l'inter-corrélation. La forme normalisée et centrée de cet opérateur agit sur deux imagesde dimensions identiques en effectuant un produit point à point des matrices de pixelsconstituant les images U et V, tel que:r 2 =⎡⎢⎣⎢∑(x,y)∈image⎤(U xy − U).(V xy − V) ⎥⎦⎥(U xy − U) 2 . (V xy − V) 2∑(x,y)∈image∑(x,y)∈image2(2.8)29

Uxy et Vxy sont les intensités des pixels (luminance) des images U et V. U et Vreprésentent les moyennes des images U et V. L'opérateur est normalisé par le produit desvariances de chacune de ces images (dénominateur).Cet opérateur permet de comparer des voisinages (imagettes extraites des images)et d'identifier leur déplacement. En effet, r est un scalaire compris dans ]0,1] qui mesure laressemblance (1 si U=V) ou la dissemblance (tend vers 0) des images. Si l'on suppose queles images U et V sont proches par le mouvement (des pixels) qui les différencie, on peut,pour chaque pixel de l'image de référence, déterminer dans des voisinages de la secondeimage, quel voisinage (de la première image) lui ressemble le plus. Cette correspondancesera donnée par le maximum du pic de corrélation entre voisinages 6 .Si l'on effectue l'opération d'identification pour un certain nombre de pixels (centresdes voisinages) de l'image de référence, on obtiendra un champ vectoriel de mouvemententre images. Ces vecteurs sont donnés par les maxima de ressemblance entre desvoisinages pris sur chacune des images. Si l'on effectue cette mise en correspondance pourtous les pixels des deux images, les voisinages seront appariés exhaustivement, et on aaffaire alors à une méthode dense.La complexité temporelle d'une telle opération sur deux imagettes carrées estconstante, car le voisinage constitue une partie fixe de l'image d'origine. Si l'on imagineque cette opération est répétée dans un voisinage proche entre les deux images, celaapporte un facteur multiplicatif constant à la complexité temporelle du traitement, qui restedonc inchangée. Puisque cette opération doit être répétée pour chacun des pixels del'image, pour obtenir un résultat dense la complexité est portée à O(N 2 ). N est la tailled'une image carrée NxN à laquelle est appliquée la mise en correspondance. Cela donne lacomplexité temporelle d'un tel algorithme en nombre de calculs de produits point à pointdes matrices pixels des images.L'implantation de cet algorithme, exige un calcul flottant, puisque du fait de lanormalisation de l'opérateur, l'indice de corrélation est un nombre compris dans ]0,1]. Lefait que cette méthode nécessite des calculs flottants, limite beaucoup la "réalisabilité" dedispositifs matériels. Un certain nombre de réalisations ont pourtant été faites, en se basantsur ce calcul (Machine de vision temps réel du C.M.U.[Kan95], algorithme Dauphin del'IGN sur Sympati [...94]). La régularité des calculs est en effet un point favorable àl'accélération matérielle de telles procédures.6 La corrélation calculée donne en effet une courbe, à 2 variables (surface), assez régulière, qui a une formeen "cloche", et dont le maximum identifie la correspondance des voisinages.30

2.4 Principe pyramidal d'appariement d'images aériennes.Nous avons vu que le calcul de la transformation projective liant deux imagespermet de les apparier globalement. Pour définir un algorithme de mise en correspondanced'images, nous nous plaçons dans le cadre de la stéréoscopie généralisée [Wu88]. Souvent,lorsque l'on parle d'images stéréoscopiques, on suppose que celles-ci sont alignéeshorizontalement. Lorsque les images sont alignées (on parle de contrainte épipolaire) touteune géométrie très développée (la géométrie épipolaire) permet de déduire desinformations spatiales de ces images. La recherche du mouvement des pixels se trouvesimplifiée, puisque située dans une direction horizontale. La stéréoscopie avec la contrainted'alignement se rapporte à un problème monodimensionnel. Afin de se ramener à unproblème classique, il est nécessaire d'obtenir des images rectifiées [Loo99]. Larectification d'images quelconques permet de se ramener à un problème 1D.Notre problème de modélisation et mise en correspondance des images estbidimensionnel, donc plus complexe. Il apparaît que si nous recherchons dans le voisinaged'une image, la ressemblance avec une imagette d'une image de référence, nous aimerionsque le déplacement recherché puisse être borné 7 .Si l'on suppose que le déplacement est borné, et pour rendre performante larecherche du mouvement des pixels, la méthode pyramidale peut être proposée [Bur83][Ber92]. Cette méthode consiste à rechercher un mouvement important, et peu précis, à unsous-échantillonnage important des images. Puis, au fur et à mesure des itérations del'algorithme, et avec une définition de plus en plus élevée des images, à affinerl'approximation initiale. En augmentant la résolution des images, nous estimons unevariation de plus en plus faible autour de l'estimation initiale. Nous pouvons donc définirun algorithme efficace d'appariement stéréoscopique d'images tel que sur la figure 2.5 ; ilsera détaillé dans les paragraphes suivants.Tout algorithme pyramidal, dans la recherche de correspondance, n'intègre pasnécessairement la détermination d'un modèle tel que celui que nous avons présenté. Lamise en correspondance d'images peut être effectuée sans qu'aucun modèle physique dumouvement de la caméra ne soit déterminé [Qué96]. Toutefois, la prise en compte d'unmodèle de vision, par la contrainte physique qu'il apporte au processus d'appariement(énoncé du modèle), permet de distinguer la convergence ou la divergence de la méthode,selon la validité des paramètres obtenus. Il est important d'avoir des paramètres dont lasignification physique est non ambiguë, pour pouvoir juger de la pertinence du résultatd'appariement.7 Si nous n'avions pas fait l'hypothèse que ce mouvement est borné, cela aurait porté la complexité del'algorithme de recherche par corrélation à O(N 4 ).31

L'algorithme générique d'appariement pyramidal proposé (figure 2.5), permetd'obtenir trois résultats :- les paramètres approximés d'une transformation projective entre images ;l'approximation du modèle projectif peut être réalisée par une méthode de descente degradient, qui permet à partir d'un champ de vecteurs, et d'un modèle physique, d'estimer lesparamètres du modèle, pour qu'il corresponde au mieux à la mesure.- un coefficient de qualité global r de l'appariement. Il peut être constitué par lecalcul de l'opérateur d'inter-corrélation entre les deux images dont l'une aura été rectifiéepar l'application de la transformation projective plane estimée.- un champ de vecteurs de déplacements dont les vecteurs le constituant sontobtenus précisément, même si la "distance" (résultant de la projection) à laquelle ilscorrespondent est importante.32

ImagesGestion des imagesde la pyramideMesure du champ devecteurs-déplacementApproximation dela transformationliant les imagesSuperposition desdeux images(recalage projectif)Calcul d'uncoefficient dequalité del'appariementOUILeCoefficientest-ilamélioré?NONMeilleurerésolution?OUIPrise en compte dumodèle projectifFINNONFigure 2.5 : Algorithme pyramidal général de mise en correspondance d'images.33

La figure 2.6 illustre ce processus d'affinement d'un vecteur-déplacement par unerecherche pyramidale de correspondance. Le modèle projectif permet de contraindre lechamp mesuré en le lissant après une itération réussie, et entre les résolutions d'images.Son rôle est de donner une cohérence globale au champ de vecteurs estimés. Il s'agit d'unlissage du champ, car le champ recherché a une cohérence globale. Cette cohérence estdonnée par la connaissance du phénomène physique de mouvement des pixels, dû audéplacement de la caméra.La recherche pyramidale multirésolution de correspondance 8 apparie des blocs detaille importante (constitués de beaucoup de pixels) aux premières itérations. La prise encompte d'un bloc de pixels est liée à ce que l'on appelle en traitement du signal le souséchantillonnage. Une valeur unique doit en effet représenter tout un voisinage afin d'êtrecomparée, via une distance lumineuse, à un autre voisinage. Une fois que des blocs detaille importante ont été appariés (appariement grossier), on subdivise ces blocs pouraffiner l'approximation. Le processus se répète jusqu'à la résolution originale des images.La première itération apparie des blocs de pixels, la dernière itération de l'algorithmepermet d'apparier des pixels entre eux et possède la plus grande précision d'estimation.Résolutioninitiale (32x32)RésolutionsIntermédiairesRésolutionFinale (256x256)Figure 2.6 : Recherche pyramidale de correspondance entre voisinages : approximationd'un vecteur.2.5 Détails de l'algorithme générique de mise en correspondance d'images.Différents éléments participent à la définition de l'algorithme de mise encorrespondance d'images. Nous allons détailler chacun de ces éléments. Il s'agit de décrirele principe d'appariement, et d'expliquer la démarche qui conduit à l'élaboration de notrepropre algorithme. Le chapitre suivant précisera les choix d'implantation que nous avonsfaits. Le problème que nous nous posons possède en effet des contraintes (de modélisationet d'implantation) que nous décrirons, qui imposent des choix.8 dénommée aussi "coarse to fine registration".34

2.5.1 Gestion de la pyramide d'images.Le sous-échantillonnage intervient en premier lieu dans l'algorithme pyramidal. Ilest constitué de deux opérations : le filtrage et la décimation. En effet, la pyramided'images est constituée des deux images d'origine (à apparier), et de plusieurs sousrésolutionsde ces mêmes images obtenues par leur sous-échantillonnage.Le filtrage est un filtrage passe bas. Il évite le phénomène d'alaising et élimine lescomposantes de haute fréquence du signal, et prépare la décimation. Le filtrage peut êtrefait à l'aide de différentes fenêtres (carrée, triangulaire, Hann, Hamming, Gaussienne etc...). Ces différents fenêtrages atténuent plus ou moins fortement les artefacts constitués parles raies spectrales secondaires qui apparaissent lorsque l'on examine (à l'aide de latransformée de Fourier) le signal dans le domaine fréquentiel.Cette préoccupation dissertée méthodiquement dans le cas monodimensionnel dutraitement numérique du signal [Pic89], est abordée plus pragmatiquement dans le domainedu traitement des images. Pour ne pas rendre prohibitif le coût temporel des calculs deconvolution par une fenêtre, et pour réduire la taille du support spatial de la fenêtre deconvolution, des approximations de ces fenêtrages sont effectuées. Dans notre domaine detraitement des images, on utilise souvent des filtres (anti-repliement) moyen (fenêtrecarrée), moyen pondéré (approximation du cosinus surélevé de Hann ou Hamming), voirela convolution gaussienne (bien sûr approximée, car la taille du support le nécessite).Puisque nous recherchons la rapidité et la régularité des traitements, le fenêtragecarré a été sélectionné. Ce fenêtrage carré est en effet constitué par le calcul d'une moyenned'intensité de pixels sur un voisinage (qui n'est pas nécessairement un support carré), et nenécessite aucune pondération. Il s'agit d'une convolution simple et régulière.Quel doit alors être le support spatial de fenêtrage (n.n) pour obtenir une sousrésolution d'un facteur s entier ?Nous voulons que le filtre passe-bas coupe les fréquences spatiales supérieures à spixels. Nous imposons la forme du filtre (carré moyen et centré, pour illustrer la nécessitédu filtrage) nous pouvons donc en déduire sa fréquence de coupure. Il suffit d'étudier laréponse fréquentielle du filtre moyen dont la dimension du masque de convolution est n 2 .⎡porte⎡− nTransformée de Fourier2 , n ⎤⎤⎢ ⎣⎢ 2 ⎦⎥ ⎥⎢⎥ =⎢ n ⎥⎣⎢⎦⎥sin ( π.n.f )π.n.f(2.9)35

Pour trouver la fréquence spatiale normalisée de coupure, il suffit donc de résoudrel'équation (2.10) :sin( π.n.f)= 1 π.n.f 2soitsin( 2.y) = y⎧⎨⎩y =π.n.f / 2(2.10)La solution de l'équation (2.10) est obtenue pour y=0.98. Nous en déduisons que :π.f.n = 1.39 (2.11)Si nous appelons s le facteur de réduction entier de l'image, le théorème del'échantillonnage impose que :f < 12.s(2.12)Nous en déduisons l'inéquation suivante :n > 0.89.s (2.13)On peut donc en déduire une règle de filtrage pour le sous échantillonnage desimages:Pour sous échantillonner une image d'un facteur de décimation s entier, il fautappliquer, au moins, un filtre centré moyen de taille n carré 0,89.sLa décimation consiste alors à ne prendre qu'un pixel sur s pixels. Puisque lemasque de convolution doit être centré (pour ne pas changer le pas d'échantillonnage), lesvaleurs convenables pour n sont 3,5,7,9 etc ... Autrement dit :- pour réduire par s=2 ou 3 la taille d'une image, il faut appliquer un filtre moyen detaille n 2 =3x3.- pour réduire par 4 ou 5 la taille d'une image, il faut appliquer un filtre moyen detaille n 2 =5x5.- pour réduire par 6 ou 7 la taille d'une image, il faut appliquer un filtre moyen detaille n 2 =7x7.- et ainsi de suite ...Il s'agit d'un filtrage anti-repliement du spectre spatial des images. Si ce filtragen'est pas appliqué, des effets de moirage apparaissent sur l'image décimée. Ceci correspondà des hautes fréquences repliées dans le domaine de fréquence de l'image (de 0 à 1/2.[pas36

d'échantillonnage]), qui peuvent perturber l'appariement des images par la méthodepyramidale.2.5.2 Modélisation du mouvement global entre images.Le mouvement entre deux images aériennes que nous voulons détecter peut êtredéterminé si les deux hypothèses suivantes sont vérifiées ; d'une part, la réflectance deséléments de la scène se conserve (hypothèse de calcul du flot optique) ; d'autre part, lesimages que nous apparions se recouvrent de manière importante (les images sont fortementcorrélées) et donc, un champ de déplacement peut être déterminé.Le champ de déplacement calculé sur la partie commune des images peut de plusêtre modélisé, car les images correspondent à des images aériennes. Nous pouvons doncdéterminer la transformation projective plane, qui relie ces images. Le champ dense devecteurs que nous cherchons à établir s'appelle plus couramment champ de disparitésstéréoscopique. Il est constitué pour chaque pixel de l'image de référence, d'un vecteur quiindique son déplacement dans la seconde image (voir figures 2.7 et 2.8).La mesure de déplacement d'un pixel ne peut pas être faite indépendamment de sonvoisinage. Un pixel en lui-même n'apporte pas une information suffisante pour identifierun déplacement. Il faut avoir recours à l'examen du voisinage d'un pixel pour trouver unvoisinage équivalent dans une autre image. Afin de trouver le déplacement (disparité) dupixel nous pouvons mesurer localement l'inter-corrélation entre les voisinages adéquats.Ce calcul étant effectué en tout pixel des images (nous voulons obtenir un champdense), il exige un temps considérable lorsque l'on utilise un ordinateur classique actuel. Ils'agit de la partie la plus complexe, et la plus coûteuse en temps de calculs, de l'algorithmepyramidal. C'est sur l'étude et l'accélération d'une telle mise en correspondance que se sontportés nos travaux. Il s'agit d'une mesure du flot optique entre images [Bér99].Il est souvent mentionné le fait que les méthodes de calcul du flot optique,constituent un problème mal posé. En effet, l'hypothèse sous-jacente à ces méthodes estqu'il y a une conservation spatiale et temporelle de la réflectance des éléments projetés dela scène. Un objet, par hypothèse, est reconnaissable, car son aspect (sa perceptionvisuelle) ne se modifie pas au cours des prises de vue. Cette hypothèse n'est presque jamaisvérifiée en toute rigueur. En effet, l'apparence d'un objet dépend certes des conditionsd'éclairage, mais également de la position d'observation, qui va changer entre les deuxprises de vue.Par ailleurs, l'algorithme chargé de reconstituer le flot optique doit être rendurobuste aux variations d'éclairement et aux différentes perturbations optiques (enparticulier l'occultation [Int94]) afin d'agrandir le champ d'application de la méthode.37

Les images aériennes de la figure 2.7 présentent, outre la transformation projectiveliée au mouvement de la caméra, des différences importantes de contraste. Le calcul de flotoptique de la figure 2.8, correspondant aux images de la figure 2.7, a toutefois pu êtreeffectué [LeC97]. Le champ de disparité présente pour ces images une composante derotation importante.Figure 2.7 : Exemple d'images aériennes du CEA.Figure 2.8 : Champ de disparité déduit des images de la figure 2.7 ; le mouvement indiquela façon de transformer l'image de gauche, pour l'amener sur l'image de droite.38

Il faut pouvoir être capable de donner au champ calculé un indice de confiance, quipermette de vérifier, a posteriori, la justesse de l'hypothèse de flot optique. C'est dans cebut qu'une modélisation du champ a été choisie comme partie constituante de l'algorithmepyramidal.Si l'on fait la seconde hypothèse que le champ est modélisable, puisque nousconnaissons un modèle de déplacement de caméra, et si le champ déterminé par la méthodede flot optique ne correspond pas bien au modèle de déplacement, alors soit notre modèleprojectif est imparfait, soit le champ calculé sous l'hypothèse du flot optique est mis endéfaut.Pour une certaine classe d'images (aériennes pour laquelle notre modèle a étéconçu) le modèle est adéquat. Ainsi, si la convergence de l'algorithme n'a pas lieu, nous enconcluons que le calcul du champ de disparité n'est pas fiable, car sans doute l'hypothèsedu flot optique sur laquelle il est basé, n'est pas vérifiée. La méthode de descente degradient nous fournit en effet un indice de conformité entre le modèle et le champexpérimental (indice de corrélation globale).2.5.3 Quantification des paramètres : ajustement du champ par le modèle projectif.À cette étape, nous disposons de deux éléments. D'une part un champ de disparitémesuré, et d'autre part de l'énoncé d'un modèle de transformation projective globale entreles images (implicite ou explicite). Le champ de vecteurs disparité est cohérent (lemouvement des pixels n'est pas indépendant). Ce champ provient de la quantification d'undéplacement tridimensionnel de la caméra, mesuré par une méthode de flot optique. Latransformation projective plane qu'il décrit, peut donc être identifiée.Il s'agit à cette étape de déterminer une série de paramètres, qui décrivent toutautant que le champ de vecteurs, la transformation entre les images. Le modèle dedéplacement est projectif, donc non linéaire. L'algorithme de descente de gradientpermettant l'approximation des paramètres, est par conséquent un algorithme itératif.L'algorithme de descente de gradient nécessite l'estimation de paramètres initiaux(solution initiale). Celui-ci trouve, dans le plan constitué par les dérivées partielles dumodèle, la solution optimale la plus proche de la solution initiale. L'optimalité est définieau sens de la distance choisie pour métrique de l'espace des dérivées partielles.L'algorithme le plus couramment utilisé est l'algorithme de moindres carrés, qui est optimalau sens d'une distance quadratique. Le choix d'une distance quadratique donne lieu à unalgorithme des moindres carrés non linéaire (Non Linear Least Square ou NLLS [Pre92])du fait de la nature projective du modèle de transformation recherché.La solution vers laquelle converge l'algorithme est correcte si les paramètresinitiaux se trouvent proches de la solution ; sinon une solution erronée (minimum local) ou39

aucune solution ne sera trouvée. Un paramètre de mesure d'erreur (coefficient dedétermination) peut être toutefois calculé. Cet indice permet de juger de la validité de lasolution. Il mesure la distance statistique du champ modélisé par rapport au champexpérimental de disparité. Nous sommes donc à même de déduire si l'algorithmed'approximation a convergé vers une solution, juste, erronée, ou s'il n'a pas convergé dutout (divergence). La plupart des difficultés de convergence, si le modèle proposé estcorrect, est liée à une estimation incorrecte des paramètres initiaux.L'approche pyramidale, de la résolution la plus basse à la résolution la plusimportante (coarse to fine), favorise la convergence d'un tel algorithme. En effet, le moduledes vecteurs constituant le champ étant, à la résolution initiale, divisé par le facteur deréduction d'image, c'est un faible déplacement apparent (correspondant à un mouvementréel important à la résolution d'origine) que nous approximons tout d'abord sur les images(réduites). Les paramètres estimés pour la première phase de l'algorithme d'estimation (dumodèle) peuvent donc être constitués par ceux de la transformation identité. Au fur et àmesure des itérations de l'algorithme pyramidal, un mouvement relatif de plus en plusfaible est à approximer.Estimer la transformation identité à l'initialisation (première itération del'algorithme pyramidal) peut se faire si le mouvement apparent entre les images est "faible"(ce qui pourra être vérifié par la convergence). Dans les autres itérations de l'algorithme dela figure 2.5, on réinjecte (si l'approximation a convergé vers une solution correcte) lesparamètres de la transformation déterminés à l'étape précédente.En conséquence, il apparaît alors qu'au cours des itérations de l'algorithme, lesparamètres de la transformation projective sont affinés. Une correspondance entre lesimages est aussi établie (recalage projectif). Il faudra un moyen de mesurer la qualité del'estimation. Cela passe par l'application de la transformation déterminée (constructiond'une mosaïque [Sze96]), et par l'évaluation quantitative de la justesse de cettetransformation.2.5.4 Superposition des deux images (mosaïque) - Vérification qualitative del'appariement.À cette étape, une transformation projective est estimée. L'opération appliquée alorsconsiste à transformer l'image à apparier, pour la superposer à l'image de référence (voirfigure 2.9). On applique sur l'image à apparier la transformation estimée précédemment.Plusieurs algorithmes (de déformation d'images ou "warping" en anglais) permettent detransformer une image à l'aide d'une transformation géométrique. Il faut en effetreconstruire l'image après avoir appliqué la transformation. On peut avoir recours à une40

interpolation bilinéaire voire spline-bicubique. Toutefois, la méthode d'approximation auplus proche voisin est celle qui se prête le mieux à la rapidité et à la simplicité des calculs 9 .L'avantage d'une telle superposition, est surtout pour l'oeil humain (l'opérateur) quipeut apprécier très finement la justesse des paramètres approximés (voir la continuité desconstituants de figure 2.9). Mais puisque nous avons comme objectif de faire un calculautomatique, et sans intervention d'un opérateur, il nous faudra quantifier la justesse de lamise en correspondance à l'aide d'un estimateur.Figure 2.9 : Mosaïque du recalage projectif des images de la figure 2.6.2.5.5 Vérification quantitative de qualité de l'appariement.La superposition - mosaïque - des deux images est un moyen pour l'opérateurhumain de juger de la qualité de l'appariement. Mais il s'agit d'une appréciation subjective,puisque visuelle. Pour effectuer une mesure précise, on applique les paramètres projectifsapproximés. Puis, l'opérateur d'inter-corrélation est calculé sur la totalité des images. Biensûr, on ne peut calculer cet opérateur que sur la zone de recouvrement des deux images. Onévalue ainsi un coefficient global de ressemblance entre images.L'inter-corrélation est un opérateur normalisé (voir formule 2.8). Quel que soit lenombre de pixels qui se recouvrent entre les deux images, et quelle que soit la résolutiond'image, le coefficient de qualité sera valable et comparable. Ainsi, il peut être utile pour9 Elle ne nécessite aucune opération arithmétique sur les pixels.41

juger de la convergence de l'algorithme. La valeur du coefficient est toutefois trèsdépendante du contenu de l'image. Les images ne se ressemblent que partiellement du faitde la distance spatiale et temporelle qui sépare les prises de vue.Pour l'algorithme de mise en correspondance, si le coefficient d'inter-corrélation estmeilleur, le modèle projectif calculé à cette étape sera pris en compte. Sinon la résolutionest augmentée. En effet, à une sous résolution donnée (par exemple si les images sontréduites 8 fois), on ne peut obtenir une précision de calcul qu'au facteur de réduction près(8 pixels). Les vecteurs constituant le champ de disparité ne correspondent qu'à uneapproximation au facteur de réduction près (dans un bloc de pixels 8 par 8). Augmenter larésolution consiste donc à déterminer un champ plus exact, et donc affiner la précision del'approximation du modèle projectif.Si la résolution ne peut être améliorée, nous sommes donc à la résolution originale.À cette résolution le champ de vecteurs disparité est le plus finement approximé. On nepeut obtenir une précision supérieure au pixel. L'algorithme prend donc fin à la résolutioninitiale d'images.A la fin de l'algorithme (à la résolution d'origine), nous sommes en présence desparamètres de la transformation projective modélisée. Nous avons aussi à notre dispositionun champ dense de vecteurs disparité dont la précision d'estimation est faite au pixelprès 10 . Enfin, nous avons le coefficient de qualité de la mise en correspondance d'images(recalage).Ce coefficient dépend du contenu des images (le contenu des images n'est pasidentique). Toutefois, pour certaines d'images se ressemblant, il est possible de choisir unseuil de qualité (40% semble être un bon seuil), permettant de juger à la fin des étapes del'algorithme, de la validité du recalage. Si le seuil n'est pas franchi, c'est que les imagesprésentées ne sont pas conformes aux hypothèses que nous avions formulées enconstruisant notre algorithme.Pour une implantation efficace de cet algorithme, il faut toutefois s'assurer de larobustesse de celui-ci aux conditions réelles de notre application. Il faut se rendre tolérantaux variations d'illumination ambiante de la scène par exemple. Diverses contraintes sont àrespecter dans l'implantation de l'algorithme pour satisfaire les conditions réelles de prisede vue.10 Les vecteurs constituant le champ de disparité indiquent une correspondance de chacun des pixels de l'unedes images, vers l'autre image.42

2.5.6 Invariance à la luminosité ambiante constituant le traitement préalable.Lorsque l'on fait un calcul de flot optique, outre les problèmes de contraste, il fautau préalable se rendre invariant à l'illumination ambiante de la scène [Gro98]. On peutenvisager de traiter les images avec des opérateurs d'ordres supérieurs. Par exemple, ungradient, ou un Laplacien, sont du fait de leur nature différentielle, des opérateurs qui sontinsensibles à la variation d'éclairement de la scène. On peut donc envisager, au lieu detraiter des images de luminance, de traiter des images de gradient (contour) ou de dérivéeseconde (courbure). Toutefois, d'un point de vue fréquentiel, ces opérateurs sont des filtrespasse-haut. Ils éliminent les basses fréquences des images (dont la composante continueambiante) et ne laissent dans l'image que les hautes fréquences. L'inconvénient majeur dece pré traitement, et que la mise en correspondance s'effectuera y compris sur le bruit(haute fréquence) que génère le dispositif optique. C'est donc une solution très peu robuste.Une solution opposée consiste à traiter la luminance des images, et mêmeéventuellement à effectuer une intégration (passe-bas) des images afin de traiter lescomposantes de basses fréquences des images (régions). C'est une méthode beaucoup plusrobuste, mais qui suppose que l'on se rende invariant au niveau continu des images(ambiant) et à la dynamique de la distribution (histogramme) des réflectances des images.Un traiteur d'image dira qu'il faut faire une correction préalable de gain et d'offset desimages. Un statisticien dira qu'il faut normaliser l'image en moyenne, et en variance.Diverses méthodes permettent cette correction. Dans notre contexte, et étant donnéla grande durée qui peut séparer la prise de vue des deux images à apparier, nous avonsopté pour une normalisation a priori des images. C'est-à-dire, que quelle que soit l'image àtraiter, nous ne cherchons pas à ramener la luminance de la seconde image, sur laluminance de la première, mais nous traitons les deux images en leur donnant un éclairagestandard. On peut se ramener à un tel éclairage standard, car on suppose que les deuximages ont un contenu très similaire. En les rendant similaires par leur luminosité ambiante(sans quoi le calcul du flot optique ne peut être réalisé), on peut supposer que l'on pourracomparer les objets qu'elles contiennent par la ressemblance des luminances.L'éclairage standard est défini par un offset de 128 (l'image est en 256 niveaux degris) et par un gain tel que 3 déviations par rapport à l'offset de l'histogramme doivent êtrecomprises entre 0 et 255. Cette normalisation est tout à fait arbitraire (on peut choisir unautre éclairage standard), mais il conditionne les traitements qui vont être effectués par lasuite, et constitue donc une hypothèse de travail. Comment définissons nous alors l'offsetet la déviation ?L'offset peut être calculé comme la moyenne d'intensité sur l'image. La déviationsera alors standard, et sera constituée par la variance de l'image. Ces grandeurs sont alorsdéfinies par :43

Offset moyen = 1 N 2∑ U ij (2.14)(i,j)∈imageDéviation = 1 N∑(i,j)∈image( U ij − offset)2(2.15)Si dans la formule (2.15) offset=offsetmoyen la déviation est alors la déviationstandard ou écart type (la racine carrée de la variance).Des recherches ont montré que si l'on prend pour offset la médiane de l'image, lanormalisation est plus robuste [Pre92]. La médiane définit le mode d'une distributionmodale, et se comporte mieux que la moyenne dans le cas d'une distribution multimodaleou modale bruitée. Le médian est bien plus immune au bruit.Le médian est défini par le niveau d'intensité de l'image tel qu'il y ait autant de pixelplus clairs ou plus sombres (ou égaux) au niveau médian. C'est le niveau de l'histogrammede l'image qui délimite l'équirépartition des intensités autour de celui-ci. Si l'offset estchoisi comme la médiane d'image, la déviation est alors une déviation par rapport auniveau médian, et l'on peut constater que la normalisation standard des images conduit àune bien meilleure invariance par rapport à l'illumination de la scène. On peut définirl'offset médian comme :Offset median = histogramme 1/2 (2.16)Toutefois, il existe une mesure plus fiable de l'offset de l'image. Cette mesure estpartie de la constatation suivante. Si l'on prend le niveau d'intensité le plus bas del'histogramme (minimum de l'image) et le niveau d'intensité le plus haut de l'histogramme(maximum de l'image) on pourrait définir le centre de l'histogramme par la moyennearithmétique suivante :Offset min max = maximum image + min imum image2(2.17)Toutefois une telle mesure est très sensible au bruit dans l'image, les minimum etmaximum étant des moments d'ordre 0. Une telle mesure est très peu précise. Alors, de lamême façon que nous avons défini le médian dans la formule (2.16), nous pouvons définirle centre de la distribution par une mesure plus robuste :Offset centre = histogramme 3/4 + histogramme 1/42(2.18)44

Cette mesure de l'offset de l'image concilie les propriétés de précision d'un calcul demoyenne (de la formule 2.14) et la robustesse d'un calcul médian (comme dans 2.16). Nousavons pu constater expérimentalement, la très grande stabilité d'une normalisation parrapport à ce centre robuste d'histogramme.Cet offset est défini, par la moyenne arithmétique entre les niveaux qui représententle quart de la distribution des pixels, et le niveau qui représente les trois-quarts de ladistribution. Si Offset=Offsetcentre dans la formule (2.15), on obtient la déviation parrapport au centre de la distribution. La mise à un éclairage standard des images consistealors à retrancher Offsetcentre à l'image, à multiplier l'image par un facteur128/(3.Deviationcentre), et à lui ajouter 128. Deviationcentre est définie par :Déviation centre = 1 N∑(i,j)∈image( U ij − offset centre )2(2.19)Si l'on avait considéré la déviation de la formule (2.15) avec Offset=Offsetmoyen,la normalisation à un éclairage standard aurait consisté à ramener la moyenne de l'image à128, et si la distribution de l'histogramme était Gaussienne d'écart type σ, à ramener 3.σentre les niveaux de luminance 0 et 128. Il faut préciser que ce choix n'a pas été fait auhasard, car dans le cas d'une distribution Gaussienne, 3.σ représente aux alentours de99.9% de la distribution (les statisticiens connaissent ce calcul, puisque, pour qu'uneméthode soit réputée fiable, on considère que 3.σ de la distribution des résultats doiventêtre corrects).On peut considérer qu'après une telle normalisation à un éclairage standard,l'histogramme de l'image est d'une part bien centré dans la dynamique des niveaux de gris(de 0 à 255), et que d'autre part, la distribution autour du centre de l'histogramme est bienrépartie puisque la presque totalité de la distribution s'y trouve située (à 1/1000 près). C'estune base de travail, qui va permettre de traiter les images avec un étalonnage précis desniveaux de gris de l'image. Il s'agit d'une correction linéaire de l'histogramme de l'image(aux saturations éventuelles près).45

2.6 Contraintes de notre application, le projet SYRAR.Notre travail s'inscrit dans un projet de conception et de réalisation d'un systèmetemps réel pour la mise en correspondance d'images aériennes. Ce projet se nommeSYstème de Reconnaissance Automatique d'objets en temps Réel 11 . Il a pour butd'effectuer une mise en correspondance d'une primitive d'image, dans deux images. L'uneest par avance connue, car son acquisition est faite par un repérage préalable (imaged'archives). La seconde est prise lors d'une mission, et la primitive qui avait été désignéedans la première image, doit être repérée dans la deuxième, dans un temps qui ne doit pasdépasser la durée d'une seconde (temps réel très strict). Les contraintes de l'application sontbasées sur les transformations géométriques acceptables entre les images. Elles sont lessuivantes :- Rotation +/- 10 degrés- Translation +/- 10% de la taille de l'image- Zoom +/- 10%Ces contraintes géométriques, et la contrainte temporelle, constituent le cahier descharges, et nous permettent d'élaborer une méthode d'appariement. Les images sont enniveaux de gris, et de taille 256x256. Les images pour lesquelles nous effectuons une miseen correspondance sont, de plus, prises à des instants nettement distincts, et desmodifications de contraste et de contenu, interviennent naturellement. Le problème de miseen correspondance est donc très contraint, notamment aussi par la contrainted'embaquabilité du dispositif de traitement.Ce projet a bénéficié de l'apport d'une équipe de travail, et se déroule sur plusieursannées. Diverses méthodes ont été proposées dans le cadre de stages (Thierry Fernandez,Rodrigo Gilbert, Jane You, Kolman Yovo, Pawel Zgagacz, Christophe Demeze, ...), et detravaux de thèse (Dhellier F.). Notre travail s'inscrit donc dans une continuité, et proposeun approfondissement de la problématique, qui nous distingue des travaux précédents, tantpar l'approche proposée, que par les réalisations matérielles auxquelles il a donné lieu.L'énoncé des contraintes de l'application nous permet d'affirmer qu'à unetransformation géométrique près, les images sur lesquelles nous travaillons sont corrélées.Autrement dit, lorsqu'une personne voit les images que l'on traite, elle peut reconnaître unepartie commune, et distinguer leurs différences et leurs ressemblances. Les deux images,puisqu'elles se ressemblent, sont en partie identiques par leur contenu. Ces deux images serecouvrent de façon importante (près de 70% de recouvrement). Ceci n'exclut pas le faitque l'objet que l'on désigne dans l'image de référence, ne fasse plus partie de la secondeimage.11 Ce projet est soutenu par le Commissariat à l'Énergie Atomique (CEA)46

Une méthode pour résoudre le problème peut consister à choisir un objet repérédans la première image, et tenter de le localiser dans la seconde image. Une méthode plusrobuste peut consister à reconnaître le contexte visuel de l'objet à identifier, et à recherchernon pas l'objet en lui-même, mais le contexte auquel il appartient. Ainsi, même si l'objet àidentifier disparaît lors de la seconde prise de vue, une extrapolation permettra de designerl'endroit où l'on aurait dû trouver la correspondance visuelle. La vision humaine fonctionnede cette façon, car un objet recherché est souvent associé à son contexte, et toute personnepeut affirmer "l'objet aurait dû se trouver à telle place" en voyant deux images qui serecouvrent.2.7 Remarques.Dans ce chapitre, nous avons rappelé les bases de la formalisation d'une méthodegénérique pyramidale permettant la mise en correspondance d'images aériennes. Un certainnombre d'hypothèses ont été formulées tenant compte de la spécificité de la visionaérienne. Le contexte de nos travaux a été présenté, et les contraintes du projet ont étéénoncées. Cette méthode générique est reprise dans le chapitre suivant, tenant compted'une approche plus appliquée aux contraintes d'un système de vision, situé dans uncontexte réel.Ce chapitre a été l'occasion de définir une approche pyramidale générique de miseen correspondance d'images. L'énoncé des contraintes liées au contexte de nos travauxpermet d'en préciser les éléments. Chacune des hypothèses donne lieu à un traitement quenous avons mis au point :- filtrage pour la gestion de la pyramide d'image.- normalisation des images pour respecter l'hypothèse de flot optique.- modèle géométrique qui conditionne l'algorithme d'appariement.- construction d'une mosaïque qui permet la quantification de la qualité du recalage.- méthode d'approximation bidimensionnelle du flot optique (moindres carrés 2D).- etc ...Par la suite, il faut mettre en oeuvre des choix d'algorithme, paramétrer ceux-ci afinqu'ils donnent des résultats satisfaisants dans le cadre de travail qui a été défini. Un premierpas vers la définition d'une méthode robuste a été fait, puisque l'on sait se rendre invariantà l'éclairage ambiant. C'est une condition préalable à toute autre ébauche de réalisation. Onne peut en effet comparer deux images que si elles sont placées dans les mêmes conditionsde luminosité. D'autres caractéristiques de la méthode ont été définies qui autorisent uncalcul fiable sur des images réelles. C'est autant une définition précise de notre méthode,que les critères de robustesse, la justification de paramètres (pour le calcul automatique)qui seront définis dans le chapitre suivant.47

La méthode de mesure du flot optique entre images est un point délicat del'algorithme. Une étude poussée a été faite sur la réalisation de celui-ci. Une fois cettemesure effectuée, la modélisation du champ de disparité peut être entreprise. Il y a doncdeux niveaux dans la hiérarchie des algorithmes de vision. La mesure du flot optique sesitue au bas niveau. Le niveau intermédiaire est constitué par une extraction decaractéristiques (paramètres) de ces images. Nous sommes à même d'extraire quelquesparamètres de la mesure, qui caractérisent le mouvement de la caméra que l'on veutidentifier. L'obtention de ces quelques paramètres physiques qui décrivent le mouvement,ouvre la voie à un niveau supérieur qui sera constitué par une prise de décision. Notreméthode couvre donc les deux niveaux inférieurs dans le classement des algorithmes devision (bas et intermédiaire).C'est dans le but que des fondations solides permettent une prise de décision fiable,que nous nous situons délibérément dans les deux niveaux inférieurs des méthodes devision. La prise de décision est du domaine de l'intelligence artificielle (IA) et de la fusionde données multicapteur, et l'exploitation des résultats obtenus ne sont pas le but de notrerecherche. Nous avons toutefois, à défaut d'exploiter les résultats (paramètres dumouvement), donné une interprétation de ceux-ci qui permet de comprendre la manièredont ils peuvent être utilisés.48

Chapitre 3. Mise en oeuvre d'une méthode d'appariementd'images.49

Dans le chapitre précédent, nous avons décrit la problématique d'appariement dansle cas de mise en correspondance d'images aériennes. Nous avons précisé le cadreformalisé du domaine de la vision aérienne, et le contexte dans lequel se situent nostravaux. Ce nouveau chapitre va nous permettre de mieux définir les choix que nous avonsfaits, pour satisfaire les contraintes de notre application, et sélectionner parmi les méthodeset algorithmes, ceux qui permettent d'élaborer notre propre système de vision. L'algorithmegénéral pyramidal, décrit au chapitre précédent, est ici repris et détaillé par notre propreapproche. Les choix de méthodes sont souvent guidés par des soucis de complexitétemporelle, et de réalisabilité matérielle. Lorsque nous concevons un algorithme, lacontrainte temporelle de notre réalisation, impose que l'algorithme ait une transpositionmatérielle aisée. Ce chapitre reprend la structure du précédent en en détaillant lesconstituants.3.1 Énoncé de la méthode d'appariement d'images aériennes.La méthode algorithmique d'appariement global d'images aériennes est donnée parle synoptique (figure 3.2). Elle peut être énoncée de la manière suivante.La méthode apparie deux images (Im1 et Im2) en suivant un processus multirésolution(pyramidal) [Lec97]. Elle débute par un sous échantillonnage initial, ce quicorrespond à la plus basse résolution (typiquement 32x32). Elle finit avec la résolution laplus élevée (avec les images originales). Un vecteur de déplacement est ainsi déterminépour chaque pixel de l'image Im1. Ce processus de calcul par étapes de recalage projectifest présenté sur la figure 3.1. La première étape (à la plus basse résolution) estime toutd'abord un vecteur approximatif, puis la composante résiduelle est affinée aux résolutionsplus élevées.yHauteM ˜ r" x,ij x + M ˜ r" y,ij yIntermédiaireM ˜ r' x,ij x + M ˜ r' y,ij yBasse résolutionM ˜ rx,ij x + M ˜ ry,ij yxFigure 3.1 : Estimations successives d'un vecteur disparité (parmi le champ) par étapespyramidales de recalage projectif.51

A une résolution donnée les étapes suivantes sont effectuées :(1&2) Calcul du champ de disparité entre l'image 1 et l'image 2. Il est effectué en deuxphases horizontales et verticales indépendantes 12 , qui permettent d'obtenir les composantesrespectives du champ. C'est l'opération la plus coûteuse et délicate de l'algorithme (il s'agitd'un calcul de flot optique). Nos travaux se sont principalement portés sur l'étude d'un telcalcul. Il est réalisé dans notre cas, par l'algorithme de programmation dynamique que nousdétaillerons. C'est sur l'étude de la formulation, des optimisations logicielles et matérielles,de l'ajustement des paramètres (ou poids), et l'évaluation de performances, que nousconsacrons une grande part de ce manuscrit.(3) La somme vectorielle des composantes obtenues précédemment, est effectuée. Cecipermet d'obtenir un champ de vecteurs bidimensionnels (flot optique).(4) Approximation du champ de vecteurs par une transformation globale projective plane.Cela permet de caractériser les paramètres physiques (a) de déplacement de la caméraentre les deux prises de vue.(5) Projection (warping) de la première image sur la seconde à l'aide des paramètres (a)estimés précédemment.(6) Calcul d'un coefficient r de corrélation entre la première image recalée, et la seconde.- Si le coefficient r est plus élevé que le précédant (initialement 0), l'image 1projetée à cette étape, est conservée pour les traitements qui suivent.- Sinon, nous améliorons la résolution des images, en prenant en compte lameilleure transformation projective estimée jusque là.12 Cette indépendance est autorisée par la propriété de séparabilité des composantes du champs vectoriel dedéplacement (flot optique).52

a = paramètres ( Identité )r = 0, Im1 & Im2 à 32x32Im1, Im2Calcul des disparitéshorizontales et verticales (PD)Dx, DyDx, DySomme vectorielle des diparitésDijDijApproximation de transformationprojective par moindres carrésa'Im1, Im2Recalage des imagesIm1', Im2Im1', Im2Calcul ducoefficient de corrélationr'(1&2)(3)(4)(5)(6)a, a' = vecteurs deparamètres de latransformation projectiver, r' = coefficients decorrélationIm1, Im2 = imagesOUIr' > r?OUIIm1 = Im1'r = r' a=a'NONMeilleurerésolution?FINNONFigure 3.2 : Synoptique de la méthode d'appariement global d'images.53

Nous décrirons par la suite chacun des éléments qui composent cette méthoded'appariement. C'est une méthode globale, car les paramètres déterminés lors del'approximation des moindres carrés permet un recalage projectif global pour les images.C'est une démarche qui nous distingue des travaux où ce sont des régions ou des blocsd'images qui sont appariés, souvent à l'aide de transformations affines (linéaires), pourréaliser une compensation locale de mouvement (cf. norme du Moving Picture ExpertGroup MPEG 1&2). Cette méthode a pour objectif d'approximer le mouvement réel globaldu dispositif de prise de vue. Il n'est pas caractérisé par le mouvement des diversconstituants de la scène individuellement (mouvement local), mais par le mouvementglobal induit par le déplacement de l'objectif de prise de vue. Tout mouvement particulierd'un objet par rapport au mouvement général de l'image, n'est pas considéré par notreméthode. Ces déplacements individuels de constituants de la scène ne seront pasmodélisés, et sont donc considérés comme des défauts du champ de disparité.La compensation de mouvement à l'aide de blocs ou régions d'images, est souventfaite dans un but de compression de séquences d'images. Notre but, est d'effectuer unemesure physique précise du mouvement de la caméra. Une méthode semblable à la notre,que l'on appliquerait sur des régions d'images, constituerait sans doute une méthode troplourde, pour être appliquée, par exemple, dans le cadre d'une compensation de mouvementpour la compression de séquences d'images. Elle donne toutefois des résultatsencourageant temporellement et qualitativement pour une compensation globale demouvement.3.2 Création de la pyramide d'imagesLa réduction de résolution des images est une opération de décimation. Elleconsiste à ne conserver qu'un pixel parmi un certain nombre dans un voisinage. Toutefois,nous avons démontré au chapitre précédent, que cette opération ne peut être effectuée sansun filtrage passe-bas préalable. Pour réduire une image 256x256 en une image 32x32, cequi correspond à une réduction d'un facteur 8, il faut nécessairement appliquer un filtre deconvolution moyen de dimension 9x9. D'autres types de filtres de convolution sontenvisageables, mais le masque de convolution moyen est le plus aisé et rapide à appliquer.Toutefois, comme nous le verrons par la suite, la méthode que nous appliquons,inspirée de l'Orthogonal Dynamic Programming (ODP) [Qué92], consiste à effectuer desbalayages d'images horizontaux et verticaux indépendants, afin de déterminer lescomposantes indépendantes horizontales et verticales du champ de mouvementbidimensionnel (flot optique). Si l'on veut obtenir un champ de déplacement cohérent, etbien que l'appariement sur les diverses lignes (ou colonnes) d'images soit indépendant entreces lignes (ou colonnes) [Anc93], il apparaît nécessaire de corréler ces lignes (ou colonnes)entre elles.54

Nous appliquons un masque de convolution, qui non seulement permet de souséchantillonnerles images, mais aussi de corréler les lignes (ou colonnes) entre elles. Celacontraint alors à appliquer notre méthode sur des images pseudo-stationnaires 13 . Il esteffectué un filtrage passe-bas important sur les images, qui élimine le bruit des images, etrend les images traitées stationnaires dans la direction perpendiculaire à la recherche dumouvement. Pour effectuer une recherche horizontale de déplacement, il faut prendre encompte non pas une ligne isolée, mais un vecteur-ligne représentant une bande horizontalelarge de l'image. Les masques de convolution appliqués pour former des bandes d'images,se recouvrent de façon importante.Le filtrage que nous effectuons a donc deux fonctions utiles. Longitudinalement(horizontalement pour les lignes et verticalement pour les colonnes d'images), il permet deréduire correctement la dimension des images (pour respecter le théorème del'échantillonnage). Le même traitement est appliqué aux deux images à apparier.Perpendiculairement, il permet non seulement la réduction, mais en plus, il rend les imagesstationnaires dans cette direction (les lignes (ou colonnes) sont corrélées entre elles). Letableau 3.1 indique des tailles convenables de masques de convolution moyen, que nousappliquons pour obtenir des bandes horizontales ou verticales à différentes résolutionsd'images.Facteur de réduction d'image Dimension longitudinale dumasque moyenDimension transversale dumasque moyen8 9 454 5 252 3 151 1 5Tableau 3.1: Dimension du masque de convolution moyen permettant la constitution desous-résolution d'images.Nous avons en effet pu déterminer qu'un masque transversalement 5 fois plus granddonne de bon résultat quant à la stationnarité des images, et à la cohérence du champ dedisparité obtenu. La dimension longitudinale respecte strictement le théorème del'échantillonnage.13 Une image stationnaire est une image dont les voisinages sont corrélés. Seule une image de synthèse peutposséder cette propriété. Une image non-stationnaire est un bruit décorrélé. Une image pseudo-stationnaireest une image qui possède des propriétés intermédiaires.55

3.3 Programmation dynamique monodimensionelle.L'algorithme de programmation dynamique [Bel57] emprunte son nom à undomaine où il a été appliqué initialement : l'étude de systèmes dynamiques. Il s'agit dedécrire un système, qui évolue selon des lois physiques. Il permet dans le même ordred'idée d'optimiser sous contrainte, le calcul de trajectoires. Il a subi des évolutions, pourdes applications dans le domaine du traitement de la parole, avec l'adjonction de modèlesprobabilistes de locution (l'algorithme de Viterbi). La programmation dynamique permetde trouver dans un graphe, le chemin de correspondance optimal, selon un critère de coûtchoisi. La décision de parcourir un arc du graphe est guidée à chaque étape par un choixoptimal. Le fait qu'une décision optimale soit prise à chaque étape, quelles que soient lesconditions initiales, garantit l'optimalité globale de la solution 14 .L'algorithme de programmation dynamique permet en particulier de déterminer lechemin le plus court, pour la mise en correspondance de deux vecteurs constitués, dansnotre cas, par les luminances de deux lignes ou deux colonnes d'images. Il s'apparente auproblème du voyageur de commerce. En effet, une ligne ou une colonne de l'image définitun graphe 2D (matrice) orienté dans lequel nous cherchons un circuit hamiltonien [Min83](chaque noeud du graphe n'est atteint qu'une seule fois). Si l'on considère la matrice deprogrammation dynamique, formée par les distances élémentaires entre pixels, nouspourrons déterminer une distance globale (score) entre lignes (resp. colonnes) d'images,qui minimise la somme des distances locales affectée d'un coût. La distance élémentaire etle coût sont combinés dans une fonction choisie pour ses propriétés intéressantesconcernant notre application. Nous l'avons appelé fonction de coût. Elle favorise ledéveloppement de chemins diagonaux dans la matrice de programmation dynamique(ressemblance) et évite la divergence du chemin lorsque deux zones d'images identiquessont rencontrées. Ce sont des caractéristiques qui favorisent la robustesse de l'appariement.Le score ou distance globale entre lignes (resp. colonnes) est déterminé dans le piredes cas en 2.N étapes (N étant la taille de la ligne). Il détermine, selon notre implantation(parallèle), la complexité algorithmique du processus d'appariement. Le chemin ou circuitdéterminé dans le graphe (grille 2D de la matrice de programmation dynamique) permet dedéterminer, grâce à l'écart à la diagonale de la matrice, le vecteur de déplacement oudisparité stéréoscopique de chaque pixel d'image.3.3.1 Formulation mathématique.Soit la matrice de programmation dynamique constituée des distances élémentairesdij entre les éléments des vecteurs à apparier. Si l'on considère deux k èmes lignes (oucolonnes) des images U et V, formant les vecteurs Uk et Vk. Si l'on choisit commedistance élémentaire la distance L1 de Minkowski, dij est défini par :14 Selon le principe d'optimalité énoncé par Bellman.56

d ij = U ki − V kj (3.1)Il s'agit d'une distance élémentaire entre les luminances des pixels. Effectuer uncalcul de programmation dynamique, et rechercher le chemin optimal entre les vecteurs Uket Vk consiste à calculer le score tel que :score = Min ∑ d ij .C(s) (3.2)che min sLes chemins se développent depuis l'origine de la matrice de programmationdynamique (d00) et se terminent au dernier élément (dnn). Un chemin local peut sedévelopper dans l'une des 3 directions possibles (figure 3.3), que l'on nommeraorthogonale inférieure ou supérieure, ou diagonale (le graphe est orienté).Chemin associéà n élémentsE3 Chemins associésEst SE et Sud, à (n+1)élémentsSSEFigure 3.3 : 3 directions de développement d'un chemin local dans la matrice deprogrammation dynamique.Chaque élément de la matrice de programmation dynamique (noeud du graphe) nepeut être parcouru qu'une seule fois (on cherche un circuit hamiltonien). Si l'on considèreun cas symétrique de l'algorithme (le seul qui ait une utilité en traitement des images) C(s)est un coût local associé au développement d'un chemin. Il est identique dans les deuxdirections orthogonales (symétrie). On définit la pénalité orthogonale par :γ= C(orthogonal)C(diagonal)(3.3)s correspond à une direction de développement du chemin. Si l'on recherche lechemin le plus court entre les deux vecteurs, ce rapport est compris dans l'intervalle ]1, 2[.Le choix correct de ce coût C(s), ainsi que de la distance dij, déterminera la robustesse, laprécision, l'optimalité de la solution du calcul de programmation dynamique, et la vitesse57

d'exécution (l'algorithme est piloté par les données images). Pour illustrer le calcul de cetalgorithme, nous présentons maintenant quelques exemples, sur des images de synthèse.3.3.2 Exemples sur des images de synthèse : cas monodimensionnel.Dans les différents exemples que nous présentons, les images considérées sontmonodimensionelles. Elles représentent des sinusoïdes et des sinusoïdes distordues. Lamise en correspondance des images consiste donc à former deux vecteurs Uk et Vk (karbitraire) à partir de deux lignes d'images. Il s'agira ensuite, de calculer dij de la formule(3.1), et de former le score de la formule (3.2). Ce qui nous intéresse dans ces différentscalculs, est le chemin optimal représenté en noir dans la matrice (au centre d'un nuage gris,qui sera expliqué par la suite). Sur les axes sont figurés les vecteurs lignes qui constituentles données d'images à mettre en correspondance.58

a) IdentitéUUkiimage de référenceVVkj Calcul de programmationdynamiqueimage à comparerFigure 3.4 : Mise en correspondance de deux images identiquesCe cas de figure présente un chemin optimal de correspondance entre les deuxvecteurs, qui suit une diagonale parfaite. La position du chemin indique la correspondanceélastique des éléments des vecteurs considérés. Ce chemin suivant la diagonale de lamatrice de programmation dynamique indique que chacun des éléments des vecteurs, telsqu'ils se suivent, se correspondent exactement.59

) L'ajoutUUkiimage de référenceVVkj Calcul de programmationdynamiqueimage à comparerFigure 3.5 : Mise en correspondance dans le cas d'un ajoutDans cet exemple, les sinusoïdes des deux images ont la même période. Elles ontété déphasées par rapport au bord de l'image (translation spatiale) ; et de plus, au milieu del'image à comparer, sept pixels ont été ajoutés. Le chemin est d'abord situé en dessous de ladiagonale de la matrice. Cela correspond au déphasage. Puis, à partir du milieu de l'image,le chemin subit un décrochement au-dessus du chemin initial (sous diagonal). Cedécrochement est de 7 unités au-dessus de la diagonale initiale (compté horizontalement).Ces 7 unités correspondent aux 7 pixels ayant été ajoutés dans l'image à comparer.Cet exemple met en évidence que le chemin de programmation dynamique peutnous renseigner, par l'écart par rapport à la diagonale de la matrice, sur l'ajout de pixelsentre les images. Il nous renseigne aussi sur l'importance du décalage (translation) entrecelles-ci. C'est en examinant le chemin optimal déterminé dans la matrice de60

programmation dynamique, que l'on trouve le vecteur de disparité (déplacement d'uneimage à l'autre) et donc le mouvement des pixels recherché.c) L'élisionUUkiimage de référenceVVkj Calcul de programmationdynamiqueimage à comparerFigure 3.6 : Mise en correspondance dans le cas d'une élisionL'élision est le cas dual de l'ajout. Nous sommes dans les mêmes conditions queprécédemment, avec deux images constituées de sinusoïdes de même période. Le chemininitial se situe en dessous de la diagonale (comme pour l'ajout). Puis, au milieu de l'image àcomparer, 7 pixels d'une image sinusoïdale ont été retirés. Le chemin dans la matrice subitdonc un décrochement de 7 unités en dessous de la diagonale initiale. L'écart à la diagonalede la matrice (relevé horizontalement) nous renseigne, pour chaque pixel, sur lacomposante horizontale du vecteur déplacement (disparité). Les images que l'on a conçuespour cet exemple ont une disparité purement horizontale. Le flot optique entre les images61

est donc complètement déterminé par la mise en correspondance par programmationdynamique effectuée entre deux lignes quelconques de ces images.c) Le changement d'échelleUUkiimage de référenceVVkj Calcul de programmationdynamiqueimage à comparerFigure 3.7 : Mise en correspondance dans le cas d'un changement de fréquenceDans ce cas de figure, les deux images contiennent des sinusoïdes de périodesdifférentes. Le chemin de programmation dynamique s'écarte de la diagonale d'unemanière linéaire. La pente de la droite (discrétisée) que suit le chemin, peut nousrenseigner sur le rapport des périodes des signaux comparés.Remarque : Tous ces exemples sont des cas particuliers de transformations élémentairesidentifiés par le calcul. On a mis en évidence la translation, l'ajout de pixel, l'élision depixels et le changement d'échelle. Ces transformations, combinées entre elles, permettentde comparer des signaux complexes, et de trouver un champ de vecteurs correspondant à62

une déformation élastique. Il y a lieu de généraliser cette mise en correspondance afin depermettre la comparaison élastique de signaux bidimensionnels (images réelles).3.3.3 Distance lumineuse : la fonction de coût.L'équation (3.2) fait apparaître une distance dij qui est fonction de la luminance despixels que nous mettons en correspondance. Cette distance est très caractéristique duproblème que nous avons à résoudre par programmation dynamique.∑score = Min d ij .C(s)che min s(3.2) rappelNous avons à comparer des pixels d'images. La distance lumineuse doit donc avoircertaines propriétés.Les propriétés de la distance lumineuse sont les suivantes :- Une faible différence d'intensité (de l'ordre de U ki − V kj ≈ 10) doit conduire àune faible croissance de la distance lumineuse. Ainsi, le bruit, une légère différence decontraste entre images par exemples, ne perturberont pas la mesure. Cela renforce larobustesse de l'appariement. L'algorithme sera insensible par exemple, au bruit généré parla caméra.- Une forte différence d'intensité (de l'ordre de U ki − V kj ≈ 100) doit conduire àune saturation de la fonction de coût. dij.C(s) forme la fonction de coût, et il est inutiled'augmenter celle-ci au-delà d'un certain seuil. En effet, les pixels trop différents par leurluminance ne peuvent se correspondre (sous nos hypothèse). Les chemins qui ont un coûtmaximal ne participent pas à l'élaboration du chemin optimal dans la matrice deprogrammation dynamique. La saturation interviendra par exemple dans le cas d'un refletdans l'image.- Une variation moyenne d'intensité doit conduire à une croissance linéaire de lafonction de coût. Toutes les intensités des pixels (lorsqu'elles correspondent à une variationmoyenne) ont ainsi un poids égal vis-à-vis de la fonction de coût.- De plus, la distance doit être codée sur un nombre limité de bits (8, 16, 32) poursatisfaire un calcul en entiers 15 .15 Les calculs effectués en traitement d'images, sont la plupart du temps effectués sur des entiers. Celagarantit certaines performances sur les machines actuelles, bien que les calculs soient complexes. De plus, lesimages sont numériques, et donc les pixels les constituants sont codés sur des octets (8 bits, de 0 à 255).63

Toutes ces propriétés définissent assez bien ce que l'on appelle en traitement dusignal, une fonction de compression de dynamique. Parmi les fonctions mathématiquessatisfaisant ces propriétés, nous avons choisi la suivante [Pis96] :⎧ ⎛ ⎛d ij = L min α. U ki − V kj ⎞⎞⎜,α⎪ ⎜⎟⎝ ⎝ 255 ⎠⎟⎨⎠⎪L(x) =δ(s). 1 − cos(π.x) +β(s)⎩⎪2(3.4)- α fixe le support d'excursion de la fonction de coût, et sa saturation.- δ fixe la dynamique de la fonction. Cela permet de représenter les valeurs de lafonction sur un nombre de bits fini, pour un calcul entier.- β permet que la fonction de coût ne soit pas nulle pour une différence nulleU ki − V kj . En effet, une fonction de coût qui prendrait une valeur nulle dans les troisdirections de développement de chemins engendrerait une divergence du chemin lorsquedeux zones d'images identiques seraient comparées (d'où la nécessite d'un coût additif).Le rôle de la fonction est de limiter la dynamique de codage du coût local, afin defixer la sensibilité et la discriminance du coût, par rapport à la perception (niveaux deluminance des pixels). La figure 3.8 illustre les fonctions de coût orthogonales et diagonaleavec les poids que nous avons pu déterminer expérimentalement pour satisfaire autraitement de la base d'images dont nous disposons.605040302010-150 -100 -50 50 100 150Figure 3.8 : Fonctions de coût orthogonal (haut) et diagonal (bas) de l'algorithme deprogrammation dynamique. En abscisse U ki − V kj . En ordonnée dij.C(s).64

Cette fonction de coût est fonction de la luminance, et prend des valeurs discrètes etentières. Étant donné la dynamique de codage de celle-ci, la figure 3.8 laisse apparaître unefonction presque continue.Nous avons pu déterminer expérimentalement qu'une pénalitéγ= C(orthogonal) = 4/3 donne de très bons résultats sur la base d'images dont nousC(diagonal)disposons. Il s'agit du rapport homothétique des courbes de coût diagonal et orthogonal.Plus γ est grand, plus les chemins diagonaux sont favorisés. γ constitue une pénalitéorthogonale. La valeur choisie correspond à un équilibre entre le développement deschemins orthogonaux et diagonaux. γ agit comme une force de rappel du chemin (dans lamatrice de programmation dynamique), par rapport à la direction diagonale de la matrice.On recherche donc une ressemblance entre pixels.Nous avons vu dans le chapitre précédent que la variance des images était fixée defaçon à ce que 3.σ (3 déviations), soient placés entre 0 et 128. Si l'écart type des images Uet V est σ (identique puisque les images ont un éclairage standard), l'écart type de ladifférence U ki − V kj est σ. 2. Nous avons pu déterminer expérimentalement que lasaturation, fixée par le coefficient α, est bien choisie lorsqu'elle correspond à 256. 2 /3.C'est-à-dire que la fonction de coût sature exactement à deux écarts types de la quantitéU ki − V kj . Cette saturation correspond à la valeur 120.7 (voir figure 3.8). D'oùα=3/traitées.2. Ce paramètre est fixé par l'étalonnage préalable, en luminance des imagesLe niveau maximum des deux fonctions de coût, qui correspond à la saturation de lafonction pour s=orthogonal, est fixé à 63. Les valeurs de la fonction de coût peuvent doncêtre codées sur 6 bits. Nous avons en effet choisi une fonction de coût prenant des valeursdiscrètes et entières. Cela peut trouver une explication dans le fait qu'il est admis que l'oeilhumain distingue 64 niveaux d'intensités lumineuses. Si la fonction de coût discrimine 64niveaux, on peut penser qu'elle permet d'obtenir un résultat au moins aussi précis que ceque pourrait voir l'oeil humain.On a choisi β(orthogonal) = 4 et β(diagonal) = 3 (dans le même rapport que γ).δ(s) est un coût multiplicatif, et β(s)un coût additif. Nous avons donc fixé dans le mêmerapport ces deux coûts.δ(s) est choisi tel que dij.C(orthogonal) prenne à son maximum lavaleur 63 (la fonction orthogonale utilise toute la dynamique de codage). Étant donné lechoix de γ, les valeurs de δ(s) se déduisent par le calcul de normalisation de la fonction decoût (à 64 niveaux).65

La fonction de coût détermine un comportement local optimal, pour l'appariementdes pixels d'images, pour toutes les combinaisons de pixels, prises deux à deux.L'algorithme minimise la somme des coûts locaux sur la globalité de la ligne, en formant lescore. La correspondance locale est validée par la minimisation d'une somme globale. Laméthode de calcul du flot optique, est donc pour l'appariement de bas niveau (celui despixels), une méthode semi-globale. Ce n'est pas le cas des méthodes basées sur lacorrélation, qui sont locales (cf. chapitre 2).Les phénomènes d'occultation sont pris en compte par la programmationdynamique. Des exemples ont été donnés dans le cas de l'ajout et de l'élision de pixels.L'algorithme de programmation dynamique est donc particulièrement bien adapté à lamesure du flot optique entre les images. Il permet d'obtenir un champ de vecteurs dedisparité dense, puisque le déplacement individuel de chaque pixel est obtenu.Si comme dans le cas des images monodimensionelles, le champ de disparité estobtenu directement par le calcul de l'algorithme de programmation dynamique, pourquoiest-il nécessaire d'employer une méthode pyramidale ? La réponse est la suivante.Le calcul du flot optique ne peut être effectué, si on dispose d'un algorithme deprogrammation dynamique monodimensionnel, que si les images traitées se différencientpar une transformation dont les paramètres sont proches de la transformation identité, c'està-dire,si les images sont proches par leur contenu (corrélées). Des algorithmes deprogrammation dynamique mutidimensionnels sont envisageables [Vas98], mais ils ontune complexité algorithmique élevée, et sont difficilement transposables à des dispositifsmatériels dédiés.La méthode pyramidale permet d'augmenter la portée spatiale, l'excursion du calculde programmation dynamique. Elle conserve de plus, dans la détermination du champ devecteurs, une précision égale au pixel. Ceci permet d'exploiter le résultat du champ devecteurs avec l'approximation d'un modèle de transformation continu, et d'obtenir lerésultat du calcul du modèle projectif, avec une précision sub-pixel. Même si la disparitédes images est importante, la méthode pyramidale conserve la précision du calcul.Une formulation algorithmique détaillée de l'algorithme de programmationdynamique, découlant de la formulation mathématique sera donnée dans le chapitrecorrespondant à l'architecture du dispositif de vision (chapitre 5). La formulationalgorithmique nous est propre, et ressemble peu à la définition récursive courante. Notrepropre formulation a une conséquence immédiate sur l'adéquation de l'algorithme avecl'architecture proposée (A 3 C [Pis2000]). Une formulation récursive, telle qu'elle estcommunément exposée, ne s'adapte pas bien à une implantation matérielle. La formulationrécursive s'implante très bien dans des machines d'usage général, contenant une pile decalcul. Implanter l'algorithme dans du matériel, ou l'adapter à une formulation parallèlesuppose, pour être performant, de dérécursiver la formulation.66

3.4 Programmation dynamique orthogonale (bidimensionelle).Puisque nous avons fait le choix d'un algorithme de programmation dynamiquemonodimensionnel, et que le flot optique, sans la contrainte d'alignement des images -contrainte épipolaire - est bidimensionnel, il nous faut étendre l'algorithme 1D. Ceciconduit au principe de la programmation dynamique orthogonale [Qué92].Il est admis, étant donné que le mouvement des pixels d'une image à une autre estindépendant en X et Y(séparabilité) [Anc93], que pour obtenir un champ de disparité 2D larecherche des composantes des vecteurs peut se faire indépendamment horizontalement etverticalement. La programmation dynamique orthogonale se base sur cette propriété.La programmation dynamique orthogonale, consiste à utiliser l'algorithme 1D, 2.Nfois, sur les lignes et colonnes d'images. Pour une étape déterminée, nous effectuons lamise en correspondance, à une résolution donnée, en X et en Y. Les deux composanteshorizontales et verticales, pour chacun des pixels, sont alors les composantes 2D de chaquevecteur de déplacement. Les calculs horizontaux et verticaux étant indépendants, ilspeuvent éventuellement être effectués simultanément (voir figure 3.9). C'est une fois quesont effectués les calculs 1D de programmation dynamique, horizontalement etverticalement, que le flot optique bidimensionnel est obtenu. Il s'agit d'une sommevectorielle des composantes vectorielles obtenues horizontalement et verticalement. Lechamp de vecteurs 2D obtenu peut être alors approximé par le modèle projectif.Il était aussi envisageable d'alterner les calculs de programmation dynamique danschacune des directions d'image, et d'alterner les recalages projectifs en X puis en Y[Qué96]. Cela aurait rendu plus complexe l'approximation d'un modèle projectif 2D devision et nécessité la mise en oeuvre double de l'algorithme des moindres carrés 1D.L'algorithme des moindres carrés que nous avons adapté, est bidimensionnel. Il est détaillépar la suite dans ce chapitre.L'avantage d'effectuer les mises en correspondance par programmation dynamique1D, horizontalement et verticalement, simultanément, est qu'aucune supposition n'est faitesur le déplacement préférentiel dans une direction privilégiée X ou Y. Le champ demouvement peut être arbitrairement complexe, dans les deux directions X et Yindifféremment. La figure 3.9 illustre la mise en correspondance d'images, en deux passeshorizontales et verticales simultanées.67

Figure 3.9 : Programmation dynamique orthogonale effectuée en deux passes horizontaleet verticale indépendantes lors de l'appariement des images.La mise en correspondance 1D a beau être imprécise aux premières itérations del'algorithme pyramidal, le fait que nous recalions projectivement les images, grâce à unmodèle de transformation projective plane, permet que le mouvement global 2D soit lerésultat de la convergence de la méthode. Rien ne différencie les directions X ou Yd'appariement. Les directions horizontales et verticales sont symétriques du point de vue dela méthode d'appariement. Un champ de disparité stéréoscopique 2D complexe peut êtreitérativement déterminé, avec une approximation globale du flot optique.68

3.5 Modélisation du flot optique par la méthode des moindres carrés.Au chapitre précédent, deux modèles équivalents de transformation projectiveplane, explicite et implicite, ont été énoncés. Ils permettent de modéliser le flot optique.Ces deux modèles proviennent de l'analyse du contexte de vision, dans le cas de prises devue aérienne. Les modèles obtenus permettent de déterminer à l'aide de quelquesparamètres, le mouvement global qui lie deux images corrélées. Les deux transformationsdécoulent du modèle de projection de l'espace sur le plan image. Ces deux modèlesdonnent des résultats de transformation équivalents lorsque l'on examine le recalageprojectif (warping) obtenu à la fin de l'algorithme pyramidal (mosaïque).Les paramètres obtenus, qui sont au nombre de 8 dans le cas implicite, et de 11dans le cas explicite, n'ont pas la même signification. Les paramètres de la transformationexplicite, sont plus directement reliés au mouvement tridimensionnel de la caméra. Ilspermettent aussi de comprendre plus simplement la nature des transformationsélémentaires issues du mouvement de la caméra.Si l'on utilise les 11 paramètres de la transformation explicite, ceux-ci n'étant pasindépendants, il se pose pour l'algorithme de moindres carrés un problèmed'indétermination. L'algorithme chargé de déterminer la valeur des paramètres se heurte àune redondance de paramètres (ceux-ci jouent des rôles similaires). Malgré cela, l'intérêtd'une transformation explicite est important. On peut en effet juger simplement de lapertinence des paramètres obtenus. Les valeurs précises des transformations élémentairesdécomposées sont obtenues à l'aide de l'algorithme global explicitement. Il est plus aisé decomprendre, et d'apprécier par une approche "rationnelle", la valeur numérique destransformations élémentaires ainsi décomposées.La transformation explicite telle qu'elle a été énoncée au chapitre précédant ne peutêtre directement utilisée. Nous allons préciser son bon usage.3.5.1 Transformation projective explicitée.Le chapitre précédent nous a permis de formuler deux modèles projectifs, parl'intermédiaire de deux transformations : l'une explicite et l'autre implicite. Les paramètresde la transformation projective explicite sont les suivants :69

- α angle de rotation- zx facteur d'échelle en x- zy facteur d'échelle en y- cx abscisse du centre de la rotation- cy ordonnée du centre de la rotation- tx translation horizontale- ty translation verticale- λ angle de tangage- µ angle de roulis- sx angle de lacet en x- sy angle de lacet en yCes paramètres décrivent les transformations élémentaires qui lient deux imagesaériennes de la même scène, projetées selon deux axes de vue. Lorsque l'on examine latransformation implicite, on s'aperçoit que le centre de la transformation est fixe. Le centrede la transformation implicite est fixé à l'origine de l'image (le point de coordonnées (0,0)en haut à gauche de l'image). On peut, de même pour la transformation explicite, fixer lescoordonnées de ce point. On peut indifféremment avoir une référence fixe ou variable,pour les coordonnées du centre. Les coordonnées du centre de la transformation ont un rôle"muet" du point de vue de la nature des transformations. Il s'agit d'une origine, qui peutêtre placée arbitrairement par rapport à l'image de référence 16 .zx et zy sont deux facteurs d'échelles indépendants en abscisse et ordonnée. Si ledispositif de vision (caméra) est bien conçu, les pixels sont "carrés", c'est-à-dire que larésolution sur le terrain, la distance réelle qui sépare deux pixels, est identique dans lesdeux directions. Il est inutile de fixer deux paramètres indépendants, puisque la réalité de laprise de vue permet de dire que ces deux paramètres sont liés. zx et zy peuvent êtrefusionnés en un seul paramètre z qui correspond aux conditions de prise de vue.On peut démontrer qu'un lacet en x et un lacet en y d'un angle α identique,équivalent à une rotation du même angle α [Owe97]. Le lacet x appliqué en même tempsque le lacet y n'est donc pas indépendant de la rotation. Il faut appliquer une seule de cestransformations de lacet. On peut appliquer le lacet en x uniquement, et le lacet en y sera lacomposée du lacet en x et de la rotation. Le lacet en y n'est absolument pas utile (il a étédonné pour la symétrie la formulation de la transformation) et peut être ignoré.Si l'on compte parmi les paramètres des facteurs d'échelle indépendants en x et en y(la transformation implicite possède de tels facteurs indépendants), le nombre de16 Tout comme l'origine de l'espace est fixée arbitrairement lorsque l'on utilise la définition d'un espacevectoriel pour définir l'espace affine.70

paramètres de la transformation explicite est identique à celui de la transformationimplicite. Les paramètres "utiles" sont les suivants :- α angle de rotation- zx facteur d'échelle en x- zy facteur d'échelle en y- tx translation horizontale- ty translation verticale- λ angle de tangage- µ angle de roulis- ψ angle de lacetIls décrivent (mais cela n'a pas été démontré formellement) l'ensemble destransformations telles que le permet la transformation implicite. Ces deux transformationscomportent le même nombre (8) de paramètres. Il s'agit de transformations équivalentes,mais dont la forme explicite possède des paramètres "physiques décorrélés".3.5.2 Comparaison des modèles projectifs sur des images réelles.Les images (figure 3.10) qui suivent, présentent les photographies aériennes d'uncentre d'affaires en Amérique. Elles ont été recalées projectivement à l'aide des deuxmodèles présentés à 8 paramètres. La figure 3.11 présente le résultat (mosaïque) del'appariement sous forme graphique. Suivent les résultats quantitatifs dans les deux cas defigure. Le résultat présente dans les deux cas, une composante de lacet très prononcée. Lesrésultats sous forme graphique (mosaïques) sont (peu s'en faut) équivalents pour les deuxformulations.La formulation explicite du modèle est toutefois plus aisée à analyser, car lesparamètres obtenus sont "physiquement décorrélés". Énoncer explicitement le modèle,contraint l'algorithme des moindres carrés (qui détermine la valeur des paramètres) à unemeilleure discrimination des transformations élémentaires. Les conséquences physiques dumouvement tridimensionnel de la caméra, et donc le problème de détermination desparamètres, sont mieux formulés. On a affaire à un problème plus contraint (les causesphysiques sont décorrélées), et donc mieux conditionné.71

Figure 3.10 : Deux images aériennes d'un business-center aux USA.Figure 3.11 : Mosaïques d'images de la figure 3.10 obtenues avec la forme implicite(gauche) et explicite (droite) de la transformation projective plane.Paramètres du modèle implicite :m00 = 0.980783m01 = -0.270642tx= 65 pixelsm10 = -0.006761m11 = 1.036057ty= -10 pixelsm20 = -5.369096e-05m21 = -5.498772e-06Paramètres du modèle explicite :α = -5.4 °zx = 101.3 %zy = 99.6 %tx= 11 pixelsty= -2 pixelsλ = 3 °µ = 2 °ψ = -11 °72

Nous pouvons constater sur un tel résultat numérique, que les paramètres obtenus àl'aide du modèle explicite sont vraisemblablement justes. Les paramètres obtenus à l'aidedu modèle implicite, ne sont absolument pas interprétables par un humain, à moins de voirle résultat graphique auquel il correspond (mosaïque présentée à la figure 3.11). Toutefois,nous estimons, en visualisant le résultat des mosaïques présentées, que le résultat obtenu àl'aide de la transformation explicite, est bien plus proche d'une réalité tangible (de parl'interprétation des paramètres).On peut remarquer que les images traitées possèdent un relief non-négligeable quicontredit l'hypothèse de planarité (de la scène) que nous avons formulés.La forme implicite est utile pour montrer la nature du phénomène physique, etétayer la démonstration (voir chapitre 2).73

3.5.3 Moindres carrés non-linéaires supervisés.Soit le vecteur de paramètres suivant :⎛ α ⎞⎜z x⎟⎜ ⎟⎜z y ⎟⎜ t ⎟ xa = ⎜ ⎟⎜ t y ⎟⎜ λ ⎟⎜ ⎟⎜ µ ⎟⎜ ⎟⎝ ψ ⎠(3.5)Ce vecteur contient tous les paramètres de la transformation projective plane T.Effectuer un calcul de moindres carrés consiste [Pre92] déterminer la valeur numérique desparamètres du vecteur a, afin que celui-ci corresponde au mieux au sens d'une distancequadratique, au champ de vecteurs de disparité (flot optique). Soit D le champ de disparitétel que :D = D x,ij . r x + D y,ij . r y (3.6)D est la somme vectorielle des disparités obtenues horizontalement etverticalement, par la méthode de programmation dynamique orthogonale ; i et j sont lescoordonnées d'un pixel d'image. On rappelle que T est la transformation projective àapproximer. On a alors les deux composantes de cette transformation T telles que :T = T x,ij . r x + T y,ij . r y (3.7)Calculer une approximation des moindres carrés consiste à minimiser la distancequadratique entre le modèle T et le champ expérimental D, selon la formule (3.8).( ) 2 + ( D y,ij − T y,ij (a)) 2⎡E 2 D x,ij − T x,ij (a)(a) = ⎢mina⎢∑σ 2(i,j)∈imageij⎣⎢⎤⎥⎥⎦⎥(3.8)Cette minimisation consiste à approximer de manière optimale (au sens desmoindres carrés) le vecteur de paramètres a. L'algorithme de minimisation est dit nonlinéaire,du fait que le modèle T n'est pas linéaire selon ses variables i et j. En effet, si latransformation avait été une simple similitude (transformation affine), l'algorithme desmoindres carrés aurait été linéaire. Mais puisque l'on a composé à cette similitude une74

transformation perspective (non-linéaire) la transformation devient projective, et donc nonlinéaire.L'algorithme des moindres carrés non-linéaire est itératif. Il s'agit de donner unevaleur initiale au vecteur a. Puis, en plusieurs itérations, l'algorithme converge vers lasolution (unique), en approximant les paramètres du vecteur a à l'aide de l'estimationinitiale. Pour cette méthode des moindres carrés, nous avons utilisé l'algorithme deLevenberg-Markard 17 [Pre92][Sze93].Dire que l'algorithme est supervisé consiste à donner une valeur non constante à lavariance σ 2 ij (au dénominateur de 3.8). Cette variance vient pondérer la minimisation, etpermet de contraindre l'algorithme à prendre en compte les incertitudes sur les vecteurscomposant D (flot optique). L'incertitude prépondérante est liée à la position du vecteurdisparité, à une sous résolution donnée. Lorsque l'on réduit par 8 la taille des images àapparier, pour la première itération de l'algorithme pyramidal, le facteur de réduction de 8génère une incertitude sur la position du vecteur de +/- 4 pixels.Si l'on ne prend que cette incertitude due à la réduction des images, σ 2 ij resteconstant à une résolution d'image donnée. Il faut donc évaluer plus finement la variancedont nous nous servirons pour rendre supervisé l'algorithme des moindres carrés. Nousavons choisi :σ ij = 1 + r 2 . U Dij − V Dij128. 2 /3 . 1 2 (3.9)σ ij doit être non nul (on ne peut diviser par 0 dans la formule 3.8). Il estime unemesure d'incertitude sur le vecteur Dij. U Dij représente la luminance du pixel de lapremière image (à apparier), qui est à l'origine du vecteur disparité. Il s'agit donc du pixel(i,j) de la première image. V Dij représente la luminance du pixel de la seconde image (deréférence), qui est à l'extrémité (flèche) du vecteur disparité. Nous estimons l'écart type,pour chaque vecteur, et donc pour chaque pixel de la première image. Cette estimation sebase sur la différence de luminosité des pixels pointés par le vecteur Dij.⎛1 + r ⎝ 2Le terme r de la formule (3.9) est le facteur de réduction de l'image (8, 4, 2 et 1).⎞représente donc l'erreur que l'on commet en estimant un vecteur disparité, en ayant⎠réduit l'image d'un facteur r. Cette erreur est pondérée par une fonction de distancelumineuse. On a vu, dans le paragraphe sur la fonction de coût (dans ce même chapitre),17 C'est un algorithme très utilisé autant pour l'analyse numérique (Cf. Matlab) que pour la résolutionformelle (Cf. Mathematica).75

que 128. 2 /3 représente un écart-type de la distance U ki − V kj . Afin que la distancelumineuse ait la dimension d'un écart-type (sans dimension), il apparaît naturel denormaliser la distance par l'écart-type de cette distance. La pondération est constituée par lamoitié de cette distance normalisée (facteur 1/2).Ne pas pondérer l'approximation (moindres carrés) par l'énoncé de la distancequadratique, et donc utiliser un algorithme non supervisé, aurait consisté à poser σ ij = 1.On a pu vérifier expérimentalement, que l'algorithme supervisé (pondéré), donne de bienmeilleurs résultats. L'approximation du modèle projectif devient robuste. C'est unepropriété intéressante des algorithmes supervisés, pourvu comme dans notre cas, quel'incertitude sur la mesure effectuée puisse être qualifiée et évaluée.3.5.4 Critère de sélection des vecteurs du champ de disparité.Lors des différentes étapes de l'algorithme pyramidal, le nombre de vecteursdisparitén'est pas constant. Le nombre de vecteurs-disparité quadruple (comme larésolution des images traitées) à chaque nouvelle résolution prise en compte parl'algorithme. La population statistique sur laquelle est effectuée le calcul de moindrescarrés pourrait quadrupler à chaque nouvelle résolution. Cela augmenterait la durée ducalcul de l'algorithme NLLS à chaque nouvelle résolution.Pour palier ce problème, nous avons utilisé la méthode suivante. A la plus faiblerésolution (initiale 32x32), le calcul de NLLS est effectué sur tous les vecteurs de D. Puis,lorsque la résolution est doublée, nous ne prenons qu'un vecteur sur 4 en découpant lechamp D en blocs de vecteurs 2x2. A chaque nouvelle résolution, nous prenons des blocsde vecteurs 2 fois plus grands, et nous en choisissons 1 (vecteur) par bloc. Nousconservons donc égale, entre les résolutions, la population statistique traitée parl'algorithme NLLS.Le choix d'un vecteur par bloc est décidé par un critère de minimisation de lavariance affectée au vecteur concerné. La formule (3.9) donne à chaque vecteur un écarttypeσ ij . Nous choisissons parmi les vecteurs du bloc, le vecteur dont l'écart-type est leplus faible. L'écart-type de la formule (3.9) détermine l'incertitude pour chaque vecteur deD. Nous cherchons donc à ne proposer à l'algorithme NLLS, que les vecteurs quiprésentent l'incertitude la plus réduite possible. Cela permet d'obtenir un résultat del'algorithme de moindres carrés, avec un coefficient de détermination (fiabilité) plus élevé,car l'algorithme se voit présenter des données sélectionnées, et entachées de moinsd'incertitude.76

3.5.5 Initialisation des paramètres de la transformation projective.Le modèle de transformation projective du plan (image) est non-linéaire.L'algorithme des moindres carrés qui permet de déterminer les paramètres, connaissant lemodèle et un champ de vecteur expérimental (flot optique), est itératif [Pre92]. À lapremière itération, il faut présenter à cet algorithme, des valeurs numériques de paramètresproches de la solution (unique) à approximer.La première itération de l'algorithme NLLS, est aussi la première itération del'algorithme pyramidal. On peut donc admettre, étant donné que les images ont été réduitesconsidérablement, que le mouvement que l'on cherche à estimer est très faible (à cetterésolution). Les images ont typiquement une taille 32x32, et le mouvement d'un pixel estconsidérablement affaibli (par 8) à cette résolution. Ce que nous avons à estimer à lapremière itération est une transformation proche de l'identité.Toutefois, si nous donnons à l'algorithme les paramètres correspondants à latransformation identité, l'approximation échoue pour deux raisons. D'une part une rotationd'un angle de 0 degrés (comme pour l'identité), conduit l'algorithme NLLS à unesingularité qu'il rejette. Il faut donc présenter à cet algorithme un angle de rotation estiméfaible, et non nul. D'autre part, il est préférable, pour que la convergence ait lieu, d'estimerla translation initiale des images. Dans ce qui suit, nous allons donc proposer uneestimation des paramètres initiaux pour les deux modèles projectifs considérés, àparamètres explicites et implicites.a) Estimation de la translation initiale.Lors de la première itération de l'algorithme NLLS, nous avons calculé le flotoptique entre les deux images. Nous avons à notre disposition le champ de vecteurs D. Lechamp D est d'abord très imparfait. Il s'agit du premier calcul de D, qui sera perfectionnépar les itérations suivantes de l'algorithme pyramidal. D présente naturellement parexemple, des effets de bords indésirables. Le seul sous-ensemble "fiable" du champ D, sesitue au centre du champ des vecteurs-disparité.Afin d'estimer la translation des images, et connaissant le champ D nousmaximisons l'expression (3.10) suivante :⎡max ⎢ ∑ ∑ U Dmn − U Dmnij ⎣⎢m=i±kn= j±l( ).V ( Dmn − V Dmn )⎤⎥⎦⎥(3.10)i et j varient de +/- 5 voisinages de blocs 9x9, du centre de l'image U. k et l varientde +/- 4 pixels. U Dmn représente donc un voisinage 9x9 de l'image U, tel que les77

voisinages comparés ne se recouvrent pas (quels que soient i et j). V Dmn représente levoisinage 9x9 qui correspond à U Dmn par le calcul de flot optique. U Dmn et V Dmn sontles niveaux moyens sur les deux voisinages de U et V.Le calcul de (3.10) qui détermine deux valeurs de i et j, consiste donc à maximiserl'inter-corrélation centrée, mais non normalisée (contrairement au chapitre 2), sur desvoisinages appariés du centre des images U et V. Le choix du centre des images permetd'éviter les effets de bords du calcul de flot optique.Si l'on avait normalisé la formule de corrélation, par le produit des variances desvoisinages, le calcul aurait consisté à choisir i et j (et donc deux voisinages) tel que lesdeux voisinages se ressemblent le plus, au sens de la corrélation. Mais, cet opérateurn'étant pas normalisé, il est implicitement le produit de la corrélation normalisée-centrée(cf. chapitre 2) par la variance des voisinages. Cela signifie que l'on recherche nonseulement les deux voisinages qui se ressemblent le plus, mais qui en même temps,possèdent la plus grande variance. Un voisinage de grande variance, en traitementd'images, représente un point d'intérêt. Ce que nous recherchons par la maximisation de(3.10) sont deux voisinages appariés et corrélés, qui correspondent le plus à un pointd'intérêt commun. Nous maximisons à la fois la ressemblance, et la variance des voisinagesappariés. La translation des images que nous cherchons à estimer est alors le vecteursuivant :⎛ˆt x ⎞⎜⎝ˆt ⎟ y ⎠= D ij (3.11)Figure 3.12 : Estimation initiale d'une translation pure, sur les images de la figure 3.10. Agauche, extrait de U, et à droite, extrait apparié de V.La figure 3.12 est un exemple, sur les images de la figure 3.10, de la recherched'une translation pure, afin d'estimer les paramètres initiaux. On recherche, par inter-78

corrélation centrée, les voisinages corrélés mis en correspondance, qui correspondent à unpoint d'intérêt. Le voisinage qui satisfait le mieux à ces conditions, est encadré de noir, etsa luminance est inversée (pour l'illustration du résultat et non pour quelque traitementutile). La translation estimée alors, pour initialiser les paramètres tx et ty, est constituée parle vecteur Dij établi par programmation dynamique orthogonale.b) Initialisation des autres paramètres pour la transformation implicite.Pour la transformation implicite, les paramètres d'initialisation sont choisis tel que :m00 = 1.0m01 = 0.0001tx= ˆt xm10 = 0.0001m11 = 1.0ty= ˆt ym20 = 0.0001m21 = 0.0001Cette transformation est proche d'une translation pure selon le vecteur estimé. Elleévite à l'algorithme NLLS d'échouer par une singularité de calcul.c) Initialisation des autres paramètres pour la transformation explicite.Pour la transformation explicite, les paramètres d'initialisation sont choisis tel que :α = 1 °zx = 1zy = 1tx= ˆt xty= ˆt yλ = 0 °µ = 0 °ψ = 0 °Cette transformation est proche d'une translation pure selon le vecteur estimé. Elleévite à l'algorithme NLLS d'échouer par une singularité de calcul.En utilisant une translation estimée presque "pure", nous avons constaté quel'algorithme pyramidal converge toujours vers une solution. Si l'algorithme NLLS diverge,c'est que l'hypothèse du flot optique (voir chapitre 2) n'est pas vérifiée. Le modèle de79

transformation projective du plan est adéquat. L'algorithme de calcul du flot optique estoptimal (selon le principe d'optimalité de Bellman). L'algorithme de moindres carrés(NLLS) est optimal selon le critère d'une distance quadratique. De plus, l'algorithme demoindres carrés est robuste, puisque supervisé. Les meilleurs critères de convergence del'algorithme pyramidal sont réunis. Le seul critère qui puisse être mis en défaut estl'hypothèse initiale du flot optique. Nous présenterons les étapes de l'algorithme pyramidalsur des exemples précis dans une partie correspondant aux résultats.3.6 Vérification du résultat par application de la transformée.Afin de juger de la qualité du recalage projectif, il est nécessaire d'appliquer latransformation projective pour superposer les images. Ainsi, une fois les imagessuperposées, il est aisé de les comparer pixels à pixels. L'opération consiste à effectuer unetransformation d'image (warping) à l'aide du modèle déterminé par l'étape des moindrescarrés. Les paramètres (vecteur a) de la transformation sont connus.Pour transformer l'image, il s'offre deux choix. Soit appliquer la transformation à laseconde image pour la ramener sur la première. Soit transformer la première, pour larendre similaire à la seconde.La première solution (V=>U) consiste à utiliser l'inverse de la transformée. En fait,la transformation T est complexe, et sa transformation inverse est difficile à obtenir. Leplus souvent, on a recours à la pseudo-inverse. Appliquer une pseudo-inverse consiste enl'algorithme de la figure 3.13.Pour j variant de 1 à la hauteur d'imagePour i variant de 1 à la largeur d'imageImage_transformée[i][j]

Pour j variant de 1 à la hauteur d'imagePour i variant de 1 à la largeur d'imageImage_transformée[Tx,ij][Ty,ij]

Le cardinal (card) représente le nombre de pixel de l'intersection par superposition(mosaïque) des deux images. Il s'agit de la partie des images où elles se coïncident par lecontenu. Étant donné la normalisation préalable des images, on a immédiatement :⎧ U = V = 128⎨⎩σ U =σ V = 128 / 3(3.13)puisque la moyenne et l'écart-type des images sont fixés préalablement. De plus, pourtrouver l'intersection C = U ∩ V, on peut utiliser l'algorithme de la figure 3.16.Pour tout i,j : C[i][j]

- Soit r est moins grand. Dans ce cas, r et a ne sont pas réactualisés.L'image_transformée n'est pas non plus réactualisée. Mais U et V sont échantillonnés àune taille d'image deux fois supérieure dans le cas d'une résolution intermédiaire. Bien sur,avant de sous-échantillonner U, on lui applique la transformation par a (qui correspond aumeilleur r estimé jusque-là). Si U et V atteignent la résolution initiale, l'algorithme prendfin.Lorsque l'algorithme prend fin, nous disposons de l'image_transformée, du champD, de la transformée T caractérisée par ses coefficients a, et enfin du paramètre de qualité rqui permet de juger numériquement du résultat.Pour illustrer la méthode pyramidale d'approximation globale du recalage projectif,nous allons maintenant présenter un résultat.3.9 Résultats de la méthode.Le résultat est celui des deux images de la base d'images provenant du CEA,recalées projectivement, que nous avions placées pour illustrations dans le chapitreprécédent. Nous le commenterons. Nous disposons d'un échantillon d'une quarantained'images correspondant à des vues aériennes de deux scènes différentes. Ces images, prisesdeux à deux, constituent autant de couples sur lesquels notre algorithme peut être évalué.La figure 3.17 et les données qui suivent présentent le résultat obtenu sur deux imagesextraites de la base d'images que nous avons constituée.Figure 3.17 : Images aériennes 256x256 de test du CEA.83

N°d'itérationTailled'imageTempsd'exécutionPD bi-SPARC 400(en ms)Phases de l'algorithme pyramidal :Facteur decorrélation(%)Filtragebi-SPARC400(ms)Moindrescarrés bi-SPARC400(ms)Recalageprojectifbi-SPARC400(ms)Corrélationbi-SPARC400(ms)1 32x32 163.3 35.08 23.3 22.2 69.3 6.12 32x32 163.3 52.75 23.3 10.9 69.6 5.93 32x32 156.5 44.13 23.2 9.6 69.2 5.94 64x64 628.8 52.94 24.5 10.8 69.2 5.95 64x64 647.5 48.92 23.9 15.9 69.9 6.06 128x128 1891 53.51 29.6 11.6 69.3 5.97 128x128 1857 53.32 30.2 14.4 69.7 5.98 256x256 13 755 59.28 25.0 14.2 68.9 6.09 256x256 14 022 57.25 24.3 13.0 69.2 5.9Total 33 284 227 123 624 54Paramètres de la transformationprojective :Échelle : 96.4 %Angle de rotation : -16.8°Translation horizontale : 62 pixelsTranslation verticale : 20 pixelsPosition x du centre : 175Position y du centre : 13Angle de tangage : -3°Angle de roulis : -1°Angle de lacet : 0°Corrélation : 59.28 %MosaïqueLe résultat est obtenu sur deux images 256x256 provenant du CEA. Ces imagescorrespondent presque aux hypothèses que nous avions formulées pour l'algorithmepyramidal. Presque, mais pas tout à fait. En effet, le relief des bâtiments de la scène n'estpas tout à fait négligeable. Et surtout, des modifications de contraste des imagesinterviennent. On peut percevoir cela, par le mouvement des ombres (pour le contraste), etpar le fait que les bâtiments apparaissent sous deux angles de vue différents (pour le relief).Nous ne sommes pas tout à fait dans les conditions qui correspondent auxhypothèses émises. Toutefois, l'algorithme est suffisamment robuste pour se comportercorrectement dans des conditions réelles de prise de vue.84

La première démonstration de la qualité du recalage projectif, est illustrée par lamosaïque d'images reconstituée. On peut apercevoir sur celle-ci une continuité parfaite desvoies ferroviaires qui sont présentes dans les deux images. Pour effectuer la mosaïque,nous appliquons la transformation déterminée par les paramètres de a (vecteur deparamètres résultat) en effectuant une moyenne des deux images sur la partie commune decelles-ci (recouvrement). Si le recalage projectif était moins bon que celui présenté, onverrait, sur la partie commune des images, un flou (moyen) qui n'apparaît pas ici. Lecoefficient de corrélation obtenu globalement sur la partie commune des images, estd'environ 60%.Le tableau de résultat présenté illustre la convergence de l'algorithme pyramidal. Sil'on prend en compte la colonne qui concerne le coefficient de corrélation (enpourcentage), les nombres en gras indiquent qu'à cette itération de l'algorithme, celui-ci aconvergé. Il faut 9 itérations pour que l'algorithme converge, après l'examen de toutes lesrésolutions (deuxième colonne à gauche du tableau). La première itération donne unrésultat de corrélation assez bon, car l'estimation initiale d'une translation "pure" a donné àla méthode des moindres carrés, une estimation correcte de la solution.Dans les différentes autres colonnes, les temps de calcul des différents éléments del'algorithme sont donnés. La dernière ligne du tableau indique les temps cumulés. Le tempsdonné pour le calcul du champ de disparité (par programmation dynamique) n'est donnéque pour les balayages horizontaux de lignes d'images. Il faut donc multiplier ce temps par2 pour obtenir le temps total du calcul de flot optique. Si l'on effectue cette multiplicationpar 2 du temps annoncé pour le calcul du champ, on se rend compte que 99% du temps prispar la méthode, est utilisé à effectuer un calcul de programmation dynamique. Celareprésente en tout, environ 1 minutes de calcul.On est bien éloigné (de 2 ordres de grandeur) du temps réel qui nous est imposé parles impératifs de notre application. Si l'on veut effectuer un calcul en moins d'une seconde,il faut nécessairement penser à accélérer le calcul de programmation dynamique. C'est cequi va faire l'objet de la deuxième partie de notre manuscrit. Un dispositif matériel pour lecalcul parallèle de l'algorithme de programmation dynamique, va être décrit.85

3.10 Conclusion partielle sur la partie algorithmique du mémoire.Une méthode robuste, précise et performante pour l'appariement d'images aériennesa été proposée. Elle est basée sur une approche formalisée de la problématiqued'appariement de ces images. Le cadre formel a été décrit, conduisant à une caractérisationphysique des données et hypothèses. Cela nous amène à proposer une méthode globale demise en correspondance d'images, qui répond aux contraintes du problème dans lecontexte qui a été décrit. En découle l'énoncé d'un algorithme pyramidal basé surl'approximation itérative du calcul de flot optique, et l'approximation du champ de vecteursobtenu par un modèle de vision. Ce modèle permet de décrire tout comme le champ devecteurs disparité, le mouvement relatif d'une caméra lorsqu'elle observe la même scèneaérienne, sous deux angles de vue et à des instants distincts.Le calcul du flot optique possède des limites intrinsèques, dues à l'hypothèsed'invariance spatio-temporelle de la luminance des images, préalable à celui-ci. Despropositions ont été faites, qui permettent d'étendre le champ d'application de la méthodede calcul par programmation dynamique orthogonale. La fiabilité de ce calcul reposeautant sur le bon étalonnage en luminance des images, que sur les propriétésmathématiques de la fonction de coût qui constitue la distance lumineuse entre les images.Cette fonction de coût, qui intervient dans le calcul de programmation dynamique,constitue les caractéristiques optiques de ce qui représente l'oeil, si l'on fait une analogieanthropomorphique, de l'algorithme de vision.Nous avons choisi l'algorithme de programmation dynamique, car celui-ci estparticulièrement adapté à la mesure du flot optique entre images. C'est sa propriété desemi-globalité, qui offre à la partie de bas niveau de la méthode une adéquation complèteaux contraintes du problème. L'algorithme des moindres carrés, une fois annoncé le modèlede vision est aussi parfaitement adéquat et optimal. Nous avons proposé une manière derendre cet algorithme supervisé. Cela apporte une très grande fiabilité aux paramètres dumodèle, déterminé tout au long des itérations pyramidales.La méthode pyramidale offre une précision au calcul que nous avons pu constatersur le résultat présenté. Il reste à démontrer l'adéquation de cette méthode, par le biais deson implantation, avec du matériel et une architecture "accélératrice" que nous avonsconçue. L'une des contraintes de notre application, n'est en effet pas respectée. Cettecontrainte porte sur la durée du calcul, qui ne doit pas dépasser une seconde. Dans ce but,nous avons simulé une machine virtuelle permettant le calcul parallèle de l'algorithme deprogrammation dynamique. L'algorithme de programmation dynamique est en effet lepoint critique de la méthode, du fait de sa complexité temporelle.La simulation d'une machine de programmation dynamique, a pour but d'étudier lescaractéristiques d'une machine physique. Elle permet de vérifier qu'à un haut niveau, lescontraintes d'implantation, n'influeront pas significativement sur la qualité des résultats.86

Cela passe par une formulation originale de l'algorithme de programmation dynamique, quise prête à l'implantation dans un dispositif matériel dédié.C'est grâce à la "solidité" de la méthode de recalage projectif des images aériennes,que nous pouvons envisager une accélération matérielle des calculs. C'est ce que nousdévelopperons dans les chapitres suivants.87

2ème PartieChapitre 4. Modèle et principe fonctionnel du dispositif demicro-programmation dynamique.89

La première partie de ce mémoire nous a permis d'énoncer une méthoded'appariement global d'images aériennes. Un algorithme a été défini, et sa réalisation avecla contrainte de temps d'exécution, impose qu'un dispositif matériel soit mis en oeuvre pourla respecter 18 (méthodologie A 3 C). La partie la plus critique de l'algorithme pyramidal quia été défini, est constituée par les traitements de bas niveaux. C'est en effet le calcul du flotoptique, par la méthode de programmation dynamique 1D "orthogonale" qui affectebeaucoup les performances temporelles de la méthode proposée [Lec97]. En effet, le tempsqui est imparti pour la réalisation de la mesure de déplacement de la caméra est d'uneseconde, et correspond au temps que mettrait un humain pour réagir à une perceptionvisuelle. Le dispositif de prise de décision se basant sur la méthode doit être au moins aussifiable et rapide que le serait un opérateur.Les critères de fiabilité de la méthode ont été discutés précédemment. Nous avonsconstruit un algorithme en analysant les données et hypothèses liées au contexte de visionaérienne dans lequel nous sommes placés, et évalué qualitativement celui-ci. Dans cettedeuxième partie, c'est l'adéquation entre une définition algorithmique énoncée, et undispositif matériel, qui est abordée. Il s'agit de formuler un modèle fonctionnel d'unemachine permettant le calcul d'un champ vectoriel de disparité, satisfaisant les contraintes(temps réel, embarquabilité ...). Ce calcul, d'après le choix précédent, est basé surl'algorithme de programmation dynamique monodimensionnel. L'implantation matériellede celui-ci nécessite une formulation adaptée. Un dispositif électronique a toujours unfonctionnement parallèle et asynchrone 19 . La description fonctionnelle de notre dispositifpasse par la formulation adéquate dans un langage adapté.Un grand nombre de langages permettent la spécification fonctionnelle d'unemachine à différents niveaux d'observation. Au cours de la progression de nos travaux demodélisation nous avons utilisé des langages séquentiels (langage C) parallèles (langage dela machine Synapse, C* de la machine CM5, VHDL proche du langage ADA). Certains seprêtent mieux à la description d'une machine parallèle et asynchrone telle que par nature,est constitué un dispositif matériel électronique. Il s'agissait, lors de ces différentesimplantations de spécifier et de valider une description fonctionnelle du modèle du circuitproposé.Le modèle de la machine permet de concevoir une description fonctionnelle pourcelle-ci. Le modèle systolique [Qui89] duquel s'inspire la description, ressemble peu auxarchitectures conventionnelles. Du reste, implanter une description fonctionnelle d'une telle18 A 3 C : méthodologie adéquation-algorithme-architecture sous contrainte ; elle vise à définir lesarchitectures de systèmes/circuits non seulement par le biais des structures les plus adéquates pour supporterefficacement le principe calculatoire de l'algorithme donné (comme le stipule la méthodologie A 3 ), maisaussi à prendre en compte les contraintes hexogènes à ce principe [Pis2000].19 Une machine séquentielle possède toujours des degrés de parallèlisme masqués, et la synchronisationd'une machine est un modèle qui permet d'appréhender le fonctionnement d'un dispositif par natureasynchrone.91

machine sur une machine conventionnelle conduit à un échec quant aux performancesattendues. C'est un modèle dont on conçoit aisément qu'il puisse permettre desperformances accrues, mais qui du fait des réalisations auxquelles il a donné lieu, s'estsouvent heurté à des contraintes de réalisation insurmontables [NEC94].Remarque : On traite dans cette partie de la programmation dynamique en général[LeC98] (et non de la programmation dynamique pour le traitement d'images - letraitement d'image intervient uniquement dans la définition de la fonction de coût). On sepréoccupe du principe calculatoire : structure d'un Processeur Élémentaire, liaison entre lesPE. Le modèle que nous énonçons d'abord, et le calculateur systolique qui en découle parla mise en oeuvre d'une méthodologie (A 3 [Sor94]) est indépendant de l'application. C'estl'application des contraintes de l'application en traitement des images qui dédie la mise enoeuvre.4.1 Définition d'un modèle de circuit de programmation dynamique.Énoncer un modèle pour la machine de micro-programmation dynamique permet deconcevoir une description fonctionnelle. Le modèle énoncé permet que la descriptionfonctionnelle de la machine soit en correspondance avec le matériel qu'elle implique. Unebonne description suppose aussi que la mise en oeuvre matérielle, par les contraintesqu'elle impose, produise un retour sur la description fonctionnelle, et fasse évoluer celle-ci.L'adéquation découle de cette interaction entre la description et sa mise en oeuvre.4.1.1 Formulation mathématique.D'après le chapitre 3, pour le calcul de la matrice programmation dynamique 1D ilfaut choisir une distance dij entre tous les éléments (i,j) (pixels) de deux vecteurs Uk et Vk(lignes et colonnes) :d ij = U ki − V kj(3.1) rappelLa recherche du chemin global de coût minimal (score) qui établi unecorrespondance optimale entre le premier vecteur et le deuxième, selon la définition de laprogrammation dynamique de Bellman, est la minimisation de la somme de coûtsdirectionnels locaux C(s) pondérés par la distance de luminosité dij. Cela forme la fonctionde coût élaborée pour chaque couple (i,j) de pixels considérés. Effectuer un calcul deprogrammation dynamique consiste à former le score :∑score = Min d ij .C(s)che min s(3.2) rappel92

Le score minimise sur l'ensemble des chemins dans la matrice (chaque élément nepouvant être atteint qu'une fois) la distance affectée d'un coût directionnel. C(s) est le coûtqui dépend de la direction du chemin, diagonale ou sur l'une des directions orthogonales.Le sens de propagation dans ces directions est imposé, puisque le chemin se propage dansle cadran inférieur droit du voisinage de l'élément de matrice courant (figure 4.1).DépartVkN Vkj Vk1Uk1 ... Uki ... VkNDij (2)(2)(1)ArrivéeFigure 4.1 : Propagation d'un chemin dans la matrice de programmation dynamique.(2) = C(orthogonal) et (1) = C(diagonal). U et V sont les luminances de 2 lignes d'images.La définition rencontrée couramment donne lieu à une implantation récursive[Qué88] , du fait que le problème global, qui est un problème d'optimisation, se décomposeen sous-problèmes élémentaires résolus chacun de manière optimale. Mais une formulationrécursive se prête mal à la définition d'un modèle de machine dédiée. C'est un problèmeque l'on rencontre aussi, et pour une raison similaire, lorsqu'un algorithme est défini àl'aide d'une simple boucle (Tant que ... Faire) qui donne lieu à un coût matérielimportant 20 .Afin d'adapter la formulation de l'algorithme à une implantation matérielledescriptible, on peut avoir recours à une analogie mécanique. L'analogie mécanique quenous proposons permet de concevoir la forme dérécursivée de l'algorithme, et possède entout point les mêmes éléments que ceux présents dans la formulation mathématique. Il20 la synthèse d'architecture donne lieu au déroulement spatial de la boucle.93

s'agit d'un modèle mécanique simple, qui permet, lorsque l'on simule son fonctionnement,de concevoir une forme non récursive de l'algorithme de programmation dynamique[LeC94].4.1.2 Analogie mécanique du fonctionnement du système de programmationdynamique.Le modèle systolique 2D par analogie mécanique, de la machine de programmationdynamique permet de décrire l'algorithme parallèle de programmation dynamique (figure4.2).Figure 4.2 : Modèle systolique de la machine par analogie mécanique.La matrice de programmation dynamique contient N 2 éléments. Ces N 2 élémentssont autant de Processeurs élémentaires (PE) constituant le système de calcul del'algorithme.Chaque PE est constitué d'un percuteur et de 3 dominos. Le percuteur active les 3dominos de sa cellule, dans un délai paramétrable ; les dominos activent les percuteursd'autres cellules. Le délai de chute de chaque domino est paramétré par la fonction de coûtdij.C(s), c'est-à-dire que le domino diagonal chute en premier (dij.C(diagonal)) et que lesdeux dominos orthogonaux chutent ensuite (dij.C(orthogonal)). dij est un terme qui dépendde la luminance des pixels considérés et C(s) constitue le coût de temporel dudéveloppement des chemins dans la structure 2D.94

Le développement initial des chemins débute par une impulsion extérieure sur lepremier élément de la matrice de PE. Une onde de chute des dominos se propage dans lamatrice de programmation dynamique. Cela correspond au développement parallèle desdifférents chemins dans la matrice de programmation dynamique. Chaque PE ne peut êtreactif qu'une seule fois, car le chemin que l'on recherche dans la matrice est hamiltonien 21(voir chapitre 3).D'après la formule (3.2), on recherche dans la matrice de programmationdynamique le chemin qui minimise la somme des dij.C(s). Le détermination du chemin decoût minimal dans la matrice de PE passe donc par une phase de recouvrement. Ainsi il estnécessaire que chaque percuteur mémorise la provenance du domino qui l'a percuté lapremière fois. À partir du premier domino qui chute sur les PE de la ligne d'arrivée(extrémités droite et basse de la matrice de PE : figure 4.1), déterminer le chemin optimalconsiste à suivre le chemin de percussion mémorisé dans chaque PE. Le chemin recouvrédans la matrice est le chemin de plus faible score. Ce chemin indique la correspondanceélastique entre les vecteurs appariés.La minimisation de la somme (de la formule 3.2) se traduit par analogie mécaniquepar la minimisation d'une somme de délais (équivalent à des coûts) sur l'ensemble deschemins propagés dans la matrice. Le premier chemin qui aboutit est donc par l'analogie, lechemin recherché.4.1.3 Simulation séquentielle de la machine systolique.Le mouvement des données à l'exécution de l'algorithme permet de donner unmodèle de machine. L'architecture proposée se réfère à un modèle systolique et à unemachine SIMD (single instruction multiple data). L'algorithme qui découle d'une tellemachine est un algorithme piloté par les données (data driven) constituées par lesluminances des lignes d'images à mettre en correspondance.Simuler informatiquement une telle machine à l'aide d'un langage séquentiel,consiste à réaliser un échéancier permettant de dater chaque événement (de chute dedominos) parmi les 3.N 2 événements possibles (2.N 2 si l'on considère la symétrie descoûts orthogonaux). Le modèle d'exécution est asynchrone.21 Cela correspond au fait que les dominos ne se redressent pas.95

DépartUkjVkiChemin N°2Chemin N°1Chemin N°3échéancierArrivéeFigure 4.3 : Mise en concurrence du développement des chemins.L'implantation consiste en la mise en oeuvre un échéancier (liste d'événementsconcurrents) piloté par la donnée de la fonction de coût (liste de similarité). La concurrencedu développement des chemins est présentée dans la figure 4.3. L'échéancier contient laliste des événements activables (un percuteur a été activé) et est systématiquementparcouru pour désigner un événement activé (un domino chute) qui sortira donc de la liste.Si deux événements possèdent la même date d'activation, l'événement diagonal estfavorisé 22 .La complexité temporelle d'un tel algorithme est donnée par l'algorithme deparcours de la liste d'événements, et est donc dans le pire des cas en O(N 2 ). La fonction decoût est calculée sur les données d'images (Uk et Vk) prenant des valeurs sur 8 bits, etproduit un résultat normalisé codé sur 6 bits. La fonction de coût est donc précalculée etconstitue une table réduite (Look-Up Table de dimension 256x64x2 bits = 4 Koctets). Celane nécessite aucune opération arithmétique pendant l'exécution de l'algorithme.22 Un chemin diagonal (chemin le plus court suivant le parcours dans la matrice) indique une ressemblancedes vecteurs comparés. La résolution du conflit favorise donc la recherche d'une ressemblance entre vecteurs.96

4.1.4 Algorithme parallèle respectant le modèle.La définition de l'algorithme parallèle de programmation dynamique découle del'énoncé du modèle de la machine (voir figure 4.4) [LeC98]._________________________________________________________________________PE(0,0) := ACTIF;FIN := FALSE;score partiel := 0;TIMER := 0; /* TIMER de chaque PE */TANT QUE (NOT FIN) FAIRE EN PARALLELE SUR LES PEs ACTIFSSI RECEPTION du score partiel voisin ALORSMEMORISER la direction s du chemin optimal ;METTRE À JOUR le score partiel dans les 3 directions;ATTENDRE que TIMER = dij.C(diagonal);ACTIVER le voisin diagonal;ENVOYER le score mis à jour au voisin SUD-EST;ATTENDRE TIMER = dij.C(orthogonal);ACTIVER les voisins orthogonaux;ENVOYER le score mis à jour aux voisins SUD et EST;FIN=SI(index=(N,N)) ALORS TRUE;DESACTIVER LE PE;FIN DE SI ;FIN DE TANT QUESCORE= score partiel(N,N);/* recouvrement du chemin optimal */i=2*N;CHEMIN(i)=POSITION=(N,N);TANT QUE (NOT CHEMIN(i)=(0,0)) FAIREPOSITION := POSITION-s(POSITION);i := i-1;CHEMIN(i) := POSITION;FIN DE TANT QUE /* CHEMIN contient le chemin optimal */_________________________________________________________________________Figure 4.4 : Algorithme parallèle de programmation dynamique pour l'appariement dedeux vecteurs.97

L'algorithme comprend deux étapes : une étape de développement des chemins, etune étape de recouvrement du chemin optimal. L'étape de développement permet le calculdu score de programmation dynamique. C'est un résultat qui numériquement n'est pas utilepour l'algorithme qui a été défini au chapitre 3. Cette étape est toutefois nécessaire, carc'est la détermination du score (intégrale des coûts minimale) qui détermine le cheminélastique de correspondance optimale entre les deux vecteurs mis en correspondance. Lechemin optimal est utile pour déterminer le champ vectoriel de disparité entre les imagesque nous apparions (voir chapitre 3). Une étape de recouvrement du chemin est doncnécessaire.Seule l'étape de développement admet une forme parallèle et possède unecomplexité en O(N) (qui est proportionnelle à la longueur 2.N du plus long chemin dans lamatrice). L'étape de recouvrement nécessite peu de calculs (complexité O(N)) et peut êtreeffectuée séquentiellement. Il s'agit en effet d'un simple parcours d'une liste d'indirectionscalculées par l'étape de développement des chemins.L'algorithme de programmation dynamique ainsi défini nécessite toutefois, pourêtre implanté efficacement sur une machine parallèle, que celle-ci comporte autant deTIMERS (élément de mesure du temps) que la matrice de programmation dynamiquepossède d'éléments. Une implantation correcte sur une machine parallèle, suppose quecelle-ci ait un parallélisme de faible grain, et possède beaucoup de noeuds de calcul(jusqu'à 64K noeuds pour la résolution 256x256). Ce type de machine n'existe pas, ni pourles machines à usage général, ni pour les machines dédiées. Le plongement de l'algorithmesur les machines parallèle existantes est donc toujours sous optimal. L'énoncé d'un modèlede machine systolique adaptée par une approche "bottom-up" 23 , permet de concevoir unemeilleure Adéquation Algorithme Architecture (A 3 ).4.1.5 Validation du modèle fonctionnel.Afin d'étudier la conformité du modèle avec une implantation parallèle, nous avonssimulé le système décrit par la machine systolique analogue [Lec97]. Nous avons pour celautilisé une description fonctionnelle en C* (langage C parallèle) sur la machine CM-5(Connection Machine de Thinking Machine Corporation). Cette machine est massivementparallèle et possède une architecture très favorable au plongement d'un algorithme répartispatialement sur une grille 2D de noeuds de calcul (son réseau de connexion y estfavorable). Le langage C parallèle qui permet sa programmation possède des propriétés devirtualisation, puisqu'il permet de simuler le fonctionnement d'une grille 2D (shape) dedimension virtuelle arbitraire, indépendamment de la dimension physique de la machine.La machine CM-5 possède un parallélisme de gros grain, puisque chaque noeud estconstitué de processeurs généralistes (SPARC). Son modèle de programmation est dit23 de la machine vers les algorithmes qu'elle serait susceptible de supporter98

SPMD (Single Process Multiple Data) qui est une variante du modèle MIMD (MultipleInstruction Multiple Data) de la classification de Flynn.Décrire un algorithme en langage parallèle suppose que l'on précise la significationdes ses directives. La directive Sur (with du C*) délimite le traitement effectué enparallèle. Cela signifie que les variables appartiennent à un processeur de la grille 2D(forme ou shape en C*) ; chaque variable élémentaire est donc implicitement indexée parla position du processeur. La directive Où (where du C*) est une forme parallèle de ladirective séquentielle Si ; elle a donc une signification conditionnelle sur un processeurparticulier (dans notre cas TIMER).Deux formes de l'algorithme sont données, l'une abrégée (figure 4.5a) et l'autredétaillée (figure 4.5b)._________________________________________________________________________Remplir le tableau de ressemblance entre pixel (initialise les TIMERS)Tant que les TIMERS (N, ?) ou (?, N) ne sont pas atteintsSur les processeursOù le TIMER atteint 0Où le TIMER adjacent ne dépasse pas la matriceDéveloppe un nouveau chemin (Rend actif le compteur adjacent) etmémorise la direction sSur les processeursDécrémente les TIMERS actifsIncrémente le compteur tempsFin de Tant queScore = tempsBacktracking à l'aide des directions s mémorisées_________________________________________________________________________Figure 4.5a : Algorithme parallèle - principeL'algorithme de la figure 4.5a décrit le fonctionnement du système deprogrammation dynamique simulé sur la CM-5. Il apparaît que les calculs effectifs sonttrès localisés. En effet la directive Où concerne peu de processeurs simultanément. Lacharge de calcul sur l'ensemble des processeurs est faible. Ces processeurs effectuentd'ailleurs des opérations très simples, car il ne s'agit que d'additions et de comparaisons.Une forme détaillée de cet algorithme est donnée dans la figure 4.5b.99

_________________________________________________________________________Définir forme Processeur(N,N)Remplir le tableau de ressemblance des valeursD(s,i,j) ← dij.C(s)Tant que [ D(diagonale,N,N) >= 0] fairePour s dans les trois directions faireSur ProcesseurNouvelle Position ← (-1,-1)Où PE(s) = inactifOù D(s) (N,N)Nouvelle Position ← (-1,-1)Pour s dans les trois directions faireSur ProcesseurOù Nouvelle Position (-1,-1)Où PE(toutes directions) = inactifDirection ← sPE(s) ←ActifPour s dans les trois directions faireSur ProcesseurOù PE(s) = actifOù D(s) >= 0D(s) ← D(s)-1Time ← Time+1Fin de Tant queScore = Time(* Score mesure la ressemblance entre les vecteurs *)(* Backtracking *)Chemin(i,j) ← 0Position ← (N,N)Tant que (Position (0,0)) faireChemin(Position) ← 1Position ← Position - Direction(Position)Fin de Tant que(* chemin(i,j) contient le chemin optimal *)_________________________________________________________________________Figure 4.5b : Algorithme parallèle - détaillé100

Étant donné que cette formulation est très conditionnée par la position duprocesseur dans la grille 2D de processeurs, pour atteindre certaines performances, ilfaudrait être à même de contrôler l'allocation dynamique des ressources de calcul. Maisnotre but n'est pas d'optimiser l'algorithme, mais de valider la spécification fonctionnelledu modèle systolique de machine dédiée [Pis98a]. Le modèle SPMD de la machine CM-5est d'ailleurs suffisamment souple et généraliste pour permettre une telle validationfonctionnelle.À cette étape nous avons pu prouver l'équivalence entre la simulation séquentielledu modèle mécanique analogue, et la formulation fonctionnelle explicitement parallèle dumodèle sur la machine CM-5. Cette démarche a été une première étape dans la péréquationdes modèles ainsi décrits. Une équivalence de fonctionnement a été prouvée, en fournissantaux deux implantations (sur une machine parallèle, et l'autre séquentielle) des données(images) complexes. Un pas particulièrement délicat a d'ailleurs été franchi dans larésolution systématique des conflits entre événements simultanés. La formulation parallèlenécessite en effet de décrire explicitement et exhaustivement les cas de conflit. Il se posedéjà à cette étape de description fonctionnelle la nécessité d'une preuve, puisque leparallélisme implicite décrit dans un langage séquentiel, exige une certaine exhaustivitélorsqu'il est explicité.La description fonctionnelle en C* sur la machine CM-5 formule une description deplus en plus précise de la machine que nous souhaitons réaliser, puisque l'on peut déjà voirqu'elle est constituée pour chaque PE de la grille 2D, de compteurs et de comparateurs.101

4.2 Mise en oeuvre des calculs de programmation dynamique sur des images.Nous avons décrit le modèle du système de programmation dynamique. Il endécoule une description fonctionnelle que nous avons validée. Il faut adapter la descriptionafin qu'elle soit synthétisable. Lorsque l'on conçoit un système les contraintes de réalisationmatérielle exigent que l'on fasse des concessions pour permettre la "réalisabilité" dusystème.Nous avons vu à la section précédente que le chemin de programmation dynamiquerecherché débute au premier élément de la matrice et se termine aux bords inférieur et droitde la matrice de programmation dynamique. Cette configuration de la machine estdéfavorable pour deux raisons. Ces raisons sont d'ordre algorithmiques et architecturalestout à la fois.La première raison d'ordre algorithmique tient aux propriétés de la programmationdynamique. Cet algorithme, quelques soient les conditions initiales du calcul, déterminegrâce à l'optimalité de la fonction de coût locale, une solution globalement optimale. Nousavons défini une telle fonction de coût local, mais dans le domaine des images où nousappliquons l'algorithme, il est difficile de démontrer que ce coût est optimal. En effet, lespoids déterminé lors de l'énoncé de la fonction de coût (chapitre 3) ont été déterminésexpérimentalement ; les propriétés de la fonction de coût ne garantissent aucune optimalité.Il s'agit d'un problème ouvert.Le calcul de programmation dynamique (voir figure 4.6) donne correctement lerésultat. Toutefois le choix du point de départ du chemin comme l'origine de la matrice deprogrammation dynamique, conduit à l'apparition d'effets de bord. Le calcul deprogrammation dynamique débute avec des conditions initiales fausses. Grâce au critèred'optimalité de l'algorithme, et aux "bonnes" propriétés de la fonction de coût, le cheminconverge spatialement vers une solution juste, mais le calcul contient des effets de bord.Ce problème lié aux effets de bords est illustré par le résultat présenté sur la figure4.6. La condition initiale (origine du chemin optimal) et la condition finale (aboutissementdu chemin optimal) sont toutes les deux fausses, le nombre de noeuds de calcul étant faible(48x48 PE), les effets de bords apparaissent clairement.102

UUkiimage de référenceVVkj Calcul de programmationdynamiqueimage à comparerFigure 4.6 : Mise en correspondance de deux lignes d'images (élision)Pour palier ce problème d'effet de bord, nous avons opté pour la solution d'agrandirles bords de la matrice, en présentant sur les bords le signal image répliqué en miroir.Durant sa progression spatiale, l'algorithme converge très rapidement. Il n'est donc pasutile d'ajouter beaucoup de réplication en miroir de l'image. Pratiquement, et quelles quesoient les résolutions d'images (de 32x32 à 256x256) seulement 8 pixels sont répliqués auxbords des images. 8 pixels correspondent à 8/32=25% de la taille d'image au sommet de lapyramide, et convient à l'approximation initiale de la disparité. Une telle réplication(48x48) permet toutefois pour la partie qui concerne l'image (32x32), que le calcul deprogrammation dynamique débute avec une condition initiale correctement calculée.La deuxième raison architecturale de l'extension de la matrice de programmationdynamique, tient au fait que le chemin ne pourrait aboutir sur les bords entiers de lamatrice (inférieurs ou gauches) sans que la réalisation du système ne se complique103

considérablement. Nous avons arbitrairement fixé la position de l'aboutissement duchemin, au dernier élément de la matrice. Cela entraîne un problème dans le calcul del'algorithme : le calcul a une condition finale fausse.De la même façon que précédemment, étendre l'image sur les bords avec un signalrépliqué en miroir permet que pour la partie centrale de la matrice qui concerne l'image, lerésultat soit correct. On ne prend en compte que la partie centrale du résultat correspondantà l'image totale. Les ajouts au bords ne sont utiles que pour "resynchroniser" la mise encorrespondance, et donc débuter et aboutir sur des conditions initiales et finalesacceptables. Cette "resynchronisation" est visible (en dehors de la matrice 32x32) sur lesimages de la figure 4.6.Le choix d'une réplication en miroir de l'image s'explique car, mettre encorrespondance deux images ou leur miroir est équivalent du point de vue de l'algorithme(ça n'est pas le cas si l'on change la direction de parcours gauche-droite ou droite-gauche).Le calcul "inutile" qui est effectué sur les bords (on ne prend pas en compte son résultat)constitue donc un calcul dual correct qui va permettre de fixer des conditions initiales etfinales acceptables.La figure 4.6 permet de voir qu'une partie centrale (cadre noir) constitue un calcul"fiable" de programmation dynamique. Seule cette partie utile (dans la matrice 32x32) seraprise en compte. Le chemin optimal présenté en noir est entouré d'une zone grise quicorrespond aux processeurs qui ont participés à l'élaboration des chemins concurrents. Lazone grise correspond donc à des chemins qui n'ont pas aboutis. On peut constater sur cettefigure que seule une bande diagonale restreinte participe à l'élaboration du chemin. Cetteremarque donnera lieu à une optimisation spatiale de la machine de programmationdynamique (A 3 C).4.3 Évaluation temporelle par simulation de la machine de micro-programmationdynamique.Nous présentons dans cette section le même résultat qualitatif, sur les mêmesimages que dans la chapitre 2. Toutefois, des temps simulés d'exécution du circuit proposésont donnés. Ils permettent de prédire le temps pris par le calcul parallèle sur le processeurde micro-programmation dynamique que nous proposons. Les temps des algorithmesautres que la programmation dynamique correspondent à une exécution sur un processeurSPARC cadencé à 250 MHz.104

Images aériennes 256x256 de test du CEA :N°itérationTailled'imageTempsd'exécutionPDSPARC250(en ms)TempsestiméµPD Fc1MHz(en ms)Facteur decorrélation(%)FiltrageSPARC250(ms)MoindrescarrésSPARC250(ms)RecalageprojectifSPARC250(ms)CorrélationSPARC250(ms)1 32x32 269.2 8.235 35.08 44.0 39.9 116.6 9.82 32x32 273.1 7.611 52.75 40.4 33.4 123.1 9.93 32x32 260.7 7.952 44.13 40.5 17.9 116.1 9.64 64x64 1082 29.49 52.94 39.7 19.3 120.9 9.75 64x64 1051 29.09 48.92 39.3 27.0 115.3 9.56 128x128 3175 110.3 53.51 46.2 21.2 116.3 9.47 128x128 3275 110.8 53.32 47.0 25.4 118.8 9.48 256x256 20 056 468.3 59.28 41.9 25.8 115.7 9.49 256x256 19 737 467.0 57.25 40.3 23.4 117.3 9.4Total 49 179 1 239 379 233 1060 86Timings pour Fc=10MHz et SPARC 250 :µPDMoindrescarrésRecalage projectifCorrélation0,2s 0,2s 1s 0,1sFiltrage0,4sTotal = 1,7 sFigure 4.7 : Résultats temporels de simulation de la machine de µPD.105

L'algorithme de programmation dynamique, tel que nous l'avons énoncé, établi unecorrespondance entre le coût local (donné par la fonction de coût) et un délai qui permet dedérouler temporellement les chemins qui se développent. Les chemins se développentconcurremment. Le score de programmation dynamique est donc proportionnel, d'aprèsnotre modèle, au temps d'exécution du calcul de programmation dynamique.Le score de programmation dynamique, moyennant un facteur multiplicatif tenantcompte de la cadence du processeur µPD, est lié au temps de calcul nécessaire poureffectuer le calcul. Une première approximation des temps de calculs est donc donnée surla figure 4.7. Elle ne tient compte que de la phase opérative du calcul correspondant audéroulement des chemins de programmation dynamique. Pour obtenir le temps totalnécessaire au calcul, il suffit de cumuler le score d'appariement de 2.N lignes (et colonnes)et de multiplier ce score global par la cadence d'horloge du circuit proposé (ici 10MHz estune fréquence convenable). Pour obtenir ici le temps simulé correspondant au calcul demicro-programmation dynamique, il faut multiplier le temps total par 2 fois la cadence del'horloge (en MHz) puisque celui-ci ne tient compte que de la phase horizontale de calcul(le calcul est effectué sur les lignes et colonnes d'images).Ce que l'on peut remarquer, c'est que le temps obtenu par simulation est multipliépar 4 à chaque nouvelle résolution. On observe une progression géométrique 8 32 128 512du temps simulé. Cela confirme, s'il était nécessaire, la complexité en O(N 2 ) del'algorithme, N 2 étant la taille de l'image carrée. Nous avions en effet annoncé que lacomplexité d'appariement de deux lignes est O(N) (proportionnelle au chemin de plusgrande longueur 2.N dans la matrice). L'algorithme étant appliqué 2.N fois sur les lignes etcolonnes d'image, cela porte la complexité à O(N 2 ) pour l'appariement de deux images.Le temps global d'appariement de deux images obtenu par simulation est de l'ordrede grandeur d'une seconde, tel que nous souhaitions qu'il soit (chapitre 2). Le temps decalcul de la convolution nécessaire au filtrage des images est figuré en parallèle du tempsde calcul de micro-programmation dynamique, car le système de micro-programmationdynamique étant un coprocesseur indépendant, on peut considérer que la convolution peutêtre effectuée durant le calcul du µPD. Cela nécessite que l'on décrive plus précisément leprincipe du dispositif matériel global proposé. Cela fera l'objet du chapitre suivant.106

4.4 Commentaires.Nous avons proposé un modèle pour un système de micro-programmationdynamique. Ce modèle est inspiré des modèles de machines systoliques. Les équationsmathématiques de l'algorithme peuvent avoir une analogie mécanique. L'analogiemécanique qui constitue un modèle adapté pour le problème de mise en correspondanced'images, étaye une description fonctionnelle qui a été transcrite de manière équivalentesur diverses machines, et dans divers langages. Une preuve de fonctionnement a été faitegrâce à la qualité du résultat présenté, obtenu sur des images réelles et complexes. Ladescription fonctionnelle de la machine peut donc être formulée dans un langage (VHDL)permettant la synthèse. Le problème d'adéquation qui se pose alors exige d'avoir une idéeprécise de l'équivalence matérielle de la description fonctionnelle.La formulation parallèle, et son implantation explicitement parallèle (en C*)constitue la description fonctionnelle la plus proche d'éléments matériels synthétisables.C'est en reprenant cette description que nous pourrons obtenir une description structurellesynthétisable. Le passage d'une description fonctionnelle à une description structurelle estune problématique d'architecture, et nécessite encore d'établir une preuve defonctionnement. La description fonctionnelle a permis de valider un modèle architectural.La description structurelle va permettre de vérifier que le modèle correspondcomplètement, à une réalité matérielle proposée. L'implantation matérielle de la machinepeut être réalisée de diverses façons, mais l'implantation adéquate de l'algorithme(description fonctionnelle) n'est effectif uniquement que sur "une" structure architecturale.C'est cette unique structure adéquate que nous développerons par la suite.Le problème qui se pose dorénavant n'est pas un problème d'optimisation (celui-cise posera ensuite) mais de concevoir une structure optimale qui permette l'implantationefficace d'un seul algorithme. Le but est de concevoir une machine dédiée. Toutefoisl'algorithme de programmation dynamique que nous implantons constitue une primitive decalcul suffisamment répandue pour que cette réalisation porte à conséquence. L'apparitionde structures électroniques programmable (FPGA = Field Programmable Gate Array) dedimensions acceptables, permet d'envisager de nouvelles structures simplement. Leprototypage réel que permettent ces structures ouvre la voie à la réalisation de structure demachines non conventionnelle (autre que Von Neumann ou Harvard respectivementconçues pour les microprocesseurs et les Digital Signal Processors ...).107

108

Chapitre 5. Réalisation et évaluation du prototype deprocesseur de micro-programmation dynamique.109

110

Les premiers chapitres nous ont permis de définir tout d'abord un algorithmegénéral de mise en correspondance (par un modèle rigide de déformation globale d'imagesaériennes). Puis un accent a été mis sur le point critique de la méthode d'appariementglobal, constituée par la partie de bas niveau : le calcul de flot optique. Une carte dedisparités dense entre deux images doit être obtenue, et l'établissement du champ devecteurs de déplacement est très coûteux en temps de calcul. Seul un dispositifélectronique dédié à ce calcul est en mesure de satisfaire les contraintes de temps réelsévère qui sont imposées par notre application.Le chapitre précédent a permis de donner une base à la réalisation d'un dispositif, etdes concepts architecturaux ont été validés. Il s'est agit de formuler un modèle (systolique)pour le processeur de micro-programmation dynamique. Ce modèle a été envisagé par uneanalogie mécanique impliquée par la formulation mathématique du problème de larecherche d'un plus court chemin entre deux vecteurs constitués de pixels. Ce problème,qui s'apparente au problème du voyageur de commerce, est résolvable par programmationdynamique. Dans le cas de la mise en correspondance d'images, la programmationdynamique orthogonale fait usage 2.N fois (N étant la taille de l'image carrée) del'algorithme de programmation dynamique 1D. C'est donc à la réalisation de cette primitive1D que nous consacrons cette partie du mémoire.Il faut prévoir dans notre démarche de description, autant la partie opérative (lecoeur du processeur) que les entrées/sorties qui lui permettent de communiquer avec sonenvironnement, et même plus largement, le dispositif embarquable dans lequel il s'intègre.Lors de la conception du circuit VLSI µPD il faut non seulement définir ses partiesopératives et contrôle, mais aussi arrêter ses entrées/sorties, les moyens pour rendre sonarchitecture extensible (scalability).Nous nous sommes attachés à la réalisation d'un prototype de processeur de microprogrammationdynamique. Le dispositif dans lequel un tel processeur s'intégrera n'estencore qu'une ébauche. On peut toutefois concevoir plus largement qu'il ne s'agit pas deconcevoir un processeur de micro-programmation dynamique, mais plutôt un systèmed'appariement d'images aériennes dans lequel il s'intègre. La conception du prototype dudispositif, à l'aide des composants actuels, étant donné la forte densité d'intégration quecelle-ci exige, ne permet pas d'envisager la réalisation complète et performante que noussouhaiterions. Il faut donc adopter une structure modulaire, tout en ayant une conceptionclaire du système envisagé.111

5.1 Architecture proposée du système de mise en correspondance d'images.Le système de mise en correspondance d'images contient plusieurs éléments decalcul (figure 5.1). D'une part, il contient 1 ou plusieurs processeurs µPD suivant la tailledes images, et la densité de Processeurs Élémentaires intégrables dans ceux-ci. Ce(s)processeur(s) nécessitent un pilote constitué par un micro-contrôleur. Celui ci contrôle lechargement des données images à apparier, et permet d'extraire le résultat (cheminoptimal) du calculateur µPD. Il fournit à ce calculateur les images rectifiées au cours desdifférentes étapes du recalage projectif. Il calcule aussi, à partir du chemin deprogrammation dynamique, la disparité stéréoscopique c'est-à-dire le champ de vecteurs dedéplacement. Le champ de vecteur est transmis à un processeur de calcul flottant (DSP) quieffectuera l'ajustement du modèle projectif par rapport à ce champ. Le processeur transmeten retour une image recalée projectivement au micro-contrôleur.données images1216Entréesdirectionnellesµ PD(s)2Contrôle de(dé)chargementdes donnéesSortie chemin3MémoireImagesµ ContrôleurMémoireRésultat16SortiesdirectionnellesDisparitésRecalageProcesseur de calcul flottant (DSP)Figure 5.1 : Architecture du système pour le recalage projectif des images.Il y a dans ce système 3 niveaux dans la classification des algorithmes de traitementd'images. Le bas niveau est le calcul de flot optique réalisé par le calculateur µPD. Leniveau intermédiaire est celui du calcul du modèle projectif dans le DSP. Le plus hautniveau peut être situé aussi dans le DSP qui contrôle le déroulement de l'algorithme (par ladétermination de la qualité du recalage projectif) et permet de prendre une décision à partirde la mesure de déplacement (de la caméra) effectuée. Le micro-contrôleur permet de faire112

l'intermédiaire entre le bas et le haut niveau, et séquence les mouvements de données(driver). Les flux de données sont un transfert régulier entre lescalculateur→contrôleur→processeur→contrôleur→calculateur qu'il faudra aussi prendreen compte pour évaluer les performances de l'algorithme sur cette architecture. Chacun deséléments a sa cadence d'horloge propre. Dans l'état de progression de nous travaux, notresouci immédiat n'étant pas l'embarquabilité, seule la partie de bas niveau constituée par lecalculateur a été prototypée grâce à un FPGA (Field Programmable Gate Array). Lesopérations de plus haut niveau sont émulées par un ordinateur standard (PC).5.2 Architecture du processeur de micro-programmation dynamique.L'organisation qui est schématisée par la figure 5.2 constitue l'architectureminimale, telle que nous l'avons d'abord envisagée. Elle convient à la mise encorrespondance, en 1 bloc calculateur µPD, d'une image 256x256.top nn16clkminimuminoou ino ioufincompteurtop6celluleckcnt64chargeT-edgex66scompar6down nnvaleur6registreen3rcoloadhalfoorthodiagosuesosu16rwshiftresetencodeurreadwritechainetransavantjeton (n-1)cex(256+16).(5+4)x(256+16).(5+4)razldloadoesmemsortie2jeton (n)suivant2stopmemjeton0startjeton suivantavanthorFigure 5.2 : Organisation d'un système minimum pour l'architecture d'un µPD.113

5.2.1 Optimisation spatiale du calculateur.Plusieurs éléments fonctionnels ont été mis en oeuvre. Nous détaillerons chacun deces éléments, toutefois il faut se pencher sur les optimisations possibles du calculateur[Pis99]. Le cas de la mise en correspondance d'image par programmation dynamique estspécifique. De plus, les contraintes de l'application bornent la recherche de disparité dansles images. Nous avons pu vérifier au chapitre 4 que seule une bande diagonale de largeurréduite contribue au calcul parallèle de l'algorithme de programmation dynamique d'unepart. D'autre part, la méthode pyramidale adoptée dans l'algorithme général, augmente laportée de la recherche du vecteur disparité. Le tableau 5.1 fixe la limite théorique de laportée du vecteur de disparité en fonction de la résolution (pyramidale) de l'image.RésolutionpyramidaleLargeur de la bandediagonaleNombre de PE/ligne32x32 9 (9+8)=1764x64 9 (9+8)=17128x128 7 (7+6)=13256x256 5 (5+4)=9Limitation de laportée en % d'image± 832 ⇔ 50%± 864 ⇔ 25%± 6128 ⇔ 10%± 4256 ⇔ 3%Tableau 5.1 : Limite théorique de la portée du vecteur disparité, fonction de la résolutionpyramidale d'image.La résolution pyramidale indiquée dans le tableau 5.1 convient à la mise encorrespondance pyramidale, par programmation dynamique 1D orthogonale, d'une image256x256. La mise en correspondance contient donc 4 étapes, à 4 résolutions distinctes. Aucours des étapes successives de l'algorithme, le recalage projectif étant de plus en plus fin,c'est un champ de disparité résiduel de plus en plus faible que nous avons à estimer. Il estdonc permis de limiter au cours des étapes successives, la largeur de la bande diagonale.Cette limitation est une optimisation qui diminue le nombre de PE mis en jeu, pour unecomplexité spatiale qui reste en O(N).La taille de l'image étant 256x256, le nombre d'éléments de calculs mis en jeu est(256+16).(5+4) qui est proportionnel à la dimension (N=256) d'image. Ce calcul estreprésenté dans la figure 5.2 comme facteur multiplicateur du nombre d'élémentsfonctionnels mis en oeuvre. Le nombre 16 qui entre en jeu dans le calcul du nombre de PEconstitue le nombre d'éléments de la matrice de programmation dynamique ajoutés lors del'extension de la matrice, pour éviter les effets de bord du calcul (voir chapitre 4). La114

somme (5+4) prend en compte l'organisation spatiale de la diagonale de processeursélémentaires, et est illustré par la figure 5.3.126374859Figure 5.3 : Organisation spatiale du processeur de micro-programmation dynamique.La figure 5.3 représente un extrait du système minimum envisagé pour la réalisationd'une matrice de programmation dynamique. La diagonale de PE implantés, figurée par leséléments grisés de la matrice, est de largeur 5, et nécessite 9 PE par couche diagonale.Toutefois, la disparité étant relevée horizontalement (ou verticalement) par rapport à ladiagonale de la matrice, la disparité (portée du vecteur mesurée) acceptable est de ±4pixels 24 .Le système minimum est composé d'une bande diagonale d'éléments de calculsconstituant des processeurs élémentaires. Si l'on se réfère à la figure 5.2, chaque PE estconstitué d'une cellule (de calcul) et d'un élément chaîne. La description structurelle d'unecellule sera donnée par la suite, puisqu'elle définit la partie opérative du PE. Nous allonsd'abord nous intéresser au mouvement des données (chargement et déchargement ducalculateur µPD).24 Cela convient à la résolution d'image originale (256x256) et est convenable pour une approximation finedu champ de vecteurs à 3% (de la taille d'image) près du vecteur résiduel.115

5.2.2 Chemin des données dans le calculateur.Le système minimum est constitué de (256+16).(5+4) Processeurs Élémentaires.Son fonctionnement décrit 3 étapes. Il faut tout d'abord charger les données correspondantà la fonction de coût, effectuer le calcul de programmation dynamique, puis lire le résultatpermettant de reconstituer le chemin calculé (permettant le recouvrement). Ces trois étapessont donc :1 - Initialisation,2 - Calcul,3 - Lecture du résultat.Le processeur de calcul correspond structurellement à la description ce la cellule dela figure 5.2. Les mouvements de données se font aux étapes 1 et 3. Il faut attendre la finde chacune des étapes pour passer à la suivante. Il faut, dans les étapes 1 et 3, que latotalité des cellules soient initialisées puis que le résultat soit lu dans toutes les cellules,pour passer à l'étape suivante. Ainsi, il est indifférent pour le fonctionnement du systèmeque le chargement et déchargement des données dans une cellule soit séquentiel (unecellule après l'autre) ou aléatoire (on peut adresser individuellement chacune des cellules).Un accès aléatoire (Random Access) pour le (dé)chargement des cellules est trèscoûteux en matériel, et complexe à mettre en oeuvre. Cela suppose une logique dedécodage d'un bus d'adresse, et l'accès individuel à chaque cellule est très pénalisant dupoint de vue du routage (complexité des connexions) du dispositif. Puisque l'accèsaléatoire aux cellules n'est pas nécessaire, il est alors préférable d'utiliser un(dé)chargement séquentiel des données nécessaires au calcul. Sur la figure 5.2 sontreprésentés un bus d'entrée sur 12 bits (6 compteur, et 6 valeur) permettant l'initialisationdes cellules. Il est aussi représenté un bus de sortie sur 2 bits (mem) qui permet la lecturedu résultat. Afin de gérer les entrées/sorties de données dans le calculateur, un jeton circulede PE en PE qui permet de désigner successivement chacun des PE, et permettre le(dé)chargement séquentiel de chacun d'entre eux.À chaque cycle (asynchrone) du signal shift (pour le décalage du jeton de PE enPE) chacun des processeurs élémentaires constituant une chaîne est initialisé par le busd'entrée (12 bits) ou une lecture du résultat est effectuée sur le bus de sortie (2 bits). Lemécanisme de transmission du jeton de PE en PE est réalisé par l'élément chaîne (de lafigure 5.2) qui correspond à une bascule D d'un registre à décalage (un point de vuefonctionnel). La distinction entre un cycle d'écriture (à l'étape 1) ou de lecture (à l'étape 3)est réalisée par le signal rw (read ou write). Un signal reset permet la réinitialisation de laposition du jeton (dans le PE numéro 1).116

Afin de prévoir la mise en cascade de plusieurs processeurs µPD, un élément dedébut de chaîne (jeton) et une entrée start, ainsi qu'une sortie stop sont disponibles àl'extérieur du système minimum.Les ordres de lecture/écriture sur les bus d'entrée/sortie donnés par la combinaisonde l'ordre de décalage (shift) du jeton et de l'état rw, sont cadenceables à la fréquenced'horloge (clk) ou des fréquences inférieures, ce qui permet de grandes performances dansles mouvements de données. Nous présenterons une évaluation de performances(chronogrammes mesurés) par la suite.Pour résumer, chacun des processeurs élémentaires de la matrice de programmationdynamique est adressé séquentiellement pour initialiser le calcul de programmationdynamique, et en lire le résultat de calcul. Le mécanisme matériel de lecture/écritures'apparente au accès des mémoires de masse (disque dur, CDROM etc ...) et s'oppose àcelui des mémoires à accès aléatoire (ROM, RAM etc ...). C'est un accès à débit important,qui favorise les performances au regard de la quantité de données à transférer. Celaconvient tout à fait à un processeur de traitement d'images où les mouvements de donnéessont un point critique de la réalisation matérielle. Un tel accès séquentiel aux éléments demémorisation est souvent présent sur tous les processeurs pour autoriser le debuggage etpar conséquent l'observabilité du fonctionnement (JTAG). C'est un mécanisme analogue, etqui est aujourd'hui devenu standard, qui nous permet le mouvement des données dans lamatrice de processeurs. Il a été adopté pour le test des composants, pour son faible coûtmatériel et ses performances, et permet dans le même ordre d'idée un accès rapide auxéléments de notre calculateur.117

5.2.3 Élément de calcul d'un processeur élémentaire.La figure 5.4 constitue une description structurelle de la cellule d'un processeurélémentaire [LeC98].LoadCompteurdij.C(ortho)RCOSorties SUD & ESTRegistre = dij.C(diag)EntréesCEComparateur

participé à l'élaboration du chemin, il faut qu'elle ait été activée). Le point mémoire estaussi représenté sur la figure 5.4.Afin de générer les deux délais paramétrables (orthogonaux et diagonaux),déclenchés par l'activation de la cellule, l'élément fonctionnel principal de la cellule estconstitué par un compteur 6 bits (selon le choix effectué au chapitre 3). Le comptage decelui-ci est déclenché par l'encodeur prioritaire par le signal CE (Count Enable). Lorsquece compteur arrive à la fin du comptage (signal RCO), il active ses voisins orthogonaux(sud et est). C'est le délai paramétrable long nécessaire à la réalisation de la fonction decoût temporel. Mais avant que cet événement orthogonal ne survienne, il se produit unévénement diagonal. Lorsque le compteur arrive à une valeur intermédiaire de comptage,par analogie, le domino diagonal doit chuter. D'un point de vue fonctionnel, on doit doncmettre en oeuvre un comparateur de la valeur de comptage, par rapport à un seuil (délaidiagonal). Cette fonction est réalisée par la présence d'un registre contenant la valeur deseuil de comparaison, et d'un comparateur dont l'état déclenche l'activation diagonale (sudest).Afin d'initialiser les deux délais d'activations, il faut donner à chaque cellule deuxvaleurs sur 6 bits, qui vont permettre de paramétrer les deux délais. Le mécanisme depassage de jeton permet de désigner le chargement d'une cellule parmi l'ensemble de cellesde la matrice de programmation dynamique (calculateur). Le chargement se fait donc parun bus 12 bits, en entrée (voir figure 5.2). Les valeurs des deux délais sont données par lecalcul de la fonction de coût (voir chapitre 3), et sont les valeurs dij.C(ortho) et dij.C(diag).Du point de vue du système global, c'est au micro-contrôleur (figure 5.1) qu'il incombe defournir ces deux valeurs, d'après une table de transcodage (mémoire) permettant le calculde la fonction de coût, à partir des valeurs d'intensité lumineuse des pixels d'images.De la même façon, pour extraire le résultat du point mémoire 2 bits de chacune descellules, le passage du jeton d'un PE à l'autre, va permettre la lecture séquentielle durésultat du calcul. Le chemin recherché, par l'algorithme de programmation dynamique,dans la phase de recouvrement, peut donc être déterminé.L'ensemble des cellules, et des éléments de la chaîne (pour le passage du jeton)regroupés, constituent les Processeurs Élémentaires de programmation dynamique, et sontorganisés selon le schéma de la figure 5.3. L'interconnexion des PE est locale, pour d'unepart la transmission de l'activation des cellules, et d'autre part la transmission du jeton parles éléments de la chaîne (registres à décalage). Par contre, 2 bus globaux, un de 12 bits enentrée, et un de 2 bits en sortie, doivent parvenir à chacun des PE. Le routage d'une tellearchitecture, du point de vue de la réalisation, grâce à la localité des transferts de données,est très favorable aux dispositifs VLSI actuellement disponibles 25 .25 notamment, les FPGA actuels, qui autorisent la réalisation de bus 3 états dans leur conception.119

5.3 Extensibilité du circuit.Les dispositifs VLSI actuellement disponibles (FPGA, ASIC) permettent de réalisermatériellement, seulement une partie du dispositif que nous souhaiterions réaliser. Unaspect important de notre réalisation doit donc être un souci d'extensibilité du calculateurµPD. Notre réalisation possède la topologie d'une grille 2D de processeurs élémentaires(matrice de programmation dynamique). L'extensibilité 26 peut être réalisée de deuxmanières. L'une consiste à cascader les calculateurs, et donc à constituer un réseau linéairede calculateurs. C'est une solution pas toujours évidente à adopter, du point de vue de lamise en oeuvre, mais qui convient aux performances temporelles souhaitables.Une autre solution consiste à rendre le processeur virtualisable. Par exemple, lafamille des processeurs TMS C40 de Texas Instrument, possède de telles propriétés devirtualisation. Pour ces processeurs, il est possible à l'aide d'un nombre réduit deprocesseur (avec 1 processeur éventuellement) d'implanter le même code que pour un largeréseau de processeurs (les processeurs C40 sont prévus pour être implantés en réseauphysique). Afin de permettre la virtualisation, des mécanismes hardware doivent êtreimplantés.Ces deux solutions autorisant l'extensibilité du circuit vont être développées.5.3.1 Réseau de calculateurs µPD.La figure 5.5 détaille la mise en cascade de 3 calculateurs µPD de dimensiondiagonale 5x3. Chacun de ses calculateurs contient (5+4).3=27 PE. C'est une dimensionacceptable pour un système réduit de micro programmation dynamique, puisque dans uncircuit programmable XC4010XLPC84 de Xilinx (FPGA) nous avons pu implanter 21 PE(avec un taux de remplissage de 70%). Malheureusement, un tel système réduit ne permetpas d'effectuer des calculs sur des images. Pour traiter une image 32x32, il faudrait uncalculateur de (5+4).(32+16)=432 PE. Une solution pour étendre la machine consiste àmettre en cascade des calculateurs, pour en constituer un réseau linéaire.Sur la figure 5.5, chacun des PE est figuré par un carré hachuré. Chaque PE del'extrémité basse de la diagonale, pour le premier calculateur, est cascadé par ses sorties(down) avec les entrées (top) du deuxième calculateur. À l'échelle d'un PE, celui-cipossède 3 entrées et 3 sorties. Ces entrées/sorties sont reliées de manière interne aucalculateur, aux voisins amont/aval de chaque PE. Lorsque ce voisin ne se situe pas àl'intérieur du calculateur, cela donne lieu à des entrées/sorties directionnelles. Cesentrées/sorties directionnelles (au nombre de 16) sont représentées sur la figure 5.1, etautorisent donc la mise en cascade des calculateurs µPD. Elles sont aussi représentées sur26 faculté à pouvoir utiliser le calculateur pour traiter des images aussi larges qu'il est souhaitable.120

la figure 5.2 et se nomment alors "top nn" et "down nn". Elles permettent que le calculsystolique de l'algorithme de programmation dynamique, se propage de calculateurs encalculateurs.La propagation de l'initialisation des cellules est aussi à prendre en compte, ainsique la lecture du résultat du calcul, par propagation du "jeton" entre calculateurs.L'initialisation et la lecture du résultat, sur un réseau de calculateurs µPD doit êtreéquivalente à l'initialisation/lecture sur un seul calculateur µPD.Calculateur No1Calculateur No2Calculateur No3Start1Stop1Start2Stop2Start3Stop3Figure 5.5 : Mise en cascade de calculateurs, pour obtenir un réseau.Il est représenté sur la figure 5.5 le parcours de propagation du jeton dans lecalculateur, ainsi que sa transmission de calculateurs en calculateurs. Les entrées/sortiesstart et stop sont chaînées entre calculateurs pour que le jeton circule entre les puces misesen cascade. Ainsi, l'initialisation sérialisée des calculateurs est rendue possible, et chaquepuce possède le même bus sur 12 bits en entrée, et sur 2 bits en sortie. La gestion du buscommun 2 bits en sortie suppose aussi que les puces soient connectées sur un buffer 3 états(mise en haute impédance).121

Un réseau de calculateurs comme celui-ci est envisageable. Mais cela donne unsystème lourd à mettre en oeuvre, et de plus, les éléments étant sérialisés un défaut sur l'undes PE entraîne la panne du réseau complet. C'est malgré tout la solution la plusperformante du point de vue temporel qui puisse être construite. Il est possible deconcevoir une solution moins performante, mais sans doute plus fiable, en prévoyant desstructures matérielles de virtualisation du calculateur.5.3.2 Processeur virtualisable.Le concept d'un processeur virtuel de micro-programmation dynamique systolique,consiste à prévoir qu'une fois le calcul effectué sur un tronçon diagonal de la matrice deprogrammation dynamique, le même calculateur va servir à nouveau pour calculerl'ensemble de la diagonale. S'il est impossible d'implanter physiquement la totalité de labande diagonale de processeurs élémentaire, et que l'on en implante seulement une partie,ce même tronçon va servir plusieurs fois au calcul total de la diagonale complète. Il s'agitd'une virtualisation à gros grain 27 .top nnREG/INCNTCNTREG/OUTdown nnFigure 5.6 : Calculateur de micro-programmation dynamique virtualisable.27 Cette virtualisation diffère de la virtualisation à grain fin introduite par les CM-1/2. Dans ce dernier cas,on connaît à priori le nombre de processeurs virtuels. Ce nombre sera équitablement simulé par chaque PEphysique, qui réitérera autant de fois l'exécution d'une même instruction dans les environnements d'exécutionde ses PE virtuels.122

Il s'agit de concevoir tous les mécanismes qui vont permettre qu'un seul calculateurpuisse effectuer un calcul complet sur l'ensemble d'une image, même si la dimensionphysique du calculateur est inférieure à celle de l'image. D'un point de vue fonctionnel, lecalculateur virtualisé constitue une fenêtre de dimension fixe glissant le long d'unediagonale. Ce glissement permet le calcul de programmation dynamique par tronçons dediagonale. On doit donc être à même de prélever les résultats issus de l'aval de ladiagonale, pour "réalimenter" le calculateur en amont du tronçon de la diagonale glissante.La figure 5.6 représente un calculateur contenant (5+4).3=27 PE. Il contient donc 3couches :- une couche d'entrée interfacée par les signaux "top nn",- une couche de calcul connectée en interne avec les PE voisins amont et aval,- une couche de sortie interfacée par les signaux "down nn".Ce calculateur est virtualisable, c'est-à-dire qu'il peut constituer un tronçon decouches de PE qui va successivement être employé au calcul d'une diagonale (5+4).3.n,avec n entier.Afin de rendre virtualisable ce calculateur, du matériel électronique a été ajouté. Ils'agit en entrée comme en sortie d'un compteur CNT, d'une batterie de registres (REG/IN etREG/OUT) et de comparateurs. Afin de décrire le mécanisme virtuel, nous allons décrired'abord la virtualisation de la sortie du calculateur.Le calculateur est initialisé (étape 1 par passage du jeton), et le lancement du calculest effectué. On a vu (dans le chapitre 4) que le lancement du calcul s'effectue par lapercussion du PE diagonal en tête de la matrice. Sur la figure 5.6 la diagonale de PEdiagonaux est représentée par des carrés hachurés clair. Le calcul de programmationdynamique suit la séquence suivante :Les PE sont d'abord initialisés par les dij.C(s) par le passage du jeton. L'étape 1d'initialisation est effectuée. Le calcul (étape 2) est lancé, le PE qui reçoit le lancement ducalcul est ici le premier de la diagonale désigné par une flèche noire (signal top). À la suitedu lancement du calcul, l'onde de propagation d'activation des PE parcourt la bandediagonale d'amont en aval. La virtualisation en sortie du calculateur consiste alors en laséquence suivante :- Dès qu'un PE de la couche de sortie du calculateur est activée (un domino chutesur la ligne d'arrivée) le compteur de sortie est autorisé à compter (Count Enable).- Chaque nouvel événement sur la couche de sortie est scruté, et pour chacun desévénements, l'état du compteur (valeur de comptage) est stocké dans la batterie de registresde sortie (REG/OUT).123

- Lorsque tous les événements sur la couche de sortie se sont produits, le calcul deprogrammation dynamique prend fin.La mémorisation de l'activation est alors extraite du calculateur grâce aux pointsmémoire 2 bits (passage du jeton). L'étape 3 est alors accomplie pour un tronçon. Par lasuite la fenêtre (tronçon diagonal) glisse sur la diagonale, et chaque PE est initialisé par lesdij.C(s) correspondant au tronçon suivant (étape 1 par passage du jeton). La virtualisationen entrée du calculateur consiste alors en la séquence suivante :- La batterie de registres d'entrée (REG/IN) est chargée à l'aide des valeurs desregistres de sortie obtenues précédemment (REG/OUT).- Le compteur d'entrée est autorisé à compter (Count Enable).- Dès que la valeur de comptage du compteur d'entrée atteint la valeur stockée dansla batterie de registres d'entrée (REG/IN), l'événement correspondant est déclenché sur lessignaux "top nn".- Lorsque tous les événements d'entrée ont eu lieu, le compteur cesse de compter, etla virtualisation reprend en sortie par un nouveau glissement du tronçon diagonal.C'est ainsi que de proche en proche, les étapes de calcul de 1 à 3 (Initialisation,Calcul et Lecture du résultat) sont répétées autant de fois que la diagonale de la matrice deprogrammation dynamique possède de tronçons.Pour résumer, afin de prévoir l'extensibilité du calculateur de micro-programmationdynamique, on a soit la possibilité d'étendre le matériel mis en oeuvre (réseau decalculateurs), soit la possibilité de réutiliser successivement le matériel disponible, enprévoyant les mécanismes de virtualisation décrits. Le choix entre une solution et l'autrepeut être décidé par la densité d'intégration rendue possible par le matériel électroniqueactuel, et le souci d'embarquabilité qui est celui du domaine de notre application derobotique aérienne. Mais le plus probable semble être une hybridation de ces deuxsolutions. Le souci de performance nous fera réaliser la plus grande matrice de processeursdiagonaux, dans la mesure de ce qui est acceptable. Le souci d'embarquabilité nousengagera à virtualiser le calculateur. Dans l'état de notre réalisation, les deux solutions sontenvisageables simultanément grâce au matériel décrit.Un calculateur µPD virtualisable d'une dimension (9+8).8=136 PE a pu êtresynthétisé pour un composant Xilinx VIRTEX (FPGA) contenant 300 000 portes avec untaux de remplissage de 97%. Un tel composant convient tout à fait à la réalisation d'uncalculateur de micro-programmation dynamique performant et embarquable. Pour traiterune image 256x256, il faudrait utiliser pour un réseau complet (256+16).(9+8)/136=34 deces puces. La virtualisation du calcul convient donc bien à la "réalisabilité" d'un système derecalage projectif embarquable.124

5.4 Réalisation et évaluation d'un prototype.La validation du concept de calculateur systolique de programmation dynamique aété accomplie en deux étapes. Il a fallu réaliser une description en VHDL de la machine.Ce langage possède 3 niveaux de description : la description fonctionnelle,comportementale et structurelle. Le niveau fonctionnel consiste à faire réaliser aucompilateur le travail de modélisation architecturale. En effet, à ce niveau, il n'est pasnécessaire de connaître un modèle de machine, car c'est l'algorithme, sans modification,qui sert de description pour la synthèse architecturale.Malheureusement, la synthèse d'un algorithme et presque toujours impossible, cartoutes les ressources matérielles qu'implique la description fonctionnelle ne sont pasdisponibles. Une description fonctionnelle est presque toujours non-synthétisable. Il fauttoujours passer par l'élaboration d'un modèle de machine, et prendre en compte lesressources rendues disponibles par le matériel ciblé. Nous avons fait ce travail demodélisation (voir chapitre 4), et par conséquent la description matérielle s'en trouvefacilitée.Il est possible grâce au niveau comportemental et au niveau structurel dedescription, de produire un code VHDL descriptif synthétisable du calculateur. Le niveaucomportemental permet de spécifier que la machine passe par certains états, et de décrireles transitions entre ces états. Ce niveau de description permet de réaliser des automatesd'états finis. Le niveau structurel permet d'assembler des primitives opératives (bascules,logique combinatoire, compteurs, multiplexeurs, décodeurs etc ...) qui auront étépréalablement décrites. Notre travail a donc été de décrire chacun des éléments duprocesseur élémentaire (voir figure 5.4), et d'assembler ces PE en une matrice constituantle calculateur.Une implantation a été réalisée à petite échelle sur un FPGA Xilinx XC4010 afin devalider le concept du processeur, et prouver sa possibilité de synthèse. Ce prototype nous aaussi permis d'obtenir une évaluation temporelle du dispositif. Puis un calculateurvirtualisable a été porté grâce à un FPGA de plus grande intégration : le Xilinx VIRTEX300. La portabilité et donc la pérennité de notre description matérielle a ainsi été prouvée.125

5.4.1 Implantation dans un Xilinx XC4010.La figure 5.7 représente le système réduit de micro-programmation dynamique quenous avons validé sur le circuit XC4010XLPC84 de Xilinx. Ce système réduit contient 21PE. Il ne convient évidemment pas à la mise en correspondance d'image pour deux raisons.Premièrement, comme on peut le voir sur la figure 5.7, ce système correspondrait à la miseen correspondance d'images 6x6. Une telle image porte trop peu d'information pourpermettre quelque traitement que ce soit 28 . Deuxièmement la bande diagonale n'est passymétrique. Ce système réduit est utile pour expérimenter le concept du calculateur.top9top8top7top5top64top12top4toptop33top11711top1top22top106101418d31591317d221d11d12d108121620find8d9d715d119d5d6d4Figure 5.7 : Dispositif réduit implanté sur le FPGA 4010.28 On peut parler de traitement sur des images, à partir d'une dimension 32x32.126

Le dispositif réduit ne contient pas de mécanisme de virtualisation. D'après l'outild'implantation (Fondation) il est susceptible de fonctionner à 50MHz. Nous l'avons testé à12MHz grâce à une carte XS40 de la société XESS. Les chargement et déchargement desdonnées est effectué grâce à une carte d'entrée/sortie numérique National Instrument. Lecadencement des échanges de données se fait à la fréquence de 10KHz. Il y a donc undéséquilibre important entre la cadence de (dé)chargement des données et la cadence decalcul propre du calculateur µPD. Ce déséquilibre, dû aux faibles performances du transfertde données pourrait laisser penser que le temps utilisé pour transfert de données estprépondérant dans le processus de calcul. En effet d'après les chronogrammes obtenus surl'oscilloscope le rapport entre le temps de calcul par le temps de (dé)chargement est del'ordre de 1/50. C'est-à-dire que le processus est temporellement occupé pour 98% par letransfert des données.Mais nous avons pour but de valider un concept, et de mettre au point de manièremodulaire le dispositif de mise en correspondance d'images. Le principal intérêt d'une telleexpérimentation est d'appréhender le fonctionnement du calculateur. Nous avons pueffectuer 10 000 cycles d'Initialisation/Calcul/Lecture du résultat, en environ 1 minute.Cela donne une cadence de fonctionnement du calculateur d'environ 200 Cycles/seconde.C'est une fréquence qui permet d'observer et d'améliorer le fonctionnement du calculateur àl'aide d'outils logiciels classiques (sur un ordinateur PC) et d'un oscilloscope. Leschronogrammes de la séquence de test sont présentés sur la figure 5.8.Sur la figure 5.8, les différentes entrées/sorties du calculateur sont présentées. Il estprésenté sur le bus de données 12 bits (compteur/valeur) des données identiques pour tousles PE. Le chemin de programmation dynamique doit donc suivre la diagonale de lamatrice, ce qui se vérifie. Après le positionnement du signal Reset (qui positionne le jetondans le premier PE) le signal Shift est activé pour donner l'ordre d'écriture (rw=1) danstous les PE. Le signal Stop, à la fin de l'initialisation passe à 1, pour indiquer la fin de lapériode d'initialisation.Après cette étape d'initialisation, le signal Top est activé, ce qui correspond aulancement du calcul de programmation dynamique, qui s'achève par le positionnement dusignal Fin. Les différentes sorties directionnelles "down nn" basculent aussi indiquant quetous les PE du calculateur ont été activés. Le signal Fin est activé en premier (avant lessignaux Down), indiquant que le chemin optimal aboutit sur la diagonale de la matrice.Afin de passer à l'étape de lecture du résultat, le signal Reset est de nouveaupositionné (passage du jeton dans le PE N°1), et l'étape de lecture est désignée par lepositionnement de rw à 0. Le signal Shift indique alors la lecture successive du contenu dupoint mémoire 2 bits de chaque PE, et est lisible sur le bus Mem. La période de lectureprend fin avec l'activation du signal Stop (le jeton se trouve dans le PE N°21).127

Figure 5.8 : Chronogrammes de simulation d'un cycle de calcul de programmationdynamique.128

On distingue donc bien sur la figure 5.8, les 3 étapes du calcul de microprogrammationdynamique. C'est l'accomplissement de ces 3 phases dont on a pudéterminer, en constituant le dispositif de test hardware, qu'il était réalisable à une cadencede 200 Hz, et avec un résultat exact. Cela permet de valider le concept architectural decalculateur de micro-programmation dynamique. Il resterait à intégrer ce calculateur audispositif qui a été énoncé par la figure 5.1. Mais, ce calculateur est trop réduit pour traiterdes images, même si l'on envisageait de le rendre virtualisable. Le FPGA n'est pas remplientièrement (voir figure 5.9), puisque le taux de remplissage est de 70%. Mais il n'y aaucun intérêt à le virtualiser, car la densité du composant 4010 n'est pas assez importantepour permettre un calcul sur des images.Figure 5.9 : Layout de placement/routage sur le FPGA 4010Nous avons alors envisagé d'utiliser un composant à plus forte intégration. Lecircuit 4010 possède l'équivalent de 10 000 portes logiques. Un composant mieux à mêmede convenir au traitement d'images est le circuit VIRTEX 300, qui contient l'équivalent de129

300 000 portes. De plus, il possède tout comme les composants de la série 4000, lapossibilité de réaliser des bus 3 états, ce qui est favorable au portage du design du 4010.5.4.2 Portage sur un Xilinx Virtex 300.La formulation en langage VHDL du calculateur virtualisable reprenant celle del'implantation sur le FPGA 4010 a pu être synthétisée. Ce système est composé de(9+8).8=136 PE. Il a de plus été ajouté les éléments de virtualisation (2 compteurs 10 bitset les batteries de registres REG/IN et REG/OUT). La figure 5.10 représente les statistiquesde remplissage du circuit VIRTEX.Device utilization summary:Number of External GCLKIOBs 1 out of 4 25%Number of External IOBs 45 out of 166 27%Number of SLICEs 3072 out of 3072 100%Number of GCLKs 1 out of 4 25%Number of TBUFs 272 out of 3200 8%Figure 5.10 : Statistiques de remplissage du circuit Xilinx VIRTEX XCV300PQ240.Le circuit est considéré rempli lorsqu'une au moins de ses ressources estentièrement utilisée. Sur la figure 5.10 on peut constater que la ressource critique est lecomposant "SLICE". Il s'agit du composant principal du FPGA VIRTEX. C'est en effet lamacro-cellule de ce composant (appelée aussi CLB sur d'autres FPGA comme le 4010). Sil'on arrive à un taux d'utilisation des macro-cellules si important (toutes ont été utilisées),c'est que la conception en grille 2D de PE du calculateur, se prête très bien à la structure duFPGA. Les interconnexions entre les PE sont de plus locales, et se prêtent très bien à unroutage automatique par le logiciel d'implantation (Fondation de Xilinx). Nous pensonsqu'il serait tout aussi aisé, malgré la complexité du calculateur, d'implanter un telcalculateur dans un ASIC. La régularité de son architecture peut permettre avec les outilsactuels de synthèse (tel Cadence) d'obtenir, avec les outils de compilation automatique(synthèse de Layout), une synthèse efficace.130

5.5 Conclusion partielle.Un calculateur de micro-programmation dynamique tel que nous l'avons proposé nepeut être pensé indépendamment de l'environnement dans lequel il s'intègre. C'est pourquoinous avons proposé une architecture d'un dispositif global de mise en correspondanced'images. L'ensemble de cette réalisation pourra être mis en oeuvre par morceaux, c'estpourquoi nous avons une approche modulaire. L'architecture proposée pour le système demise en correspondance d'image permet de maîtriser les échanges de données entre lesentités fonctionnelles. Le problème des échanges de donnée, est en effet critique lorsquel'on traite des volumes correspondants à des images. Nous avons pu nous en rendrecompte, car le dispositif de test du circuit µPD que nous utilisons pour la conception, neconviendrait certainement pas au fonctionnement du calculateur dans le but d'effectuer uneaccélération des traitements.Toutefois, avec différentes étapes marquées, pas à pas, par des validationssuccessives, nous avons abouti à une preuve de fonctionnement du calculateur. Nousl'avons en effet soumis au test d'images réelles de la base d'image du CEA (et d'autresdisponible publiquement), qui est un moyen efficace de se rendre compte du moindredysfonctionnement.L'optimisation spatiale du calculateur a été envisagée, ce qui rend le concept decelui-ci viable. L'architecture du Processeur élémentaire est simple, et grâce auregroupement de fonctionnalités simples, il est possible d'obtenir à une plus grande échelleun dispositif constituant une primitive de calcul fondamentale pour la vision parordinateur. Le calculateur effectue en effet un traitement de bas niveau qui est, puisque l'ontraite des images, un point délicat de la conception d'architectures, lorsque l'on souhaite desperformances temporelles et l'embaquabilité des moyens de calcul.Des propositions allant dans le sens d'une réalisation concrète, et plus loin qu'unprototype réduit ont été faites (optimisation, extensibilité par plusieurs voies). Étant donnéles développements récents des FPGA, il est possible d'envisager la conception de grosdispositifs avec un effort et des délais toujours réduits 29 . Les outils de synthèse se basantsur le langage VHDL (qui possède une normalisation récente en 1993), et grâce àl'existence de ce langage, permettent un développement coordonné de ces outils. Ilsouvrent aussi la voie à la portabilité des architectures qui offre la pérennité et une base detravail aux concepteurs d'architectures.Il devient possible de mettre en oeuvre des concepts qui n'étaient pas viables jusqu'àprésent. Les architectes ont toujours eu des solutions à proposer pour résoudre de manièreefficace des problèmes informatiquement parlant trop complexes. Ces concepts (comme le29 l'intégration des FPGA actuels va jusqu'au million de portes logiques ce qui fait de l'ordre de 10 millionsde transistors.131

calculateur systolique auquel nous nous sommes intéressé) deviennent maintenant nonseulement expérimentable, mais aussi viables grâce à la reconfigurabilité des moyensélectroniques.132

Conclusion.133

134

Dans ce mémoire, il a été fait état de deux versants complémentaires de travauxpermettant la mise en correspondance d'images aériennes. Cela a donné lieu à deux parties.L'énoncé d'un algorithme inspiré de l'algorithme pyramidal a été proposé. Cet algorithmepyramidal possède une spécificité car un modèle projectif plan résultant de l'analyse ducontexte de la vision aérienne est déterminé. Le modèle peut être déterminé parl'approximation de la mesure du flot optique entre les images. Nous avons donc toutd'abord évalué qualitativement des méthodes de mise en correspondance dense d'imagespar plusieurs opérateurs de calcul du champ de disparité stéréoscopique. Cela a mis enévidence que la méthode choisie est très adaptée à la mesure du champ du fait de la naturedes transformations élémentaires engendrées par la projection de deux images selon deuxangles de vue (et à deux instants distincts), et la capacité de l'algorithme de programmationdynamique (elastic matching) à prendre en compte ces transformations.Grâce à la mesure dense du flot optique, et à la modélisation géométrique de latransformation que présente le champ de vecteurs, en analysant le contexte de la visionaérienne, il est possible de définir un algorithme itératif pyramidal dont la condition deconvergence est contrôlée par la qualité du modèle déterminé. Par cet algorithmepyramidal, c'est la conformité du modèle de recalage projectif d'images aériennes quidécide d'une itération réussie. Afin que la détermination du modèle décide de laconvergence, il faut s'assurer de conditions correctes de mesure du flot optique. Si lechamp de vecteurs déterminé n'est pas correct, l'approximation par une transformation n'estpas possible. La mesure du flot optique ne peut être effectuée que si une hypothèse estvérifiée : S'il y a invariance spatio-temporelle de la réflectance des éléments de la scèneobservés. Cette hypothèse n'est en toute rigueur jamais vérifiée. Toutefois on peut seramener à des conditions convenables de mesure en observant le contexte dans lequel noussommes.Nous sommes en présence d'images très corrélées (elles se recouvrent pour plus de70% de leur contenu), le flot optique peut donc être déterminé à condition que l'éclairagedes images soit rendu similaire. Les images ont un contenu très proche, une correctionstatistique linéaire de la distribution des luminances (histogramme) peut permettre desatisfaire correctement l'hypothèse du flot optique. A cette correction près, et si la mesuredu flot optique possède certaines propriétés de robustesse vis à vis des conditions réelles deprise de vue (distorsions, bruit etc ...) la convergence de la méthode, par la déterminationdu modèle projectif peut avoir lieu.Le choix de l'ajustement d'une mesure dense du champ de disparité par le modèlede transformation plane projective est très favorable du fait de la nature du modèle. Ilpossède au minimum 8 paramètres, et c'est à condition que les données mesurées soientnombreuses (vis à vis du nombre de paramètres) que l'ajustement sera précis. Noussélectionnons les vecteurs de champ de disparité en fonction d'une mesure d'incertitude. Ilest présenté pour l'ajustement du modèle (par l'algorithme des moindres carrés non linéairesupervisé) de l'ordre de 256 vecteurs mesurés (quelle que soit la résolution des images de135

la pyramide). La densité de la mesure favorise beaucoup l'estimation du modèle (et laprécision de la transformation obtenue).Le choix d'une mesure dense du champ de disparité conduit à un algorithme trèsrégulier de mesure du champ. Il permet d'obtenir une très grande robustesse et très bonneprécision de calcul. Ce sont des contraintes qui sont énoncées dans le cadre de notre projetde mise en correspondance d'images aériennes. Toutefois, cela conduit à une très grandecomplexité du calcul, au regard des données d'images que nous avons à traiter. Lacomplexité du calcul est en O(N 2 ) pour des images de taille NxN. C'est à dire que le tempsde calcul est multiplié par un facteur constant (typiquement 4 puisque l'on quadruple lataille des images) à chaque nouvelle résolution pyramidale d'image. Mis à part lescontraintes sur la nature des transformations géométriques pour notre application, lorsqueles contraintes de temps réel (durée des traitements d'une seconde) et d'embaquabilité desmoyens de calcul sont énoncés, cela conduit à la nécessité de réaliser une accélérationmatérielle, par la mise en oeuvre d'un dispositif électronique dédié.Pour le calcul du champ de disparité nous avons choisi un algorithme dense. Celapermet d'envisager une structure matérielle simple et régulière. Cette structure donne lieu àun flot constant de données d'images, traitées de manière identique, qui permet de satisfaireles contraintes strictes de notre application.Il nous est imposé de faire une mesure automatique de transformation d'image, sansl'assistance d'un opérateur. Nous présentons un algorithme basé sur le principe de laprogrammation dynamique orthogonale (ODP), mais pour lequel la nature destransformations géométriques acceptables sont différentes, dans le contexte de lastéréoscopie généralisée. C'est à dire qu'aucune contrainte d'alignement des lignes d'imagesn'est posée, et que le problème est énoncé avec une transformation projectivebidimensionnelle (bornée toutefois). Le choix des paramètres, des poids, des seuils et despropriétés des fonctions qui interviennent est justifié. L'une des raisons du choix decertains paramètres est liée aux caractéristiques de la vision humaine. Le calcul étanteffectué automatiquement, et dans un ordre de grandeur du temps de réaction d'unopérateur humain, il faut que la mesure soit au moins aussi fiable que le serait unopérateur.Des résultats qualitatifs sont présentés qui démontrent que l'analyse du contexte, etsa modélisation ont été corrects. Les résultats sont encourageants qualitativement, mais pasdu point de vue de la contrainte de temps d'exécution. Cela conduit à la deuxième partie dece mémoire, qui traite de l'accélération matérielle du calcul de flot optique. En effet, parmitous les constituants de l'algorithme général, évalués temporellement, c'est la mesure duchamp de disparité qui est la plus pénalisante dans la réalisation (en temps réel) de laméthode.136

Il est possible de trouver des algorithmes qui répondent de manière satisfaisante auxproblèmes complexes de traitement d'image. On peut même lorsque les problèmes sonttrop complexes pour être modélisés, avoir recours à des méthodes de classification parapprentissage (réseaux de neurones). Mais lorsque certaines contraintes spécifiques à lavision autonome sont énoncées (coût, consommation, embarquabilité, temps réel etc ...)cela nécessite non seulement des compromis algorithmiques, mais aussi impose laréalisation de dispositifs dédiés. L'état actuel des technologies nécessite une réflexion surl'adéquation des algorithmes, car le progrès des technologies à moyen terme voire à longterme ne permet pas de satisfaire les contraintes.Dans la deuxième partie de ce mémoire, il est proposé le modèle d'un dispositifinspiré du modèle des calculateurs systoliques. Celui-ci permet l'adéquation du principealgorithmique de calcul de programmation dynamique avec une architecture dédiée,satisfaisant les contraintes. Ce calculateur, grâce à une spécification fonctionnelle permetd'obtenir l'estimation de temps plus conformes aux contraintes. Dans un deuxième temps,la mise en oeuvre d'un prototype matériel (sur un circuit programmable FPGA) impose denouvelles contraintes qui font évoluer la description fonctionnelle (écrite en C sur unemachine séquentielle SPARC, puis en C* parallèle sur la machine CM-5).La mise en oeuvre est parallèle avec un contrôle asynchrone (piloté par les donnéesd'images) et permet d'obtenir des temps de traitement conformes aux ordres de grandeurénoncés. Nous envisageons ensuite les optimisations matérielles par l'analyse du modèlefonctionnel. La description structurelle découle de l'assemblage de cellules élémentaires decalcul dans la grille 2D du calculateur. Nous avons vu en effet que le calcul dense del'algorithme de programmation dynamique donne lieu à un flot régulier de donnéesd'images traitées de manière identique. Cela correspond à une machine dont la structure estrégulière, et est assemblée à partir de processeurs élémentaires (PE) identiques répliquéspour former un réseau bidimensionnel. Cette structure bidimensionnelle est favorable àl'implantation dans un dispositif matériel électronique, d'autant plus, comme dans notrecas, que les communications entres les processeurs élémentaires sont locales (un PE necommunique qu'avec ses voisins immédiats à la manière des automates cellulaires).Lorsque les optimisations et les contraintes d'implantation sont envisagées, il estpossible de réaliser une description structurelle (en VHDL) du calculateur conforme aumodèle. Toutes ces étapes ont permis d'élaborer une description synthétisable, car nousavons décrit et validé le circuit à différents niveaux d'observation. La prise en compte descontraintes à chaque niveau remet en cause tous les niveaux supérieurs et nécessite denombreuses validations. Même si un dispositif complet n'est pas réalisable, il faut s'assurerque s'il l'était, il donnerait un résultat conforme sur des images. C'est à dire que lesimulateur (en C ou en C*) dont nous présentons les résultats, fonctionne de la même façonque la description structurelle (en VHDL). Nous avons pour cela recours à des séquencesde test ("test bench") sur des données complexes (cas réel).137

On se rend compte qu'il n'est pas possible de réaliser matériellement un dispositifpermettant la mise en correspondance des images traitées sans qu'une solution devirtualisation du dispositif soit envisagée. Le calculateur a été validé à petite échelle, puisporté sur un dispositif (FPGA) plus à même de traiter des images. Il faut toutefois, du faitde la contrainte d'embaquabilité, envisager d'utiliser et de réutiliser un dispositif réduit afinde traiter des morceaux d'images. En traitant des tronçons d'images, et en utilisant aumieux le matériel électronique disponible, on est à même de satisfaire la contrainted'embarquabilité. Toutes les contraintes doivent être envisagées car l'application lenécessite. Cela vient s'ajouter aux contraintes de réalisations, et la justification descompromis réalisés pour l'application ou sa mise en oeuvre, est souvent complémentaire.Cela prouve l'adéquation entre l'énoncé du problème et la méthode employée pour sarésolution.Par exemple les propriétés de la fonction de coût que nous avons défini à un hautniveau prennent en compte à la fois à des bonnes propriétés locale (tendantexpérimentalement vers un coût local optimal) qu'à la nécessité de compression dedynamique rendue nécessaire pour le codage en vue de l'implantation etc ... Les contraintess'expriment différemment à différents niveaux de réalisation, mais participent au mêmeproblème d'adéquation. Lors de la mise en oeuvre du dispositif, nous avons moins à fairedes compromis, qu'à énoncer différemment pour chaque niveau de description, les mêmescontraintes.Dans la deuxième partie de ce mémoire nous nous sommes attachés à accélérer pardes moyens matériels le calcul de l'algorithme de programmation dynamique. Nous avonsobtenu un dispositif qui répond aux contraintes de notre application dans les ordres degrandeur qui avaient été imposés. Il serait tout aussi envisageable de traiter del'accélération des calculs de convolution rendus nécessaire pour le filtrage des images pourconstituer les images de la pyramide (convolueur hardware). On aurait pu envisager aussid'accélérer le traitement de l'algorithme qui applique la transformation projective (warpinghardware). Toutefois c'est en accélérant le calcul de programmation dynamique que le gainen temps de calcul (speedup) est prépondérant. Aucune solution matérielle pour cetteaccélération n'est à l'heure actuelle proposée, alors que pour les autres constituants del'algorithme pyramidal des solutions (y compris industrielles) sont proposées.Le recalage projectif des images que nous effectuons est en fait un préalable à lareconstruction en trois dimensions à partir de vues aériennes (ou tout au moins des scènesoù la composante de profondeur visuelle est peu prononcée). Un domaine d'applicationimmédiat est donc la constitution de modèles numériques de terrain (MNT) pour lacartographie par exemple. Un autre domaine d'application où le recalage intervient estaussi la "réalité augmentée". Il s'agit dans ce cas d'assister un opérateur, en superposant à laréalité du terrain des informations supplémentaires qui vont le guider dans son travail. Onpeut envisager de réaliser de l'indexation d'images, qui permet de reconnaître une imagedans une base d'images, grâce à l'appariement de son contenu. Le flot optique étant calculé138

par notre dispositif, l'application dans le domaine de la compression de séquences d'imagesest aussi envisageable. En effet, l'estimation de mouvement est à la base de la compressiondynamique de ces algorithmes (MPEG). On peut se rendre compte que notre réalisationdans le contexte immédiat de notre application, constitue plus généralement une primitivede calcul répandue, qui peut être ouverte à de nombreux autres domaines.139

140

Bibliographie[Anc93] N. Ancona, T. Poggio, Optical flow 1D correlation : application to a simple timeto-crashdetector. In Proceedings of the 4th International Conference on Computer Vision,pages 209-214, Berlin, Allemagne, Mai 1993.[Bel57] Bellman, R., Dynamic programming, Princeton University Press, 1957[Ben92] A. Bensrhair, Contribution à la réalisation d'un capteur de vision 3D parstéréovision passive, Thèse de doctorat, Université de Rouen 1992[Bér99] D. Béréziat, Détection et suivi de structures déformables en mouvement,application à la météorologie, Thèse de doctorat, Université Paris Sud 1999.[Ber92] J.R. Bergen, P.J.Burt, R. Hingorani, and S. Peleg, A Three Frame Algorithm forEstimating Two-Component Image Motion, IEEE Trans. on PAMI, Vol 14, Dec 1992, pp.886-896.[Bur83] P.J. Burt, C. Yen, and X. Xu. Multi-resolution ow-through motion analysis. InIEEE Conference on Computer Vision and Pattern Recognition, pages 246-252,Washington, DC, June 1983.[Cer96] E. Cerclier, Décomposition fonctionnelle d'opérateurs de détection et d'estimationde mouvement en traitement d'images, Thèse de doctorat, Université Paris Sud 1996.[Dup98] Duplaquet M., Building large image mosaics with invisible seam lines,Proceedings of the SPIE, The International Society for Optical Engineering, vol 3387,1998, pp 369-77[Fau93] O. Faugeras, Three-Dimensional Computer Vision, A Geometric Viewpoint, TheMIT Press, 1993[Gro98] P. Gros. De l'appariement l'indexation des images. Habilitation à diriger desrecherches, Institut National Polytechnique de Grenoble, Décembre 1998.[Int94] Stephen S. Intille and Aaron F. Bobick Disparity-Space Images and LargeOcclusion Stereo European Conference on Computer Vision, p. 179-186, Vol B, Springer-Verlag, May 1994.[Kan95] T. Kanade, et al, Development of a Video Rate Stereo Machine, Proc. ofInternational Robotics and Systems Conference (IROS-95), Pittsburgh, PA, August 7-9,1995.141

[LeC98] F. Le Coat, E. Pissaloux, P. Bonnin, Th. Garié, F. Durbin, A. Tissot, Conceptiond'une Architecture systolique pour le calcul parallele de l'algorithme de programmationdynamique., 4eme Journées Adéquation Algorithme Architecture en traitement du signal etimages, CEA/LETI, Saclay, France, 28-30 janvier 1998, pp. 207-212.[LeC97] F. Le Coat, E. Pissaloux, P. Bonnin, Th. Garié, F. Durbin, A. Tissot, A parallelAlgorithm for a Very Fast 2D Velocity Field Estimation, IEEE's 1997 InternationalConference on Image Processing, Santa Barbara, USA, 26-29 Octobre, 1997. Vol. II pp.179-183[LeC94] F. Le Coat Conception et caractérisation d'un dispositif électronique mettant enoeuvre l'algorithme de programmation dynamique, mémoire de stage de DEA, Septembre1994[Loo99] C. Loop and Z. Zhang. Computing Rectifying Homographies for Stereo Vision.Technical Report MSR-TR-99-21, Microsoft Research, April 1999.[Min83] M. Minoux Programmation mathématique, théorie et algorithmes.. Dunod 1983.[NEC94] 7764 NEC , NEC DataBook, 1994[Owe97] Charles B. Owen, Fillia Makedon, Bottleneck-free Separable Affine ImageWarping IEEE's 1997 International Conference on Image Processing, Santa Barbara,USA, 26-29 Octobre, 1997. Vol. I pp. 683-686[Pic89] B. Picinbono, Théorie des signaux et des systèmes, Dunod 1989[Pis2000] Pissaloux E., Le Coat F., A 3 C & its Application to spatial Optimisation of aParallel Architecture dedicated to Image Matching, Proc. Int. Conf. on Computer Vision,Pattern Recognition & Image Processing CVPRIP'2000, Atlantic City, USA, Feb. 27-March 3, 2000.[Pis99b] Edwige E. Pissaloux, Francois Le Coat, Patrick Bonnin, A. Tissot, F. Durbin,Design and Optimization of a parallel architecture dedicated to image matching, IEEE's1999 International Conference on Image Processing, Kobe, Japan, 25-28 Octobre, 1999.[Pis99a] E. Pissaloux, F. Le Coat, P.Bonnin et al. Optimal design and implementation of aparallel VLSI circuit dedicated to image matching SPIE's Int. Symp. on Intelligent systemsand Advanced Manufacturing, BOSTON Ma. USA, 19-22 Sep. 1999, vol. 3837.[Pis98] E.E.Pissaloux, F.Le Coat, P.Bonnin, A.Tissot, F.Durbin and T.Garié Design andRealisation of a Parallel Systolic Architecture Dedicated to Aerial Image Matching.,142

MVA'98 IAPR Workshop on Machine Vision Applications, Chiba, Japan, November 17-19, 1998.[Pis98c] Pissaloux Edwige E., Le Coat Francois, Bonnin, Patrick J., Tissot A., Durbin, F.,Garié, Thierry Design and implementation of a systolic circuit dedicated to dynamicprogramming algorithm parallel calculation., SPIE's Intelligent Systems and AdvancedManufacturing, Boston, Massachusetts, 1-6 November 1998, Vol. 3526, p. 43-51.[Pis98b] E. Pissaloux, F. Le Coat, P. Bonnin, A. Tissot, F. Durbin, Th. Garié, Toward adesign of Data Driven Parallel Circuit for Signals Comparison., ICSPAT 1998,International Conference On Signal Processing Applications & technology, Toronto,Canada, September 13-16 1998, pp. 1503-1507.[Pis98a] E. Pissaloux, F. Le Coat, P. Bonnin, A. Tissot, F. Durbin, Th. Garié, Jane You, AParallel Method for Aerial Image Matching using a Modified Dynamic ProgrammingAlgorithm., IEEE ICIPS'98, 2nd International Conference on Intelligent ProcessingSystems, Gold Coast, Australia, August 4-7 1998, pp. 173-176.[Pis97] E. Pissaloux, F. Le Coat, P. Bonnin, G. Bezencenet, F. Durbin, A. Tissot, A veryfast dynamic programming based parallel algorithm for aerial image matching, Proc. ofthe SPIE 's 11th Annual Int. Symp. on Aerospace/Defence Sensing, Simulation andControl, Orlando, USA, Avril, 1997, vol. 3069, pp 354-360.[Pis96] E. Pissaloux, F. Le Coat, P.Bonnin et al. A parallel method for matching of aerialimages SPIE's Int. Symp. on Intelligent systems and Advanced Manufacturing, BOSTONMa. USA, 18-22 Nov. 1996, vol. 2904, pp. 75-81[Pre92] William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery,Numerical Recipes in C : The Art of Scientific Computing. Cambridge University Press,1992.[Qué88] G. M. Quénot, Conception d'un microprocesseur de comparaison dynamique pourla reconnaissance vocale, Thèse de doctorat, Université Paris Sud, 1988[Qué92] G. M. Quénot The "Orthogonal Algorithm" for Optical Flow Detection usingDynamic Programming, IEEE International Conference on Acoustics, Speech and SignalProcessing, San Francisco, CA, USA, March 1992.[Qué96] Georges M. Quénot, Computation of Optical Flow Using Dynamic Programming,Machine Vision Applications, Tokyo, Japan, 12-14 nov 1996.[Qui89] P. Quinton et Y. Robert, Algorithmes et architectures systoliques, Masson, 1989143

[Rob92] L. Robert, R. Deriche et O.D. Faugeras. Dense depth recovery from stereoimages. In Proceedings of the European Conference on Artificial Intelligence, pages 821-823, Vienna, Austria, August 1992.[Sor94] Sorel, Y., Massively Parallel Computing Systems with Real Time Constrains — theAlgorithm Architecture Adequation, Proc. of the IEEE Conference on Massively ParallelComputing Systems, pp. 282-294, Ischia, (Italy), 2-6 May , 1994, pp. 44—53[Sze96] R. Szeliski. Video mosaics for virtual environments. IEEE Computer Graphics andApplications, pages 22-30, March 1996.[Sze93] Szeleski, and Sing Bing Kang Recovering 3D Shape and Motion from ImageStreams using Non-Linear Least Squares, Technical report DEC-CRL-93-3, DigitalEquipment Corporation, Cambridge Research Lab, 1993.[Vas98] M.C. Vasiliu High Precision Image Matching using 4D Optimal Minimisation,Proc. of ICASSP, 12-15 May 1998, Seattle, Washington, USA[Wu88] Y. Wu and H. Maitre, A New Dynamic Programming Method for StereovisionIgnoring Epipolar Geometry, Ninth International Conference on Pattern Recognition(Rome, Italy, November 14--17, 1988), pp. 146-148, Computer Society Press, 1988.[Zha97] Z. Zhang and G. Xu. A General Expression of the Fundamental Matrix for BothPerspective and Affine Cameras, In Proc. Fifteenth International Joint Conference onArtificial Intelligence (IJCAI'97), pages 1502-1507, Nagoya, Japan, August 23-29, 1997.144

Résumé :Le projet de recherche porte sur deux aspects de la mise au point d'un dispositif électronique deguidage d'un robot aérien autonome. Il s'agit, grâce à un capteur passif : une caméra, de mettre au point unalgorithme de vision, qui permette le recalage du robot par rapport à une trajectoire connue. Nous disposonsd'images prises lors d'une phase de reconnaissance, qui devront être appariées aux images de mission, afin depouvoir situer le robot. Cette étude porte sur la conception d'un algorithme, en ayant pour but sonimplantation électronique dans un dispositif matériel embarquable permettant l'analyse temps réel desdonnées captées.L'algorithme consiste en un recalage projectif, par une approximation bidimensionnelle du flotoptique, grâce à un modèle géométrique explicite de transformation 2D. Pour les traitements de bas niveau, ila été conçu à partir de la reformulation de l'algorithme de programmation dynamique. Le but de cetteformulation est la capacité à implanter celui-ci sur la maille d'un processeur systolique dont les performancestemporelles soient satisfaisantes. L'architecture visée comporte un VLSI dédié au calcul du champ dedéplacement et un processeur de traitement de signal (DSP) capable de calculer la transformation projectiveissue des deux images comparées. L'algorithme a été conçu et évalué avec la perspective de sa réalisationmatérielle (méthodologie d'adéquation entre celui-ci et sa réalisation) qui constitue la deuxième phase de ceprojet.La deuxième phase consiste en la réalisation matérielle d'un prototype de calculateur permettant desatisfaire les contraintes strictes. Ce calculateur est validé grâce à une implantation et une évaluation sur unFPGA (Field Programmable Gate Array) à l'aide d'un langage de description matérielle (VHDL). Desrésultats temporels et qualitatifs sont obtenus. La portabilité et l'extensibilité du dispositif sont aussiprouvées, ce qui garanti la pérennité des travaux._______________________________________________________________________________________Abstract :The research project relates two aspects of the conception of an electronic device that allowsguidance of an autonomous aerial robot. Thanks to a passive sensor : a camera, we develop a visionalgorithm, which allows the matching of the robot compared to a known trajectory. We have taken images ata phase of recognition, which will have to be paired with the images of mission, in order to be able to locatethe robot. This study relates to the design of an algorithm, by having in mind its electronic implemetation inan onboard material device, allowing the real time analysis of the collected data.The algorithm consists of a projective matching, by a two-dimensional approximation of the opticalflow, thanks to an explicit geometrical model of 2D transformation. For the low level processing, it wasdesigned starting from the reformulation of the dynamic programming algorithm. The goal of thisformulation is the capacity to implement it on the mesh of a systolic processor whose temporal performancesshould be satisfactory. The concerned architecture comprises a VLSI dedicated to the calculation of thedisplacement field, and a signal processor (DSP) able to calculate the projective transformation resultingfrom the two compared images. The algorithm was designed and evaluated with the goal of its materialrealization (methodology of adequacy between the algorithm and its realization) which constitutes the secondphase of this project.The second phase consists of the material realization of a prototype of calculator that satisfy thestrict constraints. This calculator is validated thanks to the design of a prototype on a FPGA (FieldProgrammable Gate Array) using a material description language (VHDL). Temporal and qualitative resultsare obtained. The portability and the scalability of the device are also proved, which guarantee theperenniality of this work.