Discussion :

[Grand sorcier]

Bonjour, j'ai lu la FAQ
et notamment la partir de conversion de coordonnées 3D vers 2D.
Mais en fait le boulot est fait par DirectX...

Les données de vos objets 3D subissent de nombreuses transformations avant d'arriver en 2D sur votre écran. Comprendre celles-ci n'est pas promordial étant donné que c'est un mécanisme entièrement géré par le hardware (partie "Transfom & Lighting", "Clipping" et "Viewport Transform" du pipeline), mais se faire une idée des traitements que subissent les données est toujours utile, notamment pour correctement paramétrer les matrices, viewports et autres au niveau de l'API 3D.

Au départ, les sommets que vous envoyez à votre API 3D sont dans ce que l'on appelle l'espace objet (-> object coordinates, ou world coordinates).

Vos sommets sont tout d'abord transformés par la matrice de modèle / vue (world * view chez DirectX, modelview chez OpenGL) : ils sont ainsi ramenés dans l'espace caméra (-> eye coordinates).

Ensuite, ces coordonnées sont transformées par la matrice de projection afin de leur faire subir l'effet de perspective (-> clip coordinates). Les coordonnées ainsi obtenues (X, Y, Z, W) sont toutes comprises entre -W et W.

Les coordonnées (X, Y, Z) obtenues précédemment sont divisées par la composante W afin d'être normalisées (-> normalized device coordinates). Elles se retrouvent donc entre -1 et 1.

Enfin, ces coordonnées normalisées sont décalées / ré-échelonnées afin de coller au viewport courant (-> window coordinates). Pour rappel, le viewport permet d'afficher la scène sur n'importe quel endroit de la fenêtre de rendu.

Or j'aimerai avoir des elements de théorie un peu plus mathematiques...
car je compte créer un modeleur 3D en Java.

Merci pour vos elements de théories mathematiques.

[Laurent Gomila]

Qu'est-ce qui ne te semble pas assez précis ? Niveau mathématique tout est décrit : multiplication de matrices, divisions, additions, ...

[Grand sorcier]

Qu'est-ce qui ne te semble pas assez précis ? Niveau mathématique tout est décrit : multiplication de matrices, divisions, additions, ...

Euh

Y'a pas plus simple ? Peut-on simplifier et vulgariser un peu ces concepts ?
Faut-il vraiment être une bête en maths pour faire un modeleur 3D ?

[Laurent Gomila]

Pas une bête non, mais il faut de solides bases en algèbre linéaire et en géometrie dans l'espace.

Le plus simple serait que tu nous dises exactement ce qui te paraît trouble, ainsi on pourra te l'expliquer.

[hegros]

Ou alors commencer à apprendre à manipuler des matrices en mathématique

Si tu regardes de plus prés tu verras que les notions élémentaires concernant les matrices ( addition,soustraction,multiplication...) sont plutot facile a apprenhender et a appliquer même pour un non matheux

Dans tout les cas je crois que tu peux poser tes questions sur les matrices ici ce que tu ne comprends pas.

Bon courage !

[Grand sorcier]

Ou alors commencer à apprendre à manipuler des matrices en mathématique

Si tu regardes de plus prés tu verras que les notions élémentaires concernant les matrices ( addition,soustraction,multiplication...) sont plutot facile a apprenhender et a appliquer même pour un non matheux

Dans tout les cas je crois que tu peux poser tes questions sur les matrices ici ce que tu ne comprends pas.

Bon courage !

Ben tiens puisqu'on y est... pourquoi apparaissent les matrices ?

Je pars d'un VERTEX(X,Y,Z) et je veux obtenir un POINT(x,y).
D'ou voyez vous la necessité d'utiliser une matrice ?

Initiez moi à votre science mathematiques...

[HanLee]

Ou alors commencer à apprendre à manipuler des matrices en mathématique

Si tu regardes de plus prés tu verras que les notions élémentaires concernant les matrices ( addition,soustraction,multiplication...) sont plutot facile a apprenhender et a appliquer même pour un non matheux

