Voir la source de Rastérisation

{{À sourcer|date=mai 2016}}

La '''rastérisation''', ou '''matricialisation''', est un procédé qui consiste à convertir une [[image vectorielle]] en une [[image matricielle]] destinée à être affichée sur un [[Écran d'ordinateur|écran]] ou imprimée par un [[Imprimante|matériel d'impression]].

Les scènes en {{Nobr|3 dimensions}} étant généralement stockées en [[Mémoire vive|mémoire]] sous forme vectorielle, ce terme s'applique également pour leur rendu à l'écran (l'écran fournissant une image matricielle), c'est d'ailleurs la principale utilisation du mot « rastérisation ». Par extension, on englobe aussi dans la rastérisation tous les procédés permettant d'améliorer l'aspect final du rendu 3D.

La rastérisation d'images en deux dimensions étant nécessaire à l'intérieur de son équivalent 3D, la suite de cet article s'intéressera uniquement à la rastérisation d'images en trois dimensions dans le but de détailler les deux méthodes simultanément.

Ce procédé est l'une des deux principales techniques de rendu 3D, avec le [[Lancer de rayon|''{{Langue|en|ray tracing}}'']] (« reconstitution du trajet des rayons »). Comparée au ''{{Langue|en|ray tracing}}'', la rastérisation est beaucoup plus rapide en matière de calcul.

== Étymologie ==
[[Fichier:Raster rastrus rastrum 1890.png|vignette|upright|Le terme ''raster'' dans [https://books.google.com/books?id=DLcUAAAAYAAJ&pg=PA546&dq=raster+image+date:0-1935&lr=&as_brr=1&ei=H343SduOKZXSlQSelanmBg ''{{Langue|en|A Dictionary of Roman and Greek Antiquities}}''].]]

''Rastérisation'' se calque sur l’anglais ''{{Langue|en|rasterize}}''. En anglais, le suffixe ''{{Langue|en|-ize}}'' forme des verbes à partir de noms ou d'adjectifs, le verbe signifiant alors « faire/fabriquer ce qui est dénoté par le nom »<ref>{{en}} http://en.wiktionary.org/wiki/-ize.</ref>. Le nom ''{{Langue|en|raster}}'' vient de l’allemand ''{{Langue|de|Raster}}'', du latin {{Langue|la|raster}} (« râteau, hoyau »), de l’infinitif {{Langue|la|radere}} du verbe {{Langue|la|rādo}} (« racler, ratisser, gratter, écorcher »)<ref>{{en}} http://en.wiktionary.org/wiki/raster.</ref>.

En anglais courant, ''{{langue|en|raster}}'' désigne le motif de lecture affine de lignes parallèles utilisé pour former une image projetée sur le [[tube cathodique]] d’un écran. D’où la reprise du terme pour désigner une [[image matricielle]] qui est constituée d’une grille de [[pixel]]s, stockée comme une série de lignes.

Le terme ''matricialisation'', plus rare, découle également du passage à une version matricielle de l’image, par rapport à une [[image vectorielle]]. Cependant, ces termes sont eux-mêmes ambigus, des vecteurs pouvant être stockés et manipulés sous forme de matrices. Dans ce vocable, les images matricielles désignent des images décrites point à point, et les images vectorielles tout autre type de description d’une scène nécessitant une transformation vers une image point à point pour affichage.

== Principe géométrique de base ==
La conversion d'images vectorielles en trois dimensions vers une image matricielle en deux dimensions se fait en deux étapes : la conversion de l'image vectorielle 3D en image vectorielle 2D, puis la rastérisation (voir [[récursivité]]) de celle-ci en une image matricielle 2D finale.

=== Calcul des coordonnées 2D ===
La première étape est la [[Projection (géométrie)|projection]] des différents [[Modélisation tridimensionnelle|modèles]] de l'image vers le plan 2D.
Ce calcul peut être résumé en trois étapes :
* l'intégration du modèle dans le monde, ''{{Langue|en|Model to World}}'' (''M2W'') ;
* la prise en compte de la position et de l'angle de la caméra, ''{{Langue|en|World to View}}'' (''W2V'') ;
* la prise en compte des dimensions de l'écran, ''{{Langue|en|View to Projection}}'' (''V2P'').

Chacune de ces étapes correspond à une [[matrice (mathématiques)|matrice]]. Le calcul est une simple multiplication des coordonnées de chaque sommet avec les trois matrices. On obtient ainsi pour chaque sommet ses coordonnées 2D ainsi que sa profondeur.

Remarque : dans les [[Interface de programmation|API]] 3D actuelles, [[Direct3D]] utilise ces trois matrices alors qu'[[OpenGL]] n'utilise pas la matrice monde (''{{Langue|en|World}}'') : en effet, elle est combinée avec la matrice ''{{Langue|en|View}}'' donnant par conséquent une matrice ''{{Langue|en|Model-View}}'' (GL_MODELVIEW) (remarque valable pour les anciennes versions de l'API OpenGL qui, à partir de la version 4.0, n'implémente plus de système de gestion de matrices, qui doit être pris en charge par le programmeur, dans une optique de flexibilité de la gestion du [[Pipeline 3D|pipeline graphique]]).

==== Transformation ''{{Langue|en|Model to World}}'' ====
La [[matrice (mathématiques)|matrice]] M2W correspond à une succession d’opérations réalisées sur un objet. Ces opérations sont :
* la rotation ;
* la translation ;
* la mise à l'échelle.

En termes physiques on dirait qu’appliquer une matrice M2W à un objet revient à passer du référentiel propre à l’objet (le modèle) au référentiel commun à tous les objets d’une scène graphique (le monde).

:{| class="toccolours collapsible collapsed" width="90%" style="text-align:left"
!Les matrices de rotation
|-
|* Matrice de rotation dans le plan :
[[Fichier:Info_3D_repere_oij.PNG]]
Soit
<math>
A = \left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
\end{array}} \right);B = \left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
\end{array}} \right)
</math>
et
<math>
\overline {OA}  = \overline {OB}
</math>
<br />
<math>\left\{ {\begin{array}{*{20}c}
   {x_A  = \cos \alpha .\overline {OA} }  \\
   {y_A  = \sin \alpha .\overline {OA} }  \\
\end{array}} \right.
</math>
<br />
<math>
\left\{ {\begin{array}{*{20}c}
   {x_B  = \cos (\alpha  + \beta ).\overline {OB} }  \\
   {y_B  = \sin (\alpha  + \beta ).\overline {OB} }  \\
\end{array}} \right.
\Leftrightarrow
</math>
<br />
<math>
\left\{ {\begin{array}{*{20}c}
   {x_B  = (\cos \alpha .\cos \beta  - \sin \alpha .\sin \beta ).\overline {OB} }  \\
   {y_B  = (\cos \alpha .\sin \beta  + \sin \alpha .\cos \beta ).\overline {OB} }  \\
\end{array}} \right.
\Leftrightarrow
</math>
<br />
<math>
\left\{ {\begin{array}{*{20}c}
   {x_B  = \cos \alpha .\overline {OA} .\cos \beta  - \sin \alpha .\overline {OA} .\sin \beta }  \\
   {y_B  = \cos \alpha .\overline {OA} .\sin \beta  + \sin \alpha .\overline {OA} .\cos \beta }  \\
\end{array}} \right.
\Leftrightarrow
</math>
<br />
<math>
\left\{ {\begin{array}{*{20}c}
   {x_B  = x_A .\cos \beta  - y_A .\sin \beta }  \\
   {y_B  = x_A .\sin \beta  + y_A .\cos \beta }  \\
\end{array}} \right.
</math>
<br />
<math>
\Rightarrow
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   {\cos \beta } & { - \sin \beta }  \\
   {\sin \beta } & {\cos \beta }  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
\end{array}} \right)
</math>

* matrices de rotation dans l'espace :
Dans un repère <math>\left( {O,\vec i,\vec j,\vec k} \right)</math> l'operation ci-dessus équivaut à tourner autour du vecteur <math>\vec k</math> c'est-à-dire l'axe de z.
# autour de l'axe des z :
[[Fichier:Info_3D_repere_oijk.png]] <math>\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   {\cos \beta } & { - \sin \beta } & 0 & 0  \\
   {\sin \beta } & {\cos \beta } & 0 & 0  \\
   0 & 0 & 1 & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>

# autour de l'axe des y :
[[Fichier:Info_3D_repere_okij.png]]
L’angle de vue du repère a changé ainsi que le nom des axes, cependant par rapprochement on peut déduire :
<math>\left. {\begin{array}{*{20}c}
   {\vec i \to \vec k}  \\
   {\vec j \to \vec i}  \\
   {\vec k \to \vec j}  \\
\end{array}} \right\} \Rightarrow \left\{ {\begin{array}{*{20}c}
   {x \to z}  \\
   {y \to x}  \\
   {z \to y}  \\
\end{array}} \right.
</math><br />
On a alors:<math>\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   {\cos \beta } & 0 & {\sin \beta } & 0  \\
   0 & 1 & 0 & 0  \\
   { - \sin \beta } & 0 & {\cos \beta } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>

# autour de l'axe des x :
[[Fichier:Info_3D_repere_ojki.png]]
<math>
\left. {\begin{array}{*{20}c}
   {\vec i \to \vec k}  \\
   {\vec j \to \vec i}  \\
   {\vec k \to \vec j}  \\
\end{array}} \right\} \Rightarrow \left\{ {\begin{array}{*{20}c}
   {x \to z}  \\
   {y \to x}  \\
   {z \to y}  \\
\end{array}} \right.
</math>
On a alors :
<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   1 & 0 & 0 & 0  \\
   0 & {\cos \beta } & { - \sin \beta } & 0  \\
   0 & {\sin \beta } & {\cos \beta } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
|}

:{| class="toccolours collapsible collapsed" width="90%" style="text-align:left"
!La matrice de translation
|-
|<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   1 & 0 & 0 & {T_x }  \\
   0 & 1 & 0 & {T_y }  \\
   0 & 0 & 1 & {T_z }  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
|}

:{| class="toccolours collapsible collapsed" width="90%" style="text-align:left"
!La matrice de mise à l'échelle
|-
|<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   {S_x } & 0 & 0 & 0  \\
   0 & {S_y } & 0 & 0  \\
   0 & 0 & {S_z } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
|}

:{| class="toccolours collapsible collapsed" width="90%" style="text-align:left"
!Synthèse M2W
|-
|<math>
\left[ W \right] = \underbrace {\left[ T \right].\left[ {R_x } \right]....\left[ S \right].\left[ {R_z } \right].\left[ {R_y } \right]}_{M2W}.\left[ M \right]
</math>
* Matrices de rotation

<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \underbrace {\left( {\begin{array}{*{20}c}
   1 & 0 & 0 & 0  \\
   0 & {\cos \beta } & { - \sin \beta } & 0  \\
   0 & {\sin \beta } & {\cos \beta } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right)}_{R_x }.\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
<br />
<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \underbrace {\left( {\begin{array}{*{20}c}
   {\cos \beta } & 0 & {\sin \beta } & 0  \\
   0 & 1 & 0 & 0  \\
   { - \sin \beta } & 0 & {\cos \beta } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right)}_{R_y }.\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
<br />
<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \underbrace {\left( {\begin{array}{*{20}c}
   {\cos \beta } & { - \sin \beta } & 0 & 0  \\
   {\sin \beta } & {\cos \beta } & 0 & 0  \\
   0 & 0 & 1 & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right)}_{R_z }.\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
* Matrices de translation
<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \underbrace {\left( {\begin{array}{*{20}c}
   1 & 0 & 0 & {T_x }  \\
   0 & 1 & 0 & {T_y }  \\
   0 & 0 & 1 & {T_z }  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right)}_T.\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
* Matrices de mise à l'échelle
<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   1  \\
\end{array}} \right) = \underbrace {\left( {\begin{array}{*{20}c}
   {S_x } & 0 & 0 & 0  \\
   0 & {S_y } & 0 & 0  \\
   0 & 0 & {S_z } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right)}_S.\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>
|}

==== Transformation ''{{Langue|en|World to View}}'' ====
{{...}}
Cette matrice procède au calcul effectif des coordonnées de chaque point en fonction de la position et de la direction de la caméra.

Voici une matrice de vue classique. Pos et Dir sont les vecteurs indiquant respectivement la position de la caméra et l'endroit pointé. Le vecteur Up indique la direction verticale. Up, puis F, S et U doivent tous être normalisés.

<math>
\left( {\begin{array}{*{20}c}
   {x_B }  \\
   {y_B }  \\
   {z_B }  \\
   {w_B }  \\
\end{array}} \right) = \left( {\begin{array}{*{20}c}
   {S_x } & {S_y } & {S_z } & 0  \\
   {U_x } & {U_y } & {U_z } & 0  \\
   -{F_x } & -{F_y } & -{F_z } & 0  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   1 & 0 & 0 & -{Pos_x }  \\
   0 & 1 & 0 & -{Pos_y }  \\
   0 & 0 & 1 & -{Pos_z }  \\
   0 & 0 & 0 & 1  \\
\end{array}} \right).\left( {\begin{array}{*{20}c}
   {x_A }  \\
   {y_A }  \\
   {z_A }  \\
   1  \\
\end{array}} \right)
</math>

<math>
F = Pos - Dir
</math>

<math>
S = F * Up
</math>

<math>
U = S * F
</math>

Avec * produit vectoriel

==== Transformation ''{{Langue|en|View to Projection}}'' ====
{{...}}
La matrice de projection permet d'adapter les coordonnées calculées aux dimensions du ''[[framebuffer]]'' (c'est-à-dire de la fenêtre ou de l'écran). En effet, une fois les coordonnées multipliées par la matrice de vue, il faut encore prendre en considération la façon dont l'observateur perçoit la scène. Il faut tenir compte de certains paramètres comme les proportions de l'image (4/3, 16/9, ou autre) ou l'angle de vision (120° dans la réalité, généralement 45° à l'écran). C'est à cela que sert cette matrice.

Par exemple, pour un écran de dimensions (''width'', ''height'') on a :
: x_ecran = Xa * width / 2 / Za + width / 2
: y_ecran = Ya * height / 2 / Za + height / 2

=== Filtrage des ''vertices'' (sommets) ===
Une fois les coordonnées 2D de chaque [[Sommet (géométrie)|sommet]] connues, différentes techniques existent dans le but d'accélérer la suite du rendu.

Le ''{{Lien|back-face culling}}'' (« élimination des faces cachées ») consiste à calculer la [[Normale à une surface|normale]] de chaque face et à la comparer avec l'orientation de la caméra. Si l'angle entre les deux est supérieur à 90°, la face est dirigée vers l'extérieur et n'a donc pas besoin d'être calculée.

Si les coordonnées 2D à l'écran de tous les sommets d'une face sont à l'extérieur de la ligne formée par un des bords de la fenêtre de vision, il n'est pas non plus nécessaire d'effectuer le reste des opérations pour celle-ci.

=== Rastérisation des coordonnées 2D vers l'image finale ===
La dernière opération est de transformer chaque face, ligne ou point en pixels à l'écran.

Par exemple, une ligne qui doit aller des coordonnées (2,3) à (5,3) remplira les pixels (2,3), (3,3), (4,3) et (5,3). L'opération est néanmoins nettement plus complexe pour une ligne oblique ou pour l'intérieur d'un triangle.

Pour chaque pixel ainsi calculé, il s'agit de déterminer ses caractéristiques en pondérant les valeurs aux sommets, qui, elles, sont connues.

Pour reprendre l'exemple de la ligne, si le sommet à gauche est rouge et celui à droite est bleu, le premier pixel à gauche sera complètement rouge, le suivant un peu moins rouge et un peu plus bleu, et ainsi de suite jusqu'au dernier pixel qui sera complètement bleu.

==== ''{{Langue|en|Z-buffer}}'' ====
{{Article détaillé|Z-buffer}}

L'utilisation d'un ''{{Langue|en|z-buffer}}'' (« tampon des données de profondeur ») est une technique permettant de déterminer quel pixel se trouve au-dessus de quel autre. Il est en effet fréquent que deux éléments se chevauchent, et pour savoir quelles parties de quel(s) élément(s) sont visibles il est possible d'enregistrer au fur et à mesure leur profondeur dans un emplacement mémoire.

Ainsi, si un pixel doit écraser un autre pixel déjà existant, on vérifie grâce au ''{{Langue|en|z-buffer}}'' que le premier est plus proche de la caméra que le second. Si c'est le cas, le pixel sera écrasé et le ''{{Langue|en|z-buffer}}'' mis à jour avec la nouvelle valeur de profondeur.

Ne pas utiliser de ''{{Langue|en|z-buffer}}'' signifie que les derniers éléments à être dessinés le seront forcément au-dessus des autres, même s'ils devraient normalement être en dessous.

==== ''{{Langue|en|Stencil buffer}}'' ====
Un ''{{Langue|en|stencil buffer}}'' est un [[Mémoire tampon|tampon mémoire]] permettant de filtrer les endroits où l'image doit être dessinée. Le mot anglais ''{{Langue|en|stencil}}'' signifie « [[pochoir]] » en français.

Le ''{{Langue|en|stencil buffer}}'' et le ''{{Langue|en|z-buffer}}'' sont très liés, puisqu'il s'agit dans les deux cas de filtrer les pixels ou non. Contrairement au ''{{Langue|en|z-buffer}}'', il est possible de donner l'ordre au [[processeur graphique]] de remplir le ''{{Langue|en|stencil buffer}}'' dans certaines conditions. L'utilisation d'un ''{{Langue|en|stencil buffer}}'' repose donc généralement sur deux rendus : un premier rendu partiel permettant de remplir le ''{{Langue|en|stencil buffer}}'', puis un second rendu définitif où le filtrage est appliqué.

Pour des exemples pratiques, voir au bas de l'article (ombre portées et reflets).

==== Anticrénelage ====
{{Article détaillé|Anticrénelage}}
[[Fichier:Antialiasing comparaison.gif|vignette|300px|Exemple de l'intérêt de l'[[anticrénelage]] : à gauche (sans anticrénelage) on voit un effet d'escalier sur les bords de la lettre.]]
L'[[anticrénelage]] ou ''anti-aliasing'' permet d'éviter le crénelage des lignes à l'écran. Par exemple si une ligne va des coordonnées (1,3) à (4,4) elle doit remplir entièrement les pixels (1,3) et (4,4), mais seulement partiellement les pixels (2,3), (2,4), (3,3) et (3,4).

Sans anti-crénelage, l'algorithme ne se soucie pas du remplissage partiel, ce qui crée un effet d'escalier. Avec un anti-crénelage, un remplissage partiel est effectué grâce à la [[moyenne pondérée]] de la couleur existante à cet endroit et de la nouvelle couleur.

Le [[FSAA]] ou ''{{Langue|en|Full Screen Anti-Aliasing}}'' (« anti-crénelage de tout le décor ») consiste à calculer une image plus grande que la définition souhaitée (image sur-échantillonnée) puis à réduire sa définition vers celle souhaitée. Chaque pixel de l'image résultante est une moyenne des pixels de l'image sur-échantillonnée, adoucissant ainsi naturellement les arêtes obliques. Cette technique offre une bonne qualité et est relativement simple à mettre en œuvre, cependant elle a une influence importante sur les performances. De nombreuses autres techniques et optimisations ont été développées pour pallier ce problème de performances (MSAA, FXAA, MLAA, SMAA, TXAA, etc.).

=== Résultat final ===
Le résultat final est une image matricielle stockée dans un ''[[framebuffer|frame buffer]]'' (« tampon pour le rendu des images »). Des post-traitements peuvent intervenir sur l'ensemble ou des parties de l'image avant d'envoyer le buffer à sa destination finale (i.e., un dispositif de sortie : écran, imprimante…). Par exemple, pour faire « briller » certaines zones (cf. « [[Flou lumineux|''{{Langue|en|bloom}}'']] »), appliquer un filtre de « flou cinétique » (généralement polaire à partir du centre pour émuler un effet de mouvement rapide de l'image dans l'espace ; cf. [[Flou cinétique|''{{Langue|en|blur}}'']]), appliquer un masque sur l'ensemble de l'image ''(ex. : trou de serrure ou viseur d'une arme à feu)'', ou encore, appliquer des tampons (ex. du [[Facteur de flare|''{{Langue|en|lens flare}}'']]) {{etc.}} Certains de ces effets s'appliquent à l'ensemble de l'image ''(cas du ''{{Langue|en|bloom}}'')'' quand les autres utilisent parfois des buffers intermédiaires dédiés à leur tâche précise (cas du ''{{Langue|en|blur}}'').

== Application des textures (''{{Langue|en|mapping}}'') et éclairage ==
La base de la rastérisation ne permet néanmoins d'afficher que des objets avec des couleurs simples. La volonté de réalisme a poussé à l'invention des textures et des effets d'ombrage.

=== Application des textures (''{{Langue|en|mapping}}'') ===
{{Article détaillé|Texture (image de synthèse)}}

L'application d'une texture se fait en parallèle tout le long du processus de rastérisation. Chaque sommet initial possède, en plus de ses coordonnées 3D, les coordonnées correspondantes pour la texture à appliquer sur l'ensemble du modèle.

La véritable application de la texture ne se fait qu'au moment du calcul de la couleur de chaque pixel final. Les coordonnées de texture de chaque pixel sont calculées en modulant les valeurs des sommets, de la même manière que pour leur couleur émise et leur profondeur.

La couleur émise de chaque pixel est alors multipliée par la valeur du [[Texel (infographie)|texel]] correspondant à ces coordonnées.

==== Filtrage des textures ====
{{...}}

Néanmoins un problème se pose : plusieurs pixels peuvent afficher le même [[Texel (infographie)|texel]] (le rendu devient flou) ou inversement plusieurs texels devraient être affichés dans le même pixel.

Pour résoudre ce problème, plusieurs techniques existent : le [[filtrage bilinéaire]] consiste à prendre la moyenne pondérée des texels autour du texel à afficher, le ''[[mipmapping]]'' consiste à utiliser une texture plus petite pour les objets éloignés afin d'accélérer les calculs du filtrage. Le [[filtrage anisotrope]] est une opération dérivée du ''{{Langue|en|mipmapping}}'' (« atténuation de l'effet de pixellisation »).

=== Calcul des ombres ===
{{Article détaillé|Ombrage de Gouraud}}

L'application d'une ombre sur un objet consiste simplement à faire varier la couleur émise par chaque sommet en fonction de l'orientation de sa face par rapport aux lumières. Ce calcul se fait souvent en même temps que le calcul des coordonnées 2D.

L'opération se fait généralement en utilisant le [[produit scalaire]] de la [[Normale à une surface|normale]] de chaque face par la direction de chaque lumière. Si la normale de la face et la direction de la lumière sont [[perpendiculaire]]s, alors le produit scalaire sera égal à zéro et la face sera noire.

L'ombrage (i.e., le ''{{Langue|en|shading}}'' ; cf. ci-dessous) peut également être émulé par l'application de ''[[lightmap]]'' (consistant à pré-calculer les ombres appliquées aux textures et d'en générer une « sur-texture » d'ombrage) ainsi que par l'utilisation de certains ''{{Langue|en|shaders}}'' (afin d'émuler un bas-relief des textures ; cf. ci-dessous).

== ''{{Langue|en|Shaders}}'' ==
{{Pertinence section|date=septembre 2011}}
{{article connexe|Shader}}
Lorsque le processus de rastérisation est effectué par le matériel ([[carte graphique]] notamment), tous les calculs ci-dessus sont automatisés. Il est néanmoins possible sur la plupart des cartes depuis 2001 de personnaliser certains calculs en utilisant des [[Shader|''{{Langue|en|shaders}}'']].

Un ''{{Langue|en|shader}}'' est un [[Programme informatique|programme]] écrit dans un [[Langage de programmation|langage]] proche du [[Langage C|C]] (il en existe plusieurs : [[HLSL]], [[GLSL]], [[Cg (langage)|Cg]], etc.) qui doit être [[compilateur|compilé]] puis envoyé à la carte graphique pour qu'elle l'utilise.

=== Types de ''{{Langue|en|shaders}}'' ===
==== ''{{Langue|en|Vertex shader}}'' ====
Les ''{{Langue|en|[[vertex shaders]]}}'' permettent de commander manuellement le calcul des coordonnées et de l'éclairage. Ce type de ''{{Langue|en|shader}}'' prend en entrée les données d'un [[Sommet (géométrie)|vertex]] (coordonnées 3D, couleur propre, coordonnées texture) et les renvoie éventuellement modifiés avec leur coordonnées 2D.

Un ''{{Langue|en|vertex shader}}'' classique sert à modifier la couleur émise par chaque sommet selon divers algorithmes dans le but d'améliorer la qualité du rendu final. Le calcul des coordonnées 2D se fait la plupart du temps de la même manière que la carte l'aurait fait.

Exemple de ''{{Langue|en|vertex shader}}'' très simple en [[HLSL]] :
<pre>float4x4 WorldViewProj;

float4 VS_Transform(float4 position : POSITION0)
{
    return mul(WorldViewProj, position);
}
</pre>

La variable <code>WorldViewProj</code> représente les matrices de monde, de vue et de projection multipliées entre elles.
Le ''{{Langue|en|shader}}'' est en fait la fonction <code>VS_Transform</code>. Celle-ci multiplie tout simplement les coordonnées du vertex en entrée par les trois matrices afin de placer correctement le point sur l'écran.

Ce ''{{Langue|en|shader}}'' très simple ne gère pas la lumière.

==== ''{{Langue|en|Geometry shader}}'' ====
{{...}}

Un ''[[geometry shader]]'' est un nouveau type de ''{{Langue|en|shader}}'' introduit depuis les ''{{Langue|en|shaders model 4.0}}'' qui permet notamment d'ajouter des sommets. Il est exécuté directement après un ''{{Langue|en|vertex shader}}'' (ou son équivalent par défaut en l'absence de ''{{Langue|en|vertex shader}}'').

Ce type de ''{{Langue|en|shader}}'' prend en entrée tour à tour chaque [[Primitive (modélisation)|primitive]] de la scène (généralement des triangles) et retourne une ou plusieurs primitives qui sont ensuite passées aux étapes suivantes.

L'absence de ''{{Langue|en|geometry shader}}'' correspond à un ''{{Langue|en|shader}}'' qui retournerait directement le paramètre en entrée.

==== ''{{Langue|en|Pixel shader}}'' ====
Le ''[[pixel shader]]'', aussi appelé ''[[fragment shader]]'', permet de personnaliser le calcul de la couleur de chaque pixel.

Le ''{{Langue|en|shader}}'' prend en entrée les différents propriétés de chaque pixel (position à l'écran, coordonnées texture, couleur propre) et retourne la couleur du pixel.

=== Techniques utilisant les ''{{Langue|en|shaders}}'' ===
==== Placage de relief (''{{Langue|en|bump mapping}}'') ====
[[Fichier:Bump-map-demo-bumpy.png|vignette|Sphère sur laquelle on a appliqué la technique du ''{{Langue|en|bump mapping}}''.]]
{{Article détaillé|Placage de relief}}

Le [[placage de relief]] ou ''{{Langue|en|bump mapping}}'' consiste à modifier l'apparence d'une surface de façon à faire croire qu'elle est en relief. Ces techniques interviennent généralement au moment de la rastérisation (du dessin) des [[Texel (infographie)|texels]].

Contrairement au ''[[displacement mapping]]'' (voir ci-dessous), le ''{{Langue|en|bump mapping}}'' ne modifie pas la géométrie des objets, seulement leur couleur dans le but de donner une illusion de relief.

Il existe de nombreuses variations de cette technique, utilisant chacune une méthode de calcul légèrement différente : ''[[parallax mapping]]'', ''[[normal mapping]]''{{etc.}}

L'implémentation la plus courante est d'attribuer deux textures à l'objet : sa texture classique, et la texture servant à indiquer le relief. Chaque texel de cette deuxième texture possède une valeur indiquant quelle sera la [[Vecteur normal|normale]] à cet endroit.

L'implémentation se fait alors en deux étapes :
* un ''{{Langue|en|vertex shader}}'' crée une ''{{Langue|en|light map}}'' indiquant pour chaque vertex la provenance de la lumière dans le but de la fournir au ''{{Langue|en|pixel shader}}'' ;
* le ''{{Langue|en|pixel shader}}'' fait pour chaque pixel le [[produit scalaire]] de la provenance de la lumière avec le vecteur récupéré depuis la texture de ''{{Langue|en|bump}}''.

La technique est ainsi similaire à l'éclairage simple, mis à part que l'éclairage est calculé par le ''{{Langue|en|pixel shader}}'' (et non par le ''{{Langue|en|vertex shader}}'') et que la deuxième texture est utilisée comme une normale.

Le ''{{Langue|en|bump mapping}}'' utilise des textures ''(des ''{{Langue|en|bump maps}}'')'' n'ayant qu'une couche ''(nuances de gris)'' correspondant à la hauteur afin d'indiquer comment la lumière doit se comporter selon l'angle d'attaque (ex. : couleur assombrie ou éclaircie si ''Z'' est plus bas ou plus haut).

Le ''{{Langue|en|normal mapping}}'' utilise des textures de normales (des ''{{Langue|en|normal maps}}'') ayant trois couches (''X'', ''Y'', ''Z''). Chaque pixel de ces textures indique l'orientation du vecteur de la normale à émuler, c'est-à-dire, l'inclinaison du pixel/texel selon ''X'' et ''Y'', ainsi que son élévation ''Z''. Ce n'est pas une technique de rendu à proprement parler, mais une technique de préservation de l'information de la surface.

Les ''{{Langue|en|normal maps}}'' sont généralement utilisées avec un ''{{Langue|en|shader}}'' de ''{{Langue|en|parallax mapping}}'' qui permet de décaler l'affichage de chaque texel lors de la rastérisation afin d'émuler le volume.

Mixées, ces deux techniques permettent donc d'émuler et le volume de la surface, et son ombrage.

==== ''{{Langue|en|Displacement mapping}}'' ====
{{Article détaillé|Displacement mapping}}
Le ''{{Langue|en|displacement mapping}}'' (« placage d'effets de déplacement ») consiste, contrairement au ''{{Langue|en|bump mapping}}'', à modifier la géométrie des objets en fonction de la texture.

Pour cela, on attribue deux textures à chaque objet : sa texture classique et sa ''{{Langue|en|displacement map}}''. On utilise alors un ''{{Langue|en|vertex shader}}'' qui modifie la position de chaque vertex en fonction du texel qui devrait lui être appliqué. Par conséquent, plus il y a de vertex et plus la ''{{Langue|en|displacement map}}'' sera précise, l'idéal étant un vertex par pixel de celle-ci.

{{référence nécessaire|L'arrivée des ''[[geometry shader]]s'' va peut-être modifier cette technique, grâce à sa possibilité de multiplier les vertex en temps réel}}.

==== ''{{Langue|en|Cel-shading}}'' ====
[[Fichier:Toon Shader.jpg|vignette|Exemple de ''{{Langue|en|cel-shading}}'' : sans (à gauche) et avec (à droite).]]
{{Article détaillé|Cel-shading}}

Le ''[[cel-shading]]'' ou ''{{Langue|en|toon shading}}'' consiste à afficher un rendu de type [[bande dessinée]]. Les personnages de bande dessinée ont généralement peu de couleurs différentes. Pour créer un rendu similaire, il suffit donc de limiter le nombre de couleurs à l'écran.

La technique consiste à utiliser un ''{{Langue|en|pixel shader}}'' qui va arrondir la couleur. Par exemple, entre #000 et #444, la couleur sera arrondie à #222, entre #444 et #999, arrondie à #777, et sinon, arrondie à #CCC. De cette façon, il n'y aura que trois couleurs différentes qui ressortiront.

== Autres astuces et effets ==
=== ''{{Langue|en|Skybox}}'' ===
{{Article détaillé|Skybox (jeu vidéo)}}
Le rendu du [[ciel]] se fait généralement à l'aide d'une ''{{Langue|en|skybox}}''. Il s'agit d'un objet, souvent d'un cube, d'une demi-sphère ou d'un plan, recouvert d'une texture et englobant toute la scène. Il est toujours placé à distance fixe de la caméra, ce qui assure qu'il aura toujours la même dimension à l'écran.

L'ajout de nuage se fait généralement soit par rotation de cet objet (les nuages sont alors dans la texture), soit par des ''billboards'' (voir ci-dessous).

=== ''{{Langue|en|Billboards}}'' ===
{{Article détaillé|Sprite (jeu vidéo)}}
Dans le but d'optimiser le rendu, on peut utiliser des ''{{Langue|en|billboards}}'', c'est-à-dire un objet en 2D qui fera toujours face à la caméra. Cette technique permet souvent de dessiner les arbres (très nombreux), les particules et projectiles, certains effets comme le feu, et parfois même les personnages. De manière générale, ils servent à dessiner les objets très nombreux à l'écran.

Lorsque la caméra est loin d'un ''{{Langue|en|billboard}}'', cette technique ne se voit pas, mais de près, elle est très visible.

De nos jours, les jeux vidéo professionnels utilisent de moins en moins cette technique, car la vitesse de rendu gagnée n'est plus assez importante pour justifier la dégradation de l'image finale.

=== Ombre portée ===
{{...}}

La création d'une [[ombre portée]] repose sur l'utilisation d'un ''[[stencil buffer]]''. On détermine tout d'abord les endroits sur l'image 2D où se situent les ombres portées en remplissant le ''{{Langue|en|stencil buffer}}'' à cet endroit ; on effectue alors un premier rendu normal avec une lumière atténuée, puis un deuxième avec la lumière normale mais avec le filtrage par ''{{Langue|en|stencil buffer}}'' activé. Le second rendu dessine par-dessus le premier, sauf aux endroits filtrés par le ''{{Langue|en|stencil buffer}}'', c'est-à-dire sur les parties ombrées de l'image.

=== Réflexion ===
L'ajout de reflets est une technique avancée qui nécessite également l'utilisation d'un ''[[stencil buffer]]''.

On dessine tout d'abord l'ensemble de la scène. Ensuite, pour chaque zone réflective (miroir, métal{{etc.}}) :
* on dessine la zone réflective en ordonnant au processeur graphique de remplir le ''{{Langue|en|stencil buffer}}'' à l'endroit où sont placés les pixels ;
* on applique ensuite une transformation à l'ensemble de la scène pour qu'elle se retrouve de l'autre côté du plan du miroir ;
* on redessine ensuite l'ensemble de la scène (ou au moins les parties que l'on veut voir réfléchies) avec le filtrage activé, la scène est alors redessinée de l'autre côté du miroir mais le résultat n'est affiché que dans la zone du miroir lui-même.

Pour ajouter des effets comme un reflet déformé, il suffit d'adapter la scène entre le premier et le deuxième rendu.

Il est à noter que pour émuler les reflets, on utilise souvent des ''{{Langue|en|environment maps}}'' (''{{Langue|en|env map}}'') qui utilisent des ''{{Langue|en|env box}}'' (textures du type ''{{Langue|en|skyboxes}}'') réalisées à partir d'un point précis de la scène à rastériser. Le reflet de ces ''{{Langue|en|env box}}'' viennent se mixer à la texture des surfaces selon les valeurs colorimétriques des trois couches d'une texture dédiée que l'on appelle ''{{Langue|en|env map}}'' (afin de « coloriser » et pondérer le reflet des ''{{Langue|en|envbox}}'' selon la nature des surfaces).

== Notes et références ==
{{Références}}

== Voir aussi ==
=== Articles connexes ===
{{Colonnes|taille=25|1=
* [[Image vectorielle]]
* [[Image matricielle]]
* [[Ray tracing]]
* [[Raster Image Processor]]
* [[Environmental Systems Research Institute|Esri]]
* [[ArcGIS]] - [[QGIS]] - [[gvSIG]]
* [[Format de données]]
}}

=== Liens externes ===
* [http://professionnels.ign.fr/franceraster FranceRaster]

{{Portail|imagerie numérique}}

{{DEFAULTSORT:Rasterisation}}
[[Catégorie:3D]]
[[Catégorie:Imagerie numérique]]