FR3034515B1 - Systeme d'affichage d'elements avioniques - Google Patents

Abstract

Le système d'affichage (100) d'éléments avioniques selon la présente invention sert à afficher une scène dans un habitacle d'aéronef. La scène peut, par exemple, être un affichage complexe d'instruments comprenant des milliers et des milliers de primitives graphiques. Le système d'affichage (100) d'éléments avioniques comporte une unité centrale CPU (10), un processeur graphique GPU (54) coopérant avec la CPU (10), et un afficheur (90). Le GPU (54) comprend au moins un nuanceur de sommets, et la CPU (10) est conçue pour fournir au(x) nuanceur(s) de sommets des données de sommets représentant au moins une primitive graphique et pour appeler le/les nuanceur(s) de sommets afin de rendre dans un tampon (56) de trame la/les primitive(s) graphique(s) représentant au moins une partie de la scène. L'afficheur (90) coopère avec le tampon (56) de trame et affiche la scène. L'architecture du système d'affichage (100) d'éléments avioniques simplifie le processus de codage pour le développeur et rend le traitement d'image plus rapide en comparaison de systèmes selon la technique antérieure.

Description

Système d’affichage d’éléments avioniques

La présente invention concerne globalement un système d'affichage d'éléments avioniques destiné à servir dans divers types d'aéronefs.

Au cours des dernières décennies, l'utilisation d'habitacles en verre pour aéronefs, dans lesquels les afficheurs d'instruments analogiques ont été remplacés par des afficheurs d'instruments électroniques sur écrans, est devenue de plus en plus courante y compris dans les aéronefs légers. Depuis la fin des années 80, les systèmes électroniques certifiés de présentation d'instruments de bord (EFIS) comportant de tels afficheurs d'instruments électroniques font partie des équipements standard des avions de ligne Boeing® et Airbus®.

Bien que les récents progrès dans la puissance de calcul et les baisses du coût des écrans d'affichage et des capteurs pour la navigation (tels que les systèmes mondiaux de localisation (GPS), les centrales de cap et d'assiette, etc.) aient contribué à étendre le marché des EFIS, ceux-ci utilisent généralement encore une technologie exclusive propre à chaque fabricant pour réaliser les graphiques complexes à haute définition nécessaires pour fournir les éléments spécifiques essentiels à afficher requis dans les aéronefs, notamment l'horizon artificiel (ADI), l'indicateur de situation horizontale (HSI), etc.

Par conséquent, à mesure que davantage de fonctions, plus de complexité et une plus haute définition sont apportés à ces afficheurs EFIS, une plus grande puissance de traitement est exigée des processeurs à technologies exclusives uniquement pour générer la scène présentée aux pilotes sur l'afficheur. Non seulement cela annihile, par exemple, certains des avantages liés à l'utilisation de processeurs de toutes dernières générations fonctionnant à de plus hautes fréquences d'horloge, mais encore il en résulte un codage plus complexe et plus long lorsqu'il s'agit de programmer le résultat de l'affichage. De ce fait, le développeur a besoin de plus de temps et il y a davantage de risques que des erreurs ne se glissent dans le code au moment de l'installation d'EFIS certifiés ou non certifiés de nouvelles générations.

Ainsi, la présente invention vise à proposer un système perfectionné d'affichage d'éléments avioniques, qui soit plus facile à configurer et qui fonctionne plus rapidement que les afficheurs EFIS selon la technique antérieure. Divers autres avantages apparaîtront au fil de la description qui va suivre.

Selon un premier aspect de la présente invention, il est donc proposé un système d'affichage d'éléments avioniques destiné à afficher une scène dans un habitacle d'aéronef. La scène peut comprendre, par exemple, un affichage complexe d'instruments pour EFIS composé de milliers de primitives graphiques. Le système d'affichage d'éléments avioniques comporte une unité centrale (CPU), un processeur graphique (GPU) et un écran coopérant avec un tampon de trame.

Le GPU coopère avec la CPU et comprend au moins un nuanceur de sommets. En fonctionnement, la CPU fournit au(x) nuanceur(s) de sommets des données de sommets représentant au moins une primitive graphique et appelle le/les nuanceur(s) de sommets afin de rendre dans le tampon de trame la/les primitive(s) graphique(s) représentant au moins une partie de la scène.

Selon un second aspect de la présente invention est également proposé un procédé pour afficher une scène dans un habitacle d'aéronef. Le procédé comporte la sollicitation d'une CPU pour fournir à au moins un nuanceur de sommets des données de sommets représentant au moins une primitive graphique, l'appel du/des nuanceur(s) de sommets afin de rendre dans un tampon de trame la/les primitive(s) graphique(s) représentant au moins une partie de la scène et l'affichage de la scène sur un écran à partir du tampon de trames.

En remplaçant par un nuanceur de sommets le code de rendu de la CPU selon la technique antérieure, on réduit la quantité de données qu'il faut transmettre entre la CPU et le GPU pour transcrire la/les primitive(s) graphique(s). En outre, le codage est également simplifié et le processus de transcription est aussi bien plus rapide.

