COMMENT DESSINER UN OBJET EN 3D ?

Ce document présente une méthode pour afficher des objets en 3 dimensions. Il y a bien entendu différentes façons de faire. La méthode présentée ici n'est certainement pas la plus efficace, mais elle s'avère être assez simple à comprendre. On considère ici que les objets 3D sont simplement formés par des segments de droite, les faces seront transparentes. Il s'agit donc de représenter les objets en "fil de fer". Cette façon d'afficher des objets en 3D est illustrée par l'applet écrite en Java, pour laquelle le code source est disponible.

Un objet 3D est constitué de points P_i de coordonnées (x_i;y_i;z_i) dans un repère (A;x;y;z) que l'on appellera le repère "absolu". Les coordonnées de A sont (x_a;y_a;z_a).

Les points peuvent être reliés pour former des arêtes et décrire la forme de l'objet. On note L_ij la ligne qui relie le point P_i au point P_j.

Les points pourraient aussi être rassemblés en faces ayant une couleur ou une texture afin de donner un aspect plus réaliste.

Ici, on se limite à une représentation en "fil de fer". Un objet O = (P;L) est donc composé d'un ensemble de points P et d'un ensemble de lignes L.

Pour afficher un objet sur un écran d'ordinateur, on peut utiliser la technique suivante. On représente l'écran de l'ordinateur par un repère (B;u;v;w). Le point B de coordonnées (x_b;y_b;z_b) est le centre de l'écran; le vecteur u représente la direction horizontale de l'écran, de la gauche vers la droite; le vecteur v représente la direction verticale de l'écran, du haut vers le bas; et le vecteur w représente la direction du regard de l'observateur, de l'oeil vers l'objet.

L'observateur est situé en face de l'écran. On considère que ses yeux, représentés par le point C de coordonnées (x_c;y_c;z_c), sont juste en face du centre B de l'écran. Le point B est donc sur l'axe (C;w) à une distance d de l'écran.

L'observation d'un objet sur l'écran peut se schématiser par la figure suivante où sont tracés des faisceaux de lumière allant des points de l'objet jusqu'à l'oeil de l'observateur.

Voici la technique de représentation de l'objet. Les points P_i de l'objet sont projetés sur l'écran pour former les points P'_i. Pour cela, on détermine les segments [P_iC] qui partent des points P_i et qui arrivent au point C, l'oeil. Ensuite, il suffit de calculer les intersections P'_i de ces segments avec l'écran. Une fois les points projetés, il suffit de tracer les arêtes qui forment l'objet: à chaque ligne L_ij, il faut tracer la ligne L'_ij qui relie le point P'_i au point P'_j.

On a choisit ici de décomposer la projection des points de l'objet sur l'écran en deux étapes. La première phase consiste à changer de repère les points de l'objet. Du repère absolu (A;x;y;z), les points sont exprimés dans le repère (B;u;v;w) de l'écran. Cette étape est détaillée dans la section "Changement de repère". Ensuite, les calculs de projection sont effectués (très simples une fois le repère changé). Cette étape est détaillée dans la section "Projection sur l'écran".

Une fois que l'on est capable d'afficher un objet 3D, il peut être intéressant de le voir sous différents angles. Pour cela, la section "Mouvements dans la scène 3D" propose différents types de déplacement dans l'espace 3D comme tourner, avancer, monter...

On considère un point P_i de coordonnées (x_i,y_i,z_i) dans le repère (A;x;y;z) et on cherche à déterminer ses coordonnées (u_i;v_i;w_i) dans le repère (B;u;v;w).

Dans le repère (A;x;y;z), on constate que le vecteur AP_i a les coordonnées (x_i;y_i;z_i) et le vecteur AB les coordonnées (x_b;y_b;z_b). Dans le repère (B;u;v;w), le vecteur BP_i a les coordonnées (u_i,v_i,w_i). D'après l'égalité AP_i = AB + BP_i et les remarques précédentes, on en déduit:

