Interpolation avec précalcul du déplacement

Nous avons tout d'abord implémenté directement le déplacement de points. Le principe est de faire évoluer les points de l'image 1 vers leur position selon le point de vue 2 et en même temps de faire évoluer les point des l'image 2 vers leur position selon le point de vue 1. Nous devons donc tout d'abord précalculer le déplacement de chaque pixel des images de références .

Réalisation

Soit $p(u,v,z)$ un pixel à la position $(u,v)$ et de profondeur $z$ de l'image de départ, $M_{d}$ la matrice de transformation de la caméra du point de vue, $M_{a}$ la matrice de transformation du point de vue d'arrivée, on obtient la position d'arrivée $p_{a}$ par $p_{a}=M_{a}.M_{d}^{-1}.p$ (reprojection). Le déplacement $\overrightarrow{v_{p}}$ du point $p(u,v)$ vaut donc $p_{a}-p$, et est stocké dans une texture de définition égale à la résolution que l'image.

Une fois ce précalcul effectué, le rendu s'effectue en déplaçant chaque pixel de l'image de départ selon un paramètre $t\in[0,1]$ représentant la position de la caméra virtuelle entre les deux point de vue. Etant donné que plusieurs pixels peuvent se retrouver au même endroit, nous devons utiliser un tampon de profondeur pour gérer le problème de visibilité des pixels. La figure 2.13 montre le résultat de l'interpolation pour chaque point de vue séparément.

Figure 2.13: Interpolation avec précalcul du déplacement. Ligne supérieure : évolution des points du premier point de vue. Ligne inférieure : évolution des points du second point de vue. Colonne de gauche (pt. vue de départ) : $t\approx 0$ , colonne du milieu : $t=0.5$ , colonne de droite (pt. vue d'arrivée) : $t\approx 1$.

Pour superposer les deux images, nous devons prendre en compte la profondeur des points déplacés. Etant donné un point $p(u_{d},v_{d},z_{d})$ (dans l'espace de la caméra) d'une image de départ, transformé selon le point de vue d'arrivée en $p_{a}(u_{a},v_{a},z_{a})$, nous créons le vecteur de déplacement $\overrightarrow{v_{p}}(\Delta u,\Delta v,\Delta z)=(u_{a}-u_{d},v_{a}-v_{d},z_{a}-z_{d})$. Pour un instant $t\in[0,1]$ de l'interpolation, le pixel est linéairement interpolé aux coordonnées $p_{t}=(u_{d}+t.\Delta u,v_{d}+t.\Delta v,z_{d}+t.\Delta z)$. Nous ne le dessinons que si sa profondeur interpolée $z_{t}$ est inférieure à la profondeur stockée dans le tampon de profondeur.

Figure 2.14: Interpolation avec précalcul du déplacement. En haut, sans filtrage bilinéaire. En bas, avec filtrage bilinéaire de l'image.

Résultats

La ligne supérieure de la figure 2.14 montre le résultat de cette superposition.

Avec cette méthode, les informations suivantes sont stockées par pixel (pour chaque point de vue de référence):

1. La couleur du pixel (R,V,B) ainsi que sa profondeur = 3+2 octets (la profondeur est exprimée sur 16 bits, ce qui c'est avéré suffisant dans notre cas).
2. Le vecteur de déplacement du point selon le point de vue opposé : $(\Delta u,\Delta v,\Delta z)$ = 3x2 octets.

De plus, tous les calculs sont effectués par le processeur central. Pour chaque image de l'animation nous devons :

1. Calculer la nouvelle position des points avec un tampon de profondeur pour chaque image de référence.
2. Comparer en chaque pixel de l'écran la profondeur interpolée de chaque point de vue de référence afin de déterminer le plus proche des deux.

Tout ce traitement s'avère coûteux, tant en temps de calcul qu'en espace mémoire. Pour une définition de 512x512 pixels, la mémoire nécessaire est de 2.75 Mo par point de vue. Néanmoins, les résultats visuels sont bons, même avec des points de vues très éloignés. Le taux d'affichage dépend entièrement de la puissance du processeur central ; mais, étant donné que les calculs à effectuer sont uniquement des interpolations linéaires, le résultat est assez satisfaisant : >15FPS avec un processeur AMD Athlon cadencé à 1.4Ghz.