De plus, la CPU nécessite moins de puissance de traitement et peut donc être simplifiée. Cela permet, par exemple, de remplacer des processeurs selon la technique antérieure, propres à des applications, par des processeurs standard du commerce, consommant peu d'énergie tels qu'un processeur à technologie RISC ou un autre type de processeur susceptible, par exemple, être utilisé dans des applications pour téléphonie mobile. De tels processeurs impliquent également moins de refroidissement et ne nécessitent donc pas de grands dissipateurs de chaleur ni d'équipements de refroidissement encombrants alimentés en énergie, ce qui allège l'ensemble des composants électroniques que l'aéronef doit transporter. L'invention sera mieux comprise à l'étude détaillée de quelques modes de réalisation pris à titre d'exemples non limitatifs et illustrés par les dessins annexés sur lesquels : -la Figure 1 représente un système d'affichage d'éléments avioniques selon une forme de réalisation de la présente invention ; -la Figure 2 représente le pipeline de rendu utilisé par le GPU du système d'affichage d'éléments avioniques de la Figure 1 selon une forme de réalisation de la présente invention ; -la Figure 3 représente une primitive graphique définie à l'aide d'un code de rendu de CPU selon la technique antérieure ; -la Figure 4 représente des primitives graphiques rendues avec une précision variable, produites à l'aide du code de rendu de CPU selon la technique antérieure ; -la Figure 5 représente un graphique crénelé et un graphique anticrénelé pouvant être produits par diverses formes de réalisation de la présente invention ; -la Figure 6 représente des primitives graphiques pouvant être produites par diverses formes de réalisation de la présente invention ; -la Figure 7 représente des primitives graphiques complexes utilisables avec diverses formes de réalisation de la présente invention ; -la Figure 8 représente une vue découverte d'une primitive graphique complexe pouvant être produite par diverses formes de réalisation de la présente invention ; -la Figure 9 représente une autre primitive graphique utilisable avec diverses formes de réalisation de la présente invention ; -la Figure 10 illustre le traitement de la primitive graphique de la Figure 9 par un nuanceur de fragments d'un pipeline de rendu selon une forme de réalisation de la présente invention ; -la Figure 11 illustre la manière dont un anticrénelage est appliqué par le nuanceur de fragments à la primitive graphique de la Figure 9 selon une forme de réalisation de la présente invention ; -la Figure 12 représente la primitive graphique rendue de la Figure 9, transcrite dans une scène sur un afficheur ; et -la Figure 13 illustre un procédé pouvant être mis en œuvre selon diverses formes de réalisation de la présente invention.

La Figure 1 représente un système d'affichage 100 d'éléments avioniques selon une forme de réalisation de la présente invention. Le système d'affichage 100 d'éléments avioniques utilise une technique de traitement graphique perfectionnée pour afficher une scène dans un habitacle d'aéronef. De plus il permet d'utiliser des composants ordinaires qui peuvent être déjà certifiés selon des normes, moins coûteux, plus simples et/ou plus légers, de telle sorte que la fiabilité soit améliorée et de façon que la certification du système tout entier par divers organismes de l'industrie aéronautique (FAA, CAA, etc.) puisse avoir plus de chances d'être accordée.

Le système d'affichage 100 d'éléments avioniques comporte une unité centrale (CPU) 10. La CPU 10 est connectée à des éléments avioniques 20 par un bus 12 d'éléments avioniques. Des données relatives à des instruments de bord sont transmises à la CPU 10 via le bus 12 d'éléments avioniques, puis sont traitées par la CPU 10 et servent ensuite à afficher des données de vol sur un afficheur 90. Dans certaines formes de réalisation, la CPU 10 peut, par exemple, faire partie d'un système redondant comprenant une pluralité de CPU similaires qui traitent sensiblement les mêmes informations qui font l'objet de comparaisons et/ou de recherches d'erreurs afin d'assurer la fiabilité et la tolérance aux anomalies du système. L'allègement des processeurs et de leurs équipements de refroidissement associés est ainsi plus grand si de tels processeurs sont utilisés en grand nombre pour réaliser un système redondant.

La CPU 10 est munie d'une mémoire système 16. La mémoire 16 peut comprendre une mémoire non rémanente (p.ex. une mémoire vive) et/ou rémanente (p.ex. une mémoire flash). Dans diverses formes de réalisation, la CPU 10 est un processeur Intel®Baytrail SoC, version E3827. Celui-ci a une consommation de 8 watts et est léger. La faible consommation d'énergie signifie qu'il est produit moins de chaleur et donc que la CPU 10 est plus fiable. En outre, le processeur E3827 est léger, peu coûteux, facile à se procurer et a fait ses preuves dans d'autres domaines d'application.

En outre, la CPU 10 est couplée à une carte graphique 50 via un bus graphique 18. Le bus graphique 18 peut, par exemple, comprendre une interface d'interconnexion de périphériques (PCI), une interface PCI Express (PCIe) ou un port graphique accéléré (AGP). Dans une forme de réalisation, la carte graphique 50 est une carte GeForce GTX 750 Ti et le bus graphique 18 fonctionne à l'aide d'une PCI Express 3.0.

La carte graphique 50 fournit une interface de programmation d'applications API 52 pour mettre la CPU 10 en interface avec un processeur graphique (GPU) 54. Le GPU 54 comprend au moins un cœur de processeur, ainsi qu'une mémoire vidéo rapide 58. Par exemple, 640 cœurs CUDA indépendants peuvent être prévus pour faciliter le traitement en parallèle d'instructions uniques, données multiples (SIMD) dans le GPU 54. Ces cœurs de processeur constituent des circuits de représentation en virgule flottante, à base de matériel rapide et puissant, qui sont ainsi bien adaptés au traitement de données mathématiques complexes.