Dans tout les cas je crois que tu peux poser tes questions sur les matrices ici ce que tu ne comprends pas.

Bon courage !

Ben tiens puisqu'on y est... pourquoi apparaissent les matrices ?

Je pars d'un VERTEX(X,Y,Z) et je veux obtenir un POINT(x,y).
D'ou voyez vous la necessité d'utiliser une matrice ?

Initiez moi à votre science mathematiques...

Bah en fait, ton point est un point en 2D.
On utilise en fait que 2 coordonnées d'un vecteur 3D (x et y en pratique) pour les jeux 2D, parce qu'on considère qu'on est sur un plan.
La 3ème coordonnées est inutilisée, sauf cas particuliers.

Alors les matrices c'est quoi ? C'est juste un tableau avec un certain nombre de lignes et de colonnes, constitué d'éléments. En l'occurrence ici pour de la géométrie on utilise des nombres réels.

Ca sert à quoi ? Il faut savoir que les matrices en soi, tu peux leur donner l'utilité que tu leur souhaites.
Mais en géométrie par exemple, on les utilise pour représenter des fonctions de vecteurs par un calcul à l'aide des coordonnées du vecteur dans une base donnée, donc ici en particulier des transformations géométriques comme les rotations, homothéties (redimensionnements)...

Ainsi, si M est une matrice de rotation, A un vecteur, alors le vecteur B représentant le vecteur A qui aura tourné s'écrit B = M * A.

Remarque : il y a une manière particulière de faire du calcul matriciel. On calcule comme cela parce que ça donne les résultats voulus, et non par parce que c'est la seule manière d'utiliser un tableau qui contient des chiffre .
Je dis ça pour que tu ne te demandes pas dans le futur "mais pourquoi on doit forcément calculer comme ça ? Pourquoi pas comme ça, ce serait plus simple !"...

[Laurent Gomila]

Peut-être que la FAQ des matrices et quaternions répondrait à tes questions ?

http://jeux.developpez.com/faq/matquat/

[HanLee]

Peut-être que la FAQ des matrices et quaternions répondrait à tes questions ?

http://jeux.developpez.com/faq/matquat/

Ouais voilà, ça c'est pour les détails

[Grand sorcier]

Peut-être que la FAQ des matrices et quaternions répondrait à tes questions ?

http://jeux.developpez.com/faq/matquat/

Ouais voilà, ça c'est pour les détails

Merci pour ce lien les gars.... Je vai y jeter un coup d'oeil !

[Grand sorcier]

http://pagesperso.accesinternet.laposte.net/webmaster/topics/technic/java/java-workshop14/3/


Java : Une image qui tourne... Premiers pas vers la 3D
Jérôme Versavel

Si vous avez connu l'époque où informatique rimait avec Amiga et Atari, le résultat de cet atelier ne vous surprendra pas. Nous allons réaliser un rotozoom. Pour les non-initiés, ce mot barbare mérite une explication ou, mieux, un exemple.

Cet atelier est l'occasion de découvrir les premières notions de 3D appliquées à la programmation Java. En route pour les projections !

Au sommaire :

- Présentation de l'applet
- Définition et théorie
- Projection et rotation
- Le code
- Intégration dans la page



Présentation de l'applet

Notre applet met en scène une image qui tourne autour d'un axe perpendiculaire à son plan (et à celui de l'écran). Dans le même temps, cette image s'approche et s'éloigne de l'écran. L'applet associe donc deux mouvements : une rotation et un zoom, d'où son nom de rotozoom.

Le fonctionnement de cette applet nécessite deux classes, Rotozoom et MyImage, que nous avons découverte dans l'atelier précédent.

Avant d'étudier le code de l'applet en détail, un peu de théorie.


Définition et théorie