x_i x + y_i y + z_i z  =  (x_b x + y_b y + z_b z) + (u_i u + v_i v + w_i w)
(x_i - x_b) x + (y_i - y_b) y + (z_i - z_b) z  =  u_i u + v_i v + w_i w

En considérant que les vecteurs u, v et w ont respectivement les coordonnées (x_u;y_u;z_u), (x_v;y_v;z_v) et (x_w;y_w;z_w), on en déduit le système d'équations suivant.

x_i - x_b = x_uu_i + x_vv_i + x_ww_i
y_i - y_b = y_uu_i + y_vv_i + y_ww_i
z_i - z_b = z_uu_i + z_vv_i + z_ww_i

Après résolution, on obtient:

u_i = [(x_i - x_b) da₁ + (y_i - y_b) da₂ + (z_i - z_b) da₃] / [x_uda₁ + y_uda₂ + z_uda₃]
v_i = [(x_i - x_b) db₁ + (y_i - y_b) db₂ + (z_i - z_b) db₃] / [x_vdb₁ + y_vdb₂ + z_vdb₃]
w_i = [(x_i - x_b) dc₁ + (y_i - y_b) dc₂ + (z_i - z_b) dc₃] / [x_wdc₁ + y_wdc₂ + z_wdc₃]

avec:

da1 = yvzw - zvyw da2 = zvxw - xvzw da3 = xvyw - yvxw

db1 = ywzu - zwyu db2 = zwxu - xwzu db3 = xwyu - ywxu

dc1 = yuzv - zuyv dc2 = zuxv - xuzv dc3 = xuyv - yuxv

Pour calculer les coordonnées (u_i,v_i,w_i) des points P_i d'un objet 3D dans le repère de l'écran, il suffit d'appliquer les formules précédentes.