Chacun de ces cœurs de processeur peut être programmé par l'intermédiaire de ΓΑΡΙ 52 pour constituer divers étages d'un pipeline de rendu tels qu'un nuanceur de sommets. Le nuanceur de sommets est un programme qui agit sur un ensemble de sommets, lesquels définissent les limites d'une primitive graphique, afin de transformer mathématiquement les positions de celle-ci dans un espace virtuel en 3D en coordonnées à 2D, forme sous laquelle elles apparaîtront dans un tampon 56 de trame, puis sur l'afficheur 90. Outre la position, le/les nuanceur(s) de sommets peuvent aussi être programmés pour manipuler des coordonnées de couleurs et de textures de sommets. Les sommets et/ou les divers attributs de ceux-ci sont définis par des données de sommets représentant la/les primitive(s) graphique(s).

Le/les nuanceur(s) de sommets peut/peuvent être programmés, par exemple, conformément à la spécification OpenGL. Diverses bibliothèques connues conformes à OpenGL peuvent être utilisées au moment du codage du/des nuanceur(s) de sommets. Dans diverses formes de réalisation, le Langage de Nuançage OpenGM de type C (GLSL) est employé pour générer des données de sommets sous la forme d'un ensemble de chaînes rendu conforme, servant à programmer le/les nuanceur(s) de sommets du pipeline de rendu programmable du GPU afin de permettre des effets d'images individualisés. Un appel du/des nuanceur(s) de sommets exécute un rendu de la/des primitive(s) graphique(s) définies par les données de sommets, le résultat étant inscrit dans le tampon 56 de trame. L'afficheur 90 coopère avec le tampon 56 de trame et peut afficher le contenu du tampon 56 de trame sous la forme d'une scène en plein écran qui comprend de multiples primitives graphiques rendues qui illustrent conjointement, par exemple, un ADI, un HSI, etc.

Ainsi, la nature individualisable du pipeline de rendu programmable du GPU est exploitée par la présente invention pour permettre à la charge issue de la CPU 10 d'être transférée dans le GPU 54. De plus, un traitement global plus rapide est possible car diverses fonctions (p.ex. la détermination de données de sommets supplémentaires nécessaires pour définir diverses primitives graphiques) sont déléguées au GPU 54, ce qui assure donc que la CPU 10 ne consacre pas de temps à envoyer des instructions et des données au GPU 54 ni donc à attendre le GPU 54 pour en terminer.

De plus, le codage est simplifié pour le développeur, puisqu'il faut un nombre réduit d'instructions et de points de données pour exécuter les fonctions de traitement graphique nécessaires au rendu de la scène final. A titre d'exemple, l'inventeur a constaté, au cours d'essais, que même pour une forme de réalisation non optimisée le traitement de la scène accélérait d'un facteur au moins égal à deux, malgré le fait que le nombre de lignes de code nécessaires pour mettre en œuvre l'invention était de l'ordre de 6 à 12, à comparer aux 200 à 500 lignes qui étaient nécessaires auparavant pour le rendu de la scène selon la technique antérieure.

La Figure 2 représente un pipeline de rendu 200 utilisable par le GPU 54 du système d'affichage 100 d'applications avioniques décrit plus haut. Le pipeline de rendu 200 définit une suite d'opérations exécutées par le GPU 54 pour le rendu d'un objet à afficher tel qu'une primitive graphique. Le pipeline de rendu est un exemple susceptible d'être mis en œuvre par un seul cœur de processeur d'un GPU 54. Un grand nombre de tels pipelines peuvent être prévus pour des cœurs parallèles respectifs de processeur, lorsque les données de sommets sont indépendantes les unes des autres, de façon qu'un traitement de SIMD puisse être réalisé. Les primitives graphiques sont des formes de dessins de base qui peuvent comprendre, par exemple, des triangles, des droites, des points, des couronnes, des cercles, etc.

La CPU 10 peut commencer par élaborer une matrice de sommets qui comprend les données de sommets. Pour des éléments d'affichage fixes tels que le contour d'un HSI, par exemple, celles-ci peuvent comprendre des données statiques stockées dans une matrice préconfigurée de sommets définissant les primitives graphiques nécessaires requises pour représenter les éléments d'affichage fixes de la scène finale.

Un nuanceur 202 de sommets charge ensuite, depuis la matrice de données de sommets, des données définissant des sommets respectifs. Les systèmes d'affichage d'applications avioniques selon la technique antérieure ne présentent pas un tel nuanceur de sommets dans un pipeline de rendu de GPU pour y générer des scènes. Des données d'attributs définissant les sommets respectifs comprennent au moins une position dans trois dimensions (ïvn, jvn, Zyn) dans un espace virtuel pour chaque sommet, «, et produisent une liste ordonnée de sommets qui sont à envoyer au pipeline de rendu 200. L'interprétation de la manière dont la liste de sommets est interprétée comme primitive graphique est prise en charge dans un étage ultérieur du pipeline de rendu 200.

Dans diverses formes de réalisation, des matrices de sommets stockées dans la mémoire système 16 servent à transmettre des données d'attributs de sommets au GPU 54 à l'aide d'appels d'API. Cependant, il est également possible d'utiliser des objets de tampon de sommets qui sont stockés dans la mémoire vidéo 58, ce qui offre l'avantage qu'il faut moins d'appels d'API lancés par la CPU 10 pour réaliser le rendu des sommets. Par exemple, la CPU 10 peut définir localement dans la mémoire système 16 les attributs de sommets, puis créer un objet de tampon avant de transmettre les attributs de sommets à l'aide de fonctions glBufferData() ou de glBufferSubData(), ou par mappage du tampon à l'aide de fonctions glMapBuffer() ou glMapBufferRange().