Nous allons parler ici de 3D. Pourquoi de 3D puisque nous traitons une image en deux dimensions ? C'est fort simple : le zoom (l'effet de rapprochement et d'éloignement) sur l'image s'apparente à un déplacement de l'image sur un axe perpendiculaire aux côtés de l'image. Il s'agit bien là d'une troisième dimension.

En généralisant notre théorie à l'utilisation 3D, on décompose la création d'images ou d'animations 3D en différentes étapes :


Modélisation des objets 3D à partir de primitives (formes géométriques simples comme les cubes, les sphères, les cylindres…) ou point par point.


Application de textures sur ces objets. Il s'agit de "plaquer" une image 2D sur une forme 3D pour la décorer ou lui donner une apparence moins lisse.


Placement et transformation de ces objets dans un univers 3D.

On touche ici au domaine de l'animation 3D. Il s'agit de définir des mouvements (translation, rotation, modification de taille) sur les objets 3D. Ces opérations sont effectuées à l'aide de matrices de transformation.


Eclairage. Il s'agit de définir une source de luminosité sur les objets afin de déterminer leurs faces les plus visibles.


Projection. Il s'agit ni plus ni moins que du calcul et du tracé de l'image à l'écran.

Cette dernière étape est celle qui nous intéresse tout particulièrement dans cet atelier. Allons-y !


Projection et rotation