On considère un point P_i de l'objet 3D dont on connaît les coordonnées (u_i,v_i,w_i) dans le repère de l'écran. On cherche maintenant à calculer les coordonnées (u'_i,v'_i,w'_i) de la projection P'_i de P_i sur l'écran. On peut de suite affirmer que w'_i = 0, puisque P'_i se trouve sur le plan de l'écran.

Maintenant on doit trouver l'intersection de la droite (P_iC) avec le plan de l'écran (B;u;v). D'après la figure, on peut dire:

||P1'_iB|| / ||P1_iP3_i|| = ||P2'_iB|| / ||P2_iP3_i|| = ||BC|| / ||P3_iC||

||x|| signifie la longueur du segment x. Notons r le rapport ||BC|| / ||P3_iC||. On déduit:

r = d / (w_i + d)

D'après la figure, on peut dire:

||P1'_iB|| = v'_i
||P2'_iB|| = u'_i
||P1_iP3_i|| = v_i
||P2_iP3_i|| = u_i

Ce qui signifie que u'_i = u_ir et v'_i = v_ir. En résumé, les coordonnées de P'_i sont (u_ir;v_ir;0).

Pour tracer l'objet 3D, il faut tracer une à une les arêtes de l'objet. Considérons une de ces lignes L_ij qui va du point P_i au point P_j. Trois cas peuvent se présenter.

Dans ce cas, il suffit de tracer un trait sur l'écran qui va de la projection P'_i de P_i à la projection P'_j de P_j.

Dans ce cas, aucune partie de la ligne n'est censée être visible par l'observateur, donc on ne trace pas la ligne.

Dans ce cas, un des points se trouve devant l'écran, supposons P_i, et l'autre se trouve derrière l'écran, supposons P_j. Pour tracer la partie de la ligne que l'observateur est censé voir, il faut déterminer l'intersection P''_j de la droite (P_iP_j) avec l'écran. Ensuite, il suffit de tracer la ligne (P'_iP''_j).

Pour calculer les coordonnées (u''_i;v''_i;w''_i) de P''_j, on utilise la même technique que pour la projection. On détermine le rapport r = w_i / (w_i - w_j) qui nous permet de calculer les coordonnées:

u''_j = u_i + (u_j - u_i) r
v''_j = v_j + (v_j - v_i) r
w''_j = 0

Maintenant que l'on est capable de projeter un objet 3D sur l'écran de l'ordinateur, il pourrait être intéressant de pouvoir bouger dans la scène en 3D afin de voir l'objet sous différents angles. Bien évidemment, quand on "bouge", c'est en fait l'écran qui change de position et/ou d'orientation par rapport à l'objet. Voici la liste des quelques mouvements proposés ici (classés du plus simple au plus compliqué).

• Translations de l'écran (droite / gauche, haut / bas, avant / arrière).

• Rotations de l'écran autour de son point central (droite / gauche, haut / bas, inclinaison droite / gauche).

• Rotations autour d'un point de la scène (droite / gauche, haut / bas).

Ces translations consistent à déplacer l'écran suivant l'une des trois directions u, v ou w d'une distance donnée k.

Pour déplacer l'écran vers la droite, il faut translater son centre B suivant u dans le sens positif.

B ← B + k u

⇔

xb ← xb + kxu yb ← yb + kyu zb ← zb + kzu

Pour déplacer l'écran vers la gauche, il faut translater son centre B suivant u dans le sens négatif.

B ← B - k u

Pour déplacer l'écran vers le haut, il faut translater son centre B suivant v dans le sens négatif.

B ← B - k v

Pour déplacer l'écran vers le bas, il faut translater son centre B suivant v dans le sens positif.

B ← B + k v

Pour déplacer l'écran vers l'avant, il faut translater son centre B suivant w dans le sens positif.

B ← B + k w

Pour déplacer l'écran vers l'arrière, il faut translater son centre B suivant w dans le sens négatif.

B ← B - k w

Ces rotations consistent à tourner l'écran autour d'un des trois axes (B;u), (B;v) ou (B;w) d'un angle donné k.

Pour tourner l'écran vers la droite, il faut effectuer une rotation positive autour de l'axe (B;v). Pour cela, il suffit de considérer le plan (B,u,w) et de modifier les coordonnées des vecteurs u et w pour qu'ils subissent la rotation.

D'après la figure, cette rotation se traduit:

u ← u cos(k) - w sin(k)		⇔		xu ← xu cos(k) - xw sin(k) yu ← yu cos(k) - yw sin(k) zu ← zu cos(k) - zw sin(k)
w ← w cos(k) + u sin(k)		⇔		xw ← xw cos(k) + xu sin(k) yw ← yw cos(k) + yu sin(k) zw ← zw cos(k) + zu sin(k)

Cependant, il faut que u et v restent toujours de longueur 1. A cause des arrondis lors des calculs, leur longueur va diminuer petit à petit, rotation après rotation. Pour éviter cela, il faut réajuster à 1 la longueur des vecteurs (i.e. normaliser les vecteurs). Très simplement, on calcule la longueur d du vecteur (par exemple v).

d = √(x_v² + y_v² + z_v²)

Ensuite, on normalise le vecteur.

v ← v / d

⇔

xv ← xv / d yv ← yv / d zv ← zv / d

Remarque: Grâce à la normalisation, la rotation peut se faire plus simplement à l'aide de la tangente.

D'après la figure, la rotation peut finalement se traduire:

u' ← u - w tan(k)		⇔		xu' ← xu - xw tan(k) yu' ← yu - yw tan(k) zu' ← zu - zw tan(k)
w' ← w + u tan(k)		⇔		xw' ← xw + xu tan(k) yw' ← yw + yu tan(k) zw' ← zw + zu tan(k)
u ← u' / ||u'||
w ← w' / ||w'||

Pour tourner l'écran vers la gauche, il faut effectuer une rotation négative autour de l'axe (B;v).

u' ← u + w tan(k)
w' ← w - u tan(k)
u ← u' / ||u'||
w ← w' / ||w'||

Pour tourner l'écran vers le haut, il faut effectuer une rotation positive autour de l'axe (B;u).

w' ← w - v tan(k)
v' ← v + w tan(k)
w ← w' / ||w'||
v ← v' / ||v'||

Pour tourner l'écran vers le bas, il faut effectuer une rotation négative autour de l'axe (B;u).

w' ← w + v tan(k)
v' ← v - w tan(k)
w ← w' / ||w'||
v ← v' / ||v'||

Pour incliner l'écran vers la droite, il faut effectuer une rotation positive autour de l'axe (B;w).

v' ← v - u tan(k)
u' ← u + v tan(k)
v ← v' / ||v'||
u ← u' / ||u'||

Pour incliner l'écran vers la gauche, il faut effectuer une rotation négative autour de l'axe (B;w).

v' ← v + u tan(k)
u' ← u - v tan(k)
v ← v' / ||v'||
u ← u' / ||u'||

Ces rotations consistent à tourner d'un angle k dans l'un des trois plans (B;u;w), (B;v;w) et (B;v;u) autour d'un point donné D. La rotation est telle que le point D n'a pas changé de place sur l'écran. Cela revient à faire le tour d'un objet en fixant toujours le même point (en l'occurrence D) du regard. Ainsi, si on choisit D comme étant le centre d'un objet 3D, on a l'illusion que c'est l'objet qui tourne sur lui-même et non pas l'observateur qui se déplace.

Pour tourner à droite autour du point D, il faut tout d'abord effectuer une rotation positive d'angle k du centre B autour de la projection D' du point D sur le plan (B;u;w).

Ensuite, il suffit d'effectuer une rotation de l'écran vers la gauche du même angle k (on utilisera la "rotation gauche" vue précédemment).

Tout d'abord, les coordonnées (u_d;v_d;w_d) du point D sont calculées dans le repère (B;u;v;w) (avec la formule présentée dans la section sur le changement de repère). Les coordonnées de la projection D' du point D sur le plan (B;u;w) sont donc (u_d;0;w_d). La distance d₁ = ||BD'|| est également calculée. Elle interviendra plus tard afin de garantir que la distance ||BD'|| reste inchangée une fois la rotation terminée.

La rotation centrale commence par une rotation du point B autour de D' dans le plan (B;u;w) en utilisant la technique de la tangente vue précédemment.

D'après la figure, le point B est translaté suivant un vecteur perpendiculaire à BD' dont les coordonnées dans le plan (B;u;w) sont (w_d;-u_d). Pour respecter l'angle de rotation k, B est translaté de la manière suivante.

B ← B + u w_d tan(k) - v u_d tan(k)

Ensuite, le segment [BD'] est ramené à son ancienne longueur (i.e. d₁). Pour cela, on calcule d₂, la nouvelle distance de [BD'], et on détermine le rapport r = (d₂ - d₁) / d₂. Il suffit ensuite de translater B du vecteur r BD'. Pour simplifier les calculs, les nouvelles coordonnées de D' dans le repère (B;u;v;w) peuvent être calculées. La translation s'exprime donc:

B ← B + r BD'  ⇔  B ← B + u r u_d + w r w_d

Enfin, il faut tourner l'écran pour le remettre dans l'axe. Pour cela, il suffit d'appliquer l'opération "rotation gauche" vue précédemment avec l'angle k.

Pour tourner à gauche autour du point D, il faut tout d'abord effectuer une rotation négative d'angle k du centre B autour de la projection D' du point D sur le plan (B;u;w). Ensuite, il suffit d'effectuer une rotation de l'écran vers la droite du même d'angle k (on utilisera la "rotation droite" vue précédemment).

Pour tourner vers le haut autour du point D, il faut tout d'abord effectuer une rotation négative d'angle k du centre B autour de la projection D' du point D sur le plan (B;v;w). Ensuite, il suffit d'effectuer une rotation de l'écran vers le bas du même angle k (on utilisera la "rotation bas" vue précédemment).

Pour tourner vers le bas autour du point D, il faut tout d'abord effectuer une rotation positive d'angle k du centre B autour de la projection D' du point D sur le plan (B;v;w). Ensuite, il suffit d'effectuer une rotation de l'écran vers le haut du même angle k (on utilisera la "rotation haut" vue précédemment).