Le nuanceur 202 de sommets convertit chaque sommet d'entrée en sommet de sortie suivant un programme défini par l'utilisateur. Celui-ci comprend des transformées spatiales 3D ou 2D pour, par exemple, faire tourner des objets dans l'espace virtuel. Cependant, dans cette application, une transformation positionnelle n'est généralement pas nécessaire puisque le nuanceur 202 de sommets est principalement utilisé pour les effets complémentaires supportés, relatifs aux fonctions de rendu. En ne nécessitant pas l'utilisation d'une transformation positionnelle pour les données de sommets, le traitement s'effectue encore plus vite. Cet aspect du traitement de sommets à l'aide du nuanceur 202 de sommets est décrit plus en détail plus loin.

Les données de sortie du nuanceur 202 de sommets sont utilisées ensuite pour l'assemblage des primitives. En fonction du type de primitive que l'utilisateur a rendue, celle-ci est alors décomposée en une suite ordonnée de primitives simples (à savoir des droites, des points ou des triangles). Dans diverses formes de réalisation utilisant OpenGL, cette fonction est assurée par un nuanceur de géométries qui peut être obtenu par une version par défaut ou être défini par l'utilisateur.

Eventuellement, la suite de primitives simples peut ensuite être tesselée à l'aide d'un étage de tessellation 204. L'étage de tessellation 204 applique un nuanceur de commande de tessellation à la suite de primitives simples avant de les tesseler à l'aide d'un étage de tessellation à fonction fixe. Les données issues de l'étage de tessellation à fonction fixe sont en outre traitées à l'aide d'un nuanceur d'évaluation de tessellation pour produire la sortie finale de l'étage de tessellation 204.

Un autre nuanceur facultatif 206 de géométries peut ensuite aussi être utilisé pour traiter soit la sortie du nuanceur 202 de sommets soit l'étage facultatif de tessellation 204 éventuellement présent. Le nuanceur 206 de géométries constitue un étage programmé défini par l'utilisateur, apte à traiter les primitives graphiques définies, par exemple, par la liste de sommets d'entrée. La sortie du nuanceur 206 de géométries est composée de zéro ou d'un plus grand nombre de primitives simples. Un tel nuanceur 206 de géométries peut, par exemple, fonctionner conformément à OpenGL 3.2 ou à des spécifications plus récentes.

Le nuanceur 206 de géométries sert à retirer des primitives de la liste d'entrée ou à les tesseler en créant de multiples primitives pour une seule entrée. Les sommets peuvent également être manipulés et les primitives peuvent être converties d'un type à un autre, par exemples des droites en points, des points en triangles, etc. Les nuanceurs, tels que le nuanceur 206 de géométries, sont fournis par des programmes qui agissent sur des données d'entrée pour produire les données de sortie appropriées.

Dans certaines formes de réalisation, les primitives simples créées par le nuanceur 206 de géométries ou par suite de l'assemblage de primitives peuvent être inscrites dans un ensemble d'objets prédéfinis de tampon, en mode rétroaction de transformation, Les données ainsi créées peuvent être conservées pour servir ultérieurement, ce qui rend plus rapide la totalité du traitement nécessaire au rendu de la scène. Ce mode rétroaction de transformation peut, de plus, être efficacement utilisé comme sortie finale du pipeline de rendu 200.

Selon une autre possibilité, la sortie du nuanceur 206 de géométries peut éventuellement servir d'entrée d'un étage d'élagage 208. L'étage d'élagage divise en multiples primitives les primitives situées à une limite entre l'extérieur et l'intérieur d'un volume de vision. Les primitives situées à l'extérieur de la limite sont exclues de l'ensemble de données de sortie.

Les primitives simples sont ensuite soumises à une rastérisation par un étage de rastérisation 210. La rastérisation convertit la suite entrante de primitives en images respectives en deux dimensions, appelées fragments. Chaque point de ces fragments contient des informations telles que la couleur et la profondeur.

La rastérisation d'une primitive consiste en deux étapes. La première détermine quels carrés d'une grille d'entiers en coordonnées de fenêtre/affichage sont occupés par la primitive. La seconde attribue une couleur et une valeur de profondeur à chacun de ces carrés.

Les fragments produits par l'étage de rastérisation 210 sont fournis comme entrée à un nuanceur 212 de fragments, parfois appelé nuanceur de pixels. Le nuanceur 212 de fragments transforme chaque fragment en un jeu de trois couleurs et une valeur de profondeur et ajoute éventuellement aussi des valeurs de données de pochoir. La valeur de profondeur (valeur z) définit la position en profondeur du fragment dans un espace 3D et les valeurs de couleurs fournissent les données sur les couleurs classiques RVB nécessaires pour afficher le fragment sur l'afficheur 90.

Un étage de post-traitement 214 intervient ensuite sur les données de sortie du nuanceur 212 de fragments pour déterminer celles qui sont à inscrire dans le tampon de trame 56 pour être affichées sur l'afficheur 90. Si nécessaire, l'étage de post-traitement 214 commence par réaliser divers tests d'élimination. Dans l'hypothèse d'une telle configuration, un test de pochoir peut être réalisé sur les fragments, et ceux qui échouent au test sont éliminés. Un test de profondeur peut également être réalisé, tout fragment échouant au test étant de même éliminé et non ajouté dans le tampon de trame 56.