La projection est la transformation d'un univers 3D sur un plan 2D correspondant au champ de vision de l'observateur. Les coordonnées de chaque point de notre image (X pour l'horizontale, Y pour la verticale) sont calculées à partir des coordonnées dans l'espace 3D de chaque point de chaque objet (coordonnées x, y et z).

Pour passer de l'une à l'autre, on utilise une projection. Il existe en fait deux types de projection : parallèle et perspective. La perspective est la plus proche de la réalité, mais aussi la plus complexe. Dans cet atelier, nous nous contenterons de la méthode parallèle. La formule mathématique qui permet le passage de la 3D à la 2D est la suivante :

X = x/z;
Y = y/z;

Voilà pour la théorie. Dans notre applet, ce ne sont pas des objets 3D à proprement parler que nous allons afficher, mais une image. Cette image peut en fait être assimilée à un plan infini sur lequel est placé un dessin, répété à l'infini lui aussi. Comme il est techniquement impossible de calculer la transformation d'un plan infini, nous allons inverser le problème.

Au lieu d'appliquer la projection à chaque point de notre plan/image initiale, nous allons calculer le point d'origine de chaque pixel à afficher dans l'applet. Pour cela, nous allons lui appliquer la rotation et la projection en sens inverse.

Pour en finir brièvement avec la théorie, quelques mots sur la rotation de l'image. Etant donné que cette rotation n'est effectuée que sur un seul axe, on peut calculer la transformation à l'aide d'une simple matrice de rotation 2D. Pour passer d'un point (x,y) à un point (x',y') avec une rotation d'angle A, on applique la formule suivante :

x' = x * cos(A) + y * sin(A);
y' = -x * sin(A) + y * cos(A);


Le code

L'étude théorique de notre applet ne vous a pas fait trop peur ? Très bien, alors il s'agit maintenant d'entrer dans son code, c'est-à-dire d'appliquer les opérations que nous venons de décrire.

La création de l'image affichée à l'écran est comme d'habitude effectuée dans une méthode répétée à intervalles réguliers, soit toutes les 40 millisecondes :

94: public void rotateAndZoom()
95: {
96: double angle = (3.1415926535897931D * (double)temps*rotation) / 180D;
97: double cos = Math.cos(-angle);
98: double sin = Math.sin(-angle);
99: double coeff = moyenne + ampl * Math.sin((double)temps/zoom);
100:
101: for(int i=0;i<width;i++) {
102: for(int j=0;j<height;j++) {
103: double xx = (double)(i - centerX) * cos + (double)(j - centerY) * sin;
104: double yy = (double)(-(i - centerX)) * sin + (double)(j - centerY) * cos;
105: int xxx=(int)(Math.round(xx) * coeff);
106: int yyy=(int)(Math.round(yy) * coeff);
107: dest.setPixel(i,j,source.getPixel(xxx,yyy));
108: }
109: }
110: temps++;
111: try {
112: myThread.sleep(40);
113: } catch (Exception e){}
114: }

Vous pouvez le constater, notre méthode rotateAndZoom() est assez courte en nombre de lignes de programme, mais son temps d'exécution est plutôt long. Ceci est dû au fait que tous les calculs sont effectués avec des variables de type double (nombres réels). Si cette méthode est lourde, elle est nécessaire car nous travaillons avec les fonctions sin et cos qui génèrent des valeurs comprises entre 0 et 1 avec de nombreuses décimales.

Au début de la méthode, nous calculons (en radians) l'angle de rotation de notre image en fonction du temps écoulé (variable temps) et de la vitesse de rotation passée en paramètre (ligne 96). Nous calculons ensuite le sinus et le cosinus du négatif de cet angle (lignes 97 et 98). Enfin, nous calculons le coefficient de zoom qui évolue lui aussi de façon sinusoïdale en fonction du temps et de la vitesse paramétrée (ligne 99).

Ensuite, pour chaque point de l'image à afficher, nous calculons les coordonnées du point d'origine dans notre pseudo univers 3D. Pour cela, nous appliquons la rotation inverse aux coordonnées de ce point (en tenant bien compte de sa distance au centre de l'image) et multiplions par la distance de l'observateur (lignes 101 à 106). Souvenez-vous, pour la projection directe, il fallait diviser par z.

Une fois les valeurs converties en int, nous allons chercher dans l'image initiale la valeur du pixel aux coordonnées calculées et la plaçons sur la nouvelle image (ligne 107).


Intégration dans la page

L'intégration de notre applet Rotozoom dans une page HTML est classique. Pour une intégration optimale, il suffit de fournir au programme cinq paramètres :

<applet code="Rotozoom.class" width="240" height="180">
<param name="image" value="mon_image.jpg">
<param name="rotation" value="10">
<param name="zoom" value="4">
<param name="haut" value="10">
<param name="bas" value="2">
</applet>

En fait, seul le paramètre image est obligatoire, les autres pouvant prendre des valeurs par défaut :


haut et bas, pour les distances minimale et maximale de l'image lors du zoom.

Si une de ces valeurs est négative, on passe de l'autre côté de l'image. Ces valeurs peuvent être des valeurs décimales (par exemple 0.5).


rotation, pour la vitesse et le sens de rotation.

Une valeur positive représente une rotation dans le sens inverse des aiguilles d'une montre.


zoom, pour la durée du zoom, c'est-à-dire l'inverse de sa vitesse.

Par défaut, cette valeur est 10.


La projection parallèle est en fait le premier pas vers la réalisation d'applet de création 3D. La prochaine étape sera la projection perspective. Viendront ensuite les matrices de transformation et peut-être la création d'objet 3D.

[Grand sorcier]

http://www.eg-models.de/formats/Format_Obj.html


Wavefront and Java3D .obj Format


The Wavefront .obj file format is a standard 3D object file format created for use with Wavefront's Advanced VisualizerÖ and available for purchase from Viewpoint DataLabs, as well as other 3D model companies. Object Files are text based files supporting both polygonal and free-form geometry (curves and surfaces). The Java 3D .obj file loader supports a subset of the file format, but it is enough to load almost all commonly available Object Files. Free-form geometry is not supported.

The following text is close to the description of the .obj file format in the Sun Java3D documentation.

The Object File tokens currently supported by the JavaView loader are listed below. Unknown tokens are skipped without affecting the reading process.

# some text
Line is a comment until the end of the line
v float float float
A single vertex's geometric position in space. The first vertex listed in the file has index 1, and subsequent vertices are numbered sequentially.
vn float float float
A normal. The first normal in the file is index 1, and subsequent normals are numbered sequentially.
vt float float
A texture coordinate. The first texture coordinate in the file is index 1, and subsequent textures are numbered sequentially.
f int int int ...
or
f int/int int/int int/int . . .
or
f int/int/int int/int/int int/int/int ...
A polygonal face. The numbers are indexes into the arrays of vertex positions, texture coordinates, and normals respectively. A number may be omitted if, for example, texture coordinates are not being defined in the model.
There is no maximum number of vertices that a single polygon may contain. The .obj file specification says that each face must be flat and convex. In JavaView polygonal face may be triangulated.
The example file sample.obj is given below (it is a cube):

v 1 1 1
v 1 1 -1
v 1 -1 1
v 1 -1 -1
v -1 1 1
v -1 1 -1
v -1 -1 1
v -1 -1 -1
f 1 3 4 2
f 5 7 8 6
f 1 5 6 2
f 3 7 8 4
f 1 5 7 3
f 2 6 8 4

[Grand sorcier]

J'ai trouvé des élements mathématiques à cette
adresse...

http://fr.wikipedia.org/wiki/Rotation


Bon sang c'est chaud les maths !
J'ai bien réivsé les notions de trigonométiques, cosinus, sinus, et tangeante.

Mais les matrices de rotations.... je sais pas comment ils l'ont obtenue. J'ai essayé de la retrouver par moi même... Et j'y arrive pas.

[loka]

allons un peu de courage, ce que tu appelles les matrices de rotation sont loin d'être parmi les notions mathematiques les plus difficiles et sont faciles à redemontrer

[Grand sorcier]

allons un peu de courage, ce que tu appelles les matrices de rotation sont loin d'être parmi les notions mathematiques les plus difficiles et sont faciles à redemontrer

Salut,

Pourrais-tu me donner une ebauche de démonstration...
pour comment retrouver les matrices de rotation 2D ?

Ensuite j'essairai de trouver par moi-meme une matrice
de rotation 3D...

Merci.

[Grand sorcier]

Je viens de consulter un bouquin de mathematiques et je pense avoir une proposition qui tient la route. Voila ce que je propose.... J'attends vos remarques et ensuite je passe ce thread à résolu... 8)


Proposition :

Nous partons d'un espace vectoriel avec un point
d'origine O(0,0). Soit 2 vecteurs orthogonaux ayant
pour origine O et une longueur 1, Vect(i) et Vect(j).

Dans cet espace vectoriel, soit un point A(x,y).
Le vecteur Vect(OA) peut s'écrire aussi de cette
manière Vect(OA) = x.Vect(i) + y.Vect(j).

Soit un autre couple de vecteurs hortogonaux Vect(i')
et Vect(j') ayant pour origine 0, pour longueur 1 et tels
que Vect(i') est la rotation de Vect(i) d'angle ù et
Vect(j') est la rotation de Vect(j) d'angle ù.

Nous avons donc Vect(i') = cos(ù).Vect(i) + sin(ù).Vect(j)
et Vect(j') = -sin(ù).Vect(i) + cos(ù).Vect(j).

Soit le point B défini comme la rotation du point A(x,y)
d'angle ù repéré dans le repère (O, Vect(i), Vect(j)).
Ce point B a pour coordonnées (x,y) dans le
repère (O, Vect(i'), Vect(j')).

Le vecteur Vect(OB) peut s'écrire de cette
manière Vect(OB) = x.Vect(i') + y.Vect(j').

Soit Vect(OB) = x.[cos(ù).Vect(i) + sin(ù).Vect(j)]
+ y.[-sin(ù).Vect(i) + cos(ù).Vect(j)].

Soit Vect(OB) = [x.cos(ù) - y.sin(ù)].Vect(i)
+ [x.sin(ù) + y.cos(ù)].Vect(j).

Donc dans le repère (O, Vect(i), Vect(j)), le point
B a pour coordonnées (x.cos(ù)-y.sin(ù) , x.sin(ù)+y.cos(ù)).

C.Q.F.D.