Un mélange en tampon de trame est ensuite réalisé entre les fragments qui sont inscrits dans le tampon de trame 56 et toutes valeurs de couleurs déjà dans le tampon de trame 56 au même endroit que celui où sont inscrits les fragments.

Dans l'étage 216, les données sur les fragments sont ensuite inscrites dans le tampon de trame 56 pour être affichées sur l'afficheur 90. Eventuellement, l'utilisateur peut aussi réaliser diverses opérations de masquage concernant notamment la profondeur, la couleur, le pochoir, etc., pour créer divers effets dans la scène finale rendue.

La Figure 3 représente une primitive graphique 300 définie à l'aide du code de rendu d'une CPU classique. La primitive graphique 300 est un cercle défini par un sommet central 302 entouré radialement par trente autres sommets 304 disposés sur son pourtour. Une série de sommets définissant la primitive graphique 300 comprend des données de sommets correspondant aux sommets 302, 304 placés successivement de manière à définir un maillage de triangles successifs 306 approximant un cercle ayant pour centre le sommet 302.

Diverses autres primitives graphiques peuvent également être définies à l'aide d'un maillage de triangles. Par exemple, ces autres primitives graphiques peuvent comprendre une ellipse, une couronne, un arc, un rectangle, un rectangle à angles arrondis, un trait simple, des traits multiples, du texte, etc.

La CPU génère toutes les listes de sommets, de triangles et de couleurs. Celles-ci sont ensuite envoyées pour le rendu. Afin d'améliorer l'affichage par l'EFIS, des lignes anticrénelées sont nécessaires pour esquisser les graphiques. Ces lignes accroissent le nombre de points de sommets nécessaires. En outre, par exemple, il faut approximer un graphique de cercle pour contribuer à réduire le nombre de triangles nécessaires afin de définir le périmètre du cercle. On utilise donc des cercles prédéfinis pour éviter d'avoir à effectuer des calculs trigonométriques.

Ainsi, les systèmes selon la technique antérieure nécessitent des couches de portage graphique qui assurent des fonctions pour tracer des primitives complexes nécessitant de calculer des sommets chaque fois qu'elles sont appelées. Lors de l'exécution d'un remplissage avec gradient, chaque sommet nécessite que sa couleur soit définie ou que des textures soient utilisées. Quel que soit le cas, cela implique que des informations supplémentaires sur les sommets soient calculées et envoyées. Une telle complexité signifie que même le codage d'une primitive complexe relativement simple à l'aide de techniques classiques requiert plus de cent lignes de code.

La Figure 4 représente trois primitives graphiques 305, 310, 315, figurant des cercles, rendues avec une précision variable, qui peuvent être produites à l'aide du code de rendu classique illustré sur la Figure 3. Ces primitives graphiques 305, 310, 315 figurent un cercle après un rendu utilisant différents nombres de sommets comme entrée pour la série de sommets.

Dans chaque maillage de triangles respectif, les primitives graphiques 305, 310, 315 sont efficacement rendues sous la forme de cercles ayant une circonférence de cercle approximée à l'aide d'un certain nombre de droites. De ce fait, pour améliorer la précision du rendu, le nombre de lignes, défini par le nombre de sommets et donc le nombre de primitives triangulaires, doivent être accrus.

Cependant, si de trop nombreuses lignes sont utilisées par primitive, cela affecte la vitesse de rendu. En revanche, si trop peu de lignes sont utilisées, l'utilisateur pourra percevoir la primitive graphique comme un polygone à N côtés (ce qu'on appelle l'effet 50p, visible sur la Figure 4 lorsque les primitives graphiques passent de l'utilisation de trente sommets périphériques dans la primitive graphique 305 à vingt dans la primitive graphique 310 et à dix dans la primitive graphique 315). Par conséquent, il y a un compromis entre l'approximation et la vitesse de rendu si on utilise des techniques antérieures.

La Figure 5 représente un graphique crénelé 330 et un graphique anticrenelé 340 qui peuvent être produits par diverses formes de réalisation de la présente invention. Les deux graphiques 330, 340 sont produits à partir des mêmes sommets d'entrée fournis au pipeline de rendu 200 dans une série de sommets. L'anticrénelage est réalisé par le nuanceur de fragments dans le pipeline de rendu. Il est calculé, pixel par pixel, de la manière suivante : i) si le pixel est entièrement à l'intérieur de la primitive graphique, une couleur complète est appliquée au pixel respectif ; si le pixel est entièrement à l'extérieur de la primitive graphique, il est alors rejeté ; et iii) si le pixel est partiellement contenu dans la primitive graphique, l'effet d'anticrénelage est alors appliqué en fonction du pourcentage de présence du pixel dans la primitive graphique.

Sur le graphique 330, on voit des artefacts crénelés (bords irréguliers) lorsque la primitive graphique définie par la série de sommets est affichée après rendu sur l'afficheur 90. La réalisation d'un rendu anticrénelé permet de supprimer les bords irréguliers à l'aide de techniques de rendu qui attribuent des couleurs de pixel d'après une fraction d'une surface de pixel couverte par la primitive graphique. Une telle technique donne les bords plus lisses visibles sur le graphique 340.

Ordinairement, des techniques d'anticrénelage classiques auraient une incidence massive sur la vitesse de rendu, car elles impliquent normalement que la primitive graphique soit tracée de multiples fois (p.ex. en utilisant à plusieurs reprises le code de rendu de CPU de la Figure 3). Cela peut donc poser des problèmes si on utilise une technique de rendu classique commandée par la CPU, mais pas dans le cas de la présente invention dans laquelle peut être utilisé le nuanceur de fragments du pipeline de rendu 200.

La Figure 6 représente des primitives graphiques pouvant être produites par diverses formes de réalisation de la présente invention. La primitive graphique circulaire 350 peut être définie soit par un ensemble de sommets qui définissent un maillage de triangles dans la série de sommets, soit du fait de sommets qui définissent le périmètre d'un cercle.

Quel que soit le cas, la primitive graphique 350 représentée a été rendue sous la forme d'un cercle plein par le pipeline de rendu 200. En revanche, le pipeline de rendu 200 a été programmé pour rendre la primitive graphique 360 avec un contour uniquement à l'aide des mêmes données de série de sommets d'entrée par primitive graphique 350.

La figure 7 représente des primitives graphiques complexes 370, 380 utilisables avec diverses formes de réalisation de la présente invention. Les primitives graphiques complexes 370, 380 utilisent les mêmes données de base de série de sommets que par primitives graphiques 350 et 360.

Cependant, les primitives graphiques 370, 380 sont des primitives graphiques complexes, car un certain nombre de primitives de base sont commandées en tant que primitive graphique unique à l'aide de divers paramètres d'attributs supplémentaires. Ces paramètres d'attributs peuvent définir, par exemple, la largeur du contour, un motif de contour en pointillé, une couleur de contour, une couleur de remplissage, un gradient de remplissage, une couleur de halo, une largeur de halo, etc.

Dans les exemples représentés, la primitive graphique complexe 370 utilise des paramètres d'attributs de largeur de contour, de motif de contour en pointillé, de couleur de contour, de couleur de remplissage, de couleur de halo et de largeur de halo. La primitive graphique complexe 380 utilise des paramètres d'attributs de largeur de contour, de motif de contour en pointillé, de couleur de contour, de couleur de halo et de largeur de halo.

La Figure 8 représente une vue découverte d'une primitive graphique complexe 390 pouvant être produite par diverses formes de réalisation de la présente invention. La primitive graphique complexe 390 est un cercle complexe rempli, esquissé, pourvu d'un halo et d'un anticrénelage. La primitive graphique complexe 390 est produite par rendu d'une donnée de série de sommets à l'aide du pipeline de rendu 200 et comprend un remplissage 392, un contour 394, un halo 396 et trois lignes anticrénelées 398, 400, 402. Une telle primitive graphique complexe rendue 390 peut, par exemple, être utilisée dans le cadre d'un HSI figuré comme faisant partie d'une scène dans un afficheur EFIS d'éléments avioniques.

Si on utilise la technique de la présente invention, dans laquelle la logique de création de triangles passe de la CPU 10 au nuanceur 202 de sommets, la CPU 10 a seulement besoin d'envoyer quelques points pour définir le contour de la même primitive graphique. L'anticrénelage est également calculé par le GPU 54, pixel par pixel, à l'intérieur du nuanceur 202 de sommets. Un périmètre de cercle est également défini par pixel, et par conséquent est extrêmement lisse. Des fonctions sinus et cosinus intégrées précises sont fournies par des tables de consultation dans le GPU 54, et sont donc très rapides. Une mise en mémoire cache de données de sommets n'est pas nécessaire et des remplissages avec gradient sont efficacement réalisés par le GPU 54. De plus, le codage est simplifié et nécessite moins de lignes pour coder la même primitive graphique complexe (moins de cent dans le cas présent).

La Figure 9 représente une autre primitive graphique 410 utilisable avec diverses formes de réalisation de la présente invention, par exemple pour constituer une partie d'une scène pour un afficheur EFIS à l'aide du pipeline de rendu 200. La primitive graphique 410 est créée par un programme d'ellipse qui a servi à programmer le nuanceur 202 de sommets. Le nuanceur 202 de sommets ainsi programmé peut aussi servir à rendre des cercles, des couronnes et des arcs.

La CPU 10 définit deux triangles 414 en générant un ensemble de quatre sommets 412. Ces triangles sont présentés sous la forme de sommets successifs dans la série de sommets transmise au pipeline de rendu 200.

La CPU 10 appelle ensuite le nuanceur 202 de sommets avec les données suivantes : centre du cercle, grand axe (A) d'ellipse, petit axe (B) d'ellipse, largeur de couronne, angle initial, angle final, couleur de contour, largeur de contour, couleur de halo, largeur de halo et couleur de remplissage.

Le nuanceur 202 de sommets peut être employé pour définir un rectangle extérieur d'après les sommets 412. Plutôt que de remplir/rendre de multiples triangles individuels comme dans la technique antérieure (cf. Figure 3, par exemple), le nuanceur 202 de sommets peut être employé pour colorer l'intérieur ainsi que l'extérieur de la primitive graphique 410 définie dans les limites du rectangle extérieur. Par exemple, la zone à l'extérieur de l'ellipse mais à l'intérieur du rectangle extérieur peut être rejetée (c'est-à-dire non modifiée pour la rendre transparente) si la primitive graphique est à placer dans une scène. Cela permet que la totalité des fonctions du nuanceur 202 de sommets soient utilisées pour réaliser un rendu 2D d'image à l'intérieur du rectangle extérieur tout en limitant le plus possible le nombre d'instructions ainsi que la taille de la série de sommets nécessaires.

La Figure 10 illustre le traitement de la primitive graphique la Figure 9 par le nuanceur 212 de fragments du pipeline de rendu 200. Le nuanceur 212 de fragments détermine, pour chaque pixel px,y d'une grille de pixels 420, l'endroit dans l'ellipse où se retrouve le pixel. Les positions relatives de la grille 420 et de l'ellipse déterminent la couleur du pixel px,y, qui est établie en fonction de sa position, s'il se retrouve à l'intérieur de l'ellipse, ou qui est rendue transparente 425 s'il se retrouve à l'extérieur de celle-ci. La grille 420 est représentée superposée au remplissage 422, au contour 424 et au halo 426.

De ce fait, un nombre réduit de points (p.ex. un nombre minimal pour définir un rectangle) sont envoyés par la CPU 10 pour définir efficacement un canevas. Le nuanceur 212 de fragments trace ensuite la forme requise sur le canevas sans que la CPU 10 n'ait à envoyer tous les sommets.

La Figure 11 montre comment un anticrénelage est réalisé par le nuanceur 212 de fragments sur la primitive graphique de la Figure 9. Le nuanceur 212 de fragments réalise l'anticrénelage entre les limites 428, 430 et 432 de couleurs respectivement présentes entre chacun des remplissages 422, contour 424, halo 426 et fond 425. Dans le cas présent, cela a été exécuté à l'aide d'une simple rampe linéaire entre chacune des deux couleurs respectives.

La Figure 12 représente la primitive graphique rendue finale 500 inscrite dans le tampon de trame 56 pour figurer dans une scène sur l'afficheur 90. La Figure 12 est en outre annotée pour représenter la grand axe (A), le petit axe (B) et les angles initial et final qui ont été utilisés comme paramètres d'attributs dans le pipeline de rendu 200.

La Figure 13 illustre un procédé 600 qui peut être mis en œuvre selon diverses formes de réalisation de la présente invention. Le procédé 600 sert à afficher une scène dans un habitacle d'aéronef à l'aide d'un système d'affichage d'éléments avioniques et comporte l'utilisation 610 d'une CPU pour fournir à au moins un nuanceur de sommets des données de sommets représentant au moins une primitive graphique, l'appel 620 du/des nuanceur(s) de sommets afin de rendre dans un tampon de trame la/les primitive(s) graphique(s) représentant au moins une partie de la scène, et l'affichage 630 de la scène sur un afficheur à partir du tampon de trame. Les données de sommets peuvent être fournies sous la forme d'un objet de tampon de sommets et stockées dans une mémoire vidéo. Dans diverses formes de réalisation, les données de sommets peuvent être converties d'un ensemble de données tridimensionnelles en ensemble de données bidimensionnelles.

Dans diverses formes de réalisation, le procédé 600 peut servir à déterminer si, oui ou non, un pixel d'une scène se trouve à l'intérieur ou à l'extérieur d'une éventuelle primitive graphique particulière. Une définition reposant sur des pixels plutôt que sur des sommets peut ainsi être utilisée pour les diverses primitives graphiques. Cela offre les avantages que des primitives plus lisses peuvent être produites en éliminant sensiblement l'approximation présente si on utilise le rendu selon la technique antérieure, et que les pixels situés aux limites des primitives graphiques peuvent être convenablement colorés pour réduire les effets de bords désagréables dans la scène finale rendue.

Une interface spécifique de programmation d'application (API) peut être prévue pour mettre la CPU en interface avec un GPU. Par exemple, ΓΑΡΙ peut fonctionner suivant la spécification OpenGL.

Le procédé 600 peut comporter en outre l'exécution d'une opération d'anticrénelage sur des données de pixels stockées et/ou le rendu d'une pluralité de primitives graphiques représentant au moins une partie d'une scène en parallèle à l'aide de multiples pipelines de nuanceurs de sommets en parallèle.

Le procédé 600 permet de réduire la charge de travail de la CPU à l'appel du nuanceur de sommets dans un GPU. Le matériel plus rapide dans le GPU assure une plus grande vitesse des calculs de fonctions trigonométriques, des opérations vectorielles et des matrices. L'anticrénelage est également réalisé au prix d'une très faible surcharge en comparaison des techniques équivalentes par CPU, tout en permettant une précision des pixels plutôt que le rendu de la précision des sommets par la CPU. De plus, la présente invention permet le rendu d'une primitive graphique complète, et même d'une primitive graphique complexe, en une seule opération. Un rendu bidimensionnel (2D) d'une surface d'image complète autour d'une primitive graphique peut aussi être réalisé. Par exemple, des rectangles à angles arrondis peuvent être produits plus facilement à l'aide de la présente technique.

Divers avantages de formes de réalisation de la présente invention comprennent également la possibilité de réduire le coût, le poids et la consommation d'énergie de systèmes d'affichage d'éléments avioniques à l'aide d'organes de téléphonie mobile bon marché, consommant peu d'énergie, appelés Système-sur-Puce (SoC) en réduisant la puissance de calcul requise.

Diverses formes de réalisation de la présente invention ont été décrites ici. Les spécialistes de la technique auront bien conscience que ces formes de réalisation peuvent être mises en œuvre de la manière souhaitée en utilisant, par exemple, un ou plusieurs élément(s) à base de logiciel, de matériel et/ou de microprogramme.

Par exemple, les spécialistes de la technique comprendront que la position, la teinte, la saturation, la luminosité et le contraste de tous les pixels, sommets et textures servant à construire une scène finale peuvent être modifiés instantanément à l'aide d'algorithmes définis dans les divers nuanceurs. Ces nuanceurs peuvent être exécutés sur du matériel/un microprogramme spécifique (p.ex. sommet/pixel/ géométrie) ou à l'aide de processeurs génériques aptes à exécuter n'importe quel type de nuanceur (p.ex. les cœurs CUDA d'une carte graphique GeForce GTX 750 Ti).

Claims (16)

1. REVENDICATIONS

   1. Système d'affichage (100) d'éléments avioniques pour afficher une scène dans un habitacle d'aéronef, le système d'affichage (100) d'éléments avioniques comportant : une unité centrale (CPU) (10) ; un processeur graphique (54) coopérant avec l’unité centrale (10), le processeur graphique (54) comprenant au moins un nuanceur (202) de sommets, l’unité centrale (10) étant conçue pour fournir audit nuanceur (202) de sommets des données de sommets représentant au moins une primitive graphique et pour appeler ledit nuanceur (202) de sommets afin de rendre dans un tampon (56) de trame ladite primitive(s) graphique(s) représentant au moins une partie d'une scène ; et un afficheur (90) couplé au tampon (56) de trame pour afficher ladite scène.
2. 2. Système d'affichage (100) d'éléments avioniques selon la revendication 1, dans lequel le processeur graphique (54) et le tampon (56) de trame sont fournis par une carte graphique (50) qui comprend en outre une mémoire vidéo (58), et dans lequel la carte graphique (50) sert aussi à fournir une interface de programmation d'application (API) (52) pour mettre l’unité centrale (10) en interface avec le processeur graphique (54).
3. 3. Système d'affichage (100) d'éléments avioniques selon la revendication 2, dans lequel l’unité centrale (10) produit les données de sommets sous la forme d'un objet en mémoire de trame ou sous la forme d'une liste de points stockée dans la mémoire vidéo (58).
4. 4. Système d'affichage (100) d'éléments avioniques selon la revendication 2 ou la revendication 3, dans lequel l’interface de programmation d’application (52) fonctionne conformément à la spécification OpenGL.
5. 5. Système d'affichage (100) d'éléments avioniques selon l'une quelconque des revendications précédentes, dans lequel les données de sommets sont converties en ensemble de données bidimensionnelles.
6. 6. Système d'affichage (100) d'éléments avioniques selon l'une quelconque des revendications précédentes, dans lequel le processeur graphique (54) sert à exécuter une opération d'anticrénelage sur des données de pixels stockées dans le tampon (56) de trame.
7. 7. Système d'affichage (100) d'éléments avioniques selon l'une quelconque des revendications précédentes, dans lequel le processeur graphique (54) comprend un pipeline de nuanceur de sommets ayant un nuanceur (206) de géométries.
8. 8. Système d'affichage (100) d'éléments avioniques selon l'une quelconque des revendications précédentes, dans lequel le processeur graphique (54) comprend de multiples pipelines de nuanceurs de sommets en parallèle.
9. 9. Procédé (600) pour afficher une scène dans un habitacle d'aéronef à l'aide d'un système d'affichage (100) d'éléments avioniques, le procédé (600) comportant : l'utilisation (610) d'une unité centrale (10) pour fournir à au moins un nuanceur (202) de sommets des données de sommets représentant au moins une primitive graphique; l'appel (620) dudit nuanceur (202) de sommets afin de rendre dans un tampon (56) de trame ladite primitive graphique représentant au moins une partie de la scène ; et l'affichage (630) de la scène sur un afficheur (90) à partir du tampon (56) de trame.
10. 10. Procédé (600) selon la revendication 9, comportant en outre la prévision d'une interface de programmation d'application (API) pour mettre l’unité centrale (10) en interface avec un processeur graphique (54).
11. 11. Procédé (600) selon la revendication 10, dans lequel l’interface de programmation d’application (52) fonctionne conformément à la spécification OpenGL.
12. 12. Procédé (600) selon l'une quelconque des revendications 9 à 11, comportant en outre la production des données de sommets sous la forme d'un objet de tampon de sommets et le stockage de l'objet de tampon de sommets dans la mémoire vidéo (58).
13. 13. Procédé (600) selon l'une quelconque des revendications 9 à 12, comportant en outre la conversion des données de sommets d'un ensemble de données tridimensionnelles en ensemble de données bidimensionnelles.
14. 14. Procédé (600) selon l'une quelconque des revendications 9 à 13, comportant en outre l'exécution d'une opération d'anticrénelage sur des données de pixels stockées dans le tampon (58) de trame.
15. 15. Procédé (600) selon l'une quelconque des revendications 9 à 14, comportant en outre le rendu, en parallèle, à l'aide de multiples pipelines de nuanceurs de sommets en parallèle, d'une pluralité de primitives graphiques représentant au moins une partie de la scène.
16. 16. Procédé (600) selon l'une quelconque des revendications 9 à 15, dans lequel on vérifie si chaque pixel de la scène comprend on non au moins une primitive graphique de manière à éviter une approximation de ladite primitive graphique dans la scène.