Discussion :

[M4RIN49]

Bonjour à toutes et à tous

Je poste dans cette section "jeux" car cela me parait le plus adapté au vu de mon problème, qui concerne la 3D.

Je développe un logiciel en python et je souhaite afficher des points 3D (plusieurs dizaines milliers). Pour simplifier et comprendre le fonctionnement je pars de 9 points seulement dont les coordonnées forment un cube en 3D (plus un 9eme point point pile poil au centre du cube). Cela m'aide à visualiser.

J'ai lu pas mal à droite et à gauche (y compris sur ce forum) et j'ai découvert les fameuses matrices qui permettent d'effectuer les transformations requises. Cependant, je ne parviens pas à obtenir le résultat souhaité.
Je vais décrire pas à pas mon problème, pour que vous puissiez me dire les erreurs de raisonnement car je ne suis pas sûre de ce que je fais ...
J'utilise numpy pour les calculs matriciels. La seule chose que j'utilise de la librairie graphique sous jacente à mon programme est l'affichage de points sur l'écran. Je ne peux pas vraiment poster de code car la partie affichage de mon programme est isolée de tous ces calculs, et cela ne pourra pas fonctionner chez vous.



1. Si je veux afficher mon cube je dois le projeter sur l'écran 2D. Si j'affiche bêtement x,y cela me donne un carré (logique, projection sur un plan perpendiculaire à mon axe z).
Les coordonnées de mes points sont définies dans mon repère de référence, qui est censé être fixe.

2. Si je veux faire une rotation de mon cube, cela revient à modifier les coordonnées x,y,z de chaque point du cube dans le repère de référence via les matrices de rotation (celles que l'on trouve partout sur le net).
Ensuite, j affiche bêtement x,y et cela me donne un bon résultat, on voit que le cube a pivoté. Je vois donc mon cube pivoté projeté dans un plan perpendiculaire à mon axe z.
Si je ne fais pas erreur, pour une rotation quelconque je fais la multiplication des 3 matrices (des 3 rotations selon x,y,z) et cela semble encore bien fonctionner.

3. Ensuite, je veux placer ma caméra virtuelle à distance du cube sur l'axe z. Je crée un nouveau cube avec des coordonnées z toutes positives pour simplifier (l'ancien cube était centré sur l'origine). Sur des forums j'ai lu que les gens définissent une nouvelle matrice qui leur sert de caméra. Voici ce que je définis alors:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
        matrice_camera = np.array(((1,0,0,0),  # correspondance des vecteurs unitaires "espace camera" - "espace monde", modifier ces valeurs cause agrandissement/reduction selon l axe j'ai testé
                                              (0,1,0,0),  
                                              (0,0,1,0),
                                              (0,0,0,1))) # position camera dans le repère monde (ici je mets a l'origine)

Pour obtenir la position d'un point dans ce nouveau repère, je multiplie le vecteur point dans le repère de référence avec cette matrice camera.

Ensuite, je veux pouvoir faire pivoter ma camera partout autours du cube. Je dois donc modifier la dernière ligne de ma matrice pour placer la caméra en un point quelconque. Puis je dois appliquer les matrices de rotation a ma matrice de camera. Donc si je ne me trompe pas, c'est une translation plus des rotations. J'ai ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
        m1, m2, m3 = matRx(self.a1), matRy(self.a2), matRz(self.a3)     # les fonctions matRx etc retournent les matrices de rotation, a1 etc sont 3 angles de rotation de ma classe
        mcampivotee = matrice_camera.dot(m1).dot(m2).dot(m3)        # application successive des 3 rotations
 
	for x,y,z in liste_points:
            v = point(x,y,z)
	    x2,y2,z2,_ = v.dot(mcampivotee)

Qu 1 : Est ce que je me trompe si je dis que les points x2,y2,z2 sont bien les points de mon cube dans le repère de la caméra ?

4. Si je modifie ma matrice caméra de sorte que la dernière ligne de la matrice soit la position du centre du cube (chez moi c'est 0,0,400) alors je constate un premier problème qui est que les valeurs z de mes points sont encore plus éloignées de la caméra qu'elles ne l'étaient avant !!!

Qu 2 : Est ce que je dois faire mes coordonnées en négatif pour effectuer la translation correctement ? Avec des coordonnées en négatif cela semble mieux (0,0,-400). Par contre je dois tjrs filtrer selon la valeur de z avant d'afficher pour éviter que des points derrière la caméra ne se trouvent projetés.

5. Si vous m'avez supportée jusque là :-) il me reste à faire de la perspective et à projeter correctement (pas simplement afficher x et y). Là, j'ai trouvé sur le net plein de variantes de cette matrice de perspective. Que me faut il faire ?

Qu 3 : Après application d'une matrice de projection je suis bien censée obtenir systematiquement un z à 0 ? Sinon je ne comprends plus.

J'en ai essayé plusieurs, la dernière étant (mon code ici n'est pas glam ...) Ne vous embêtez pas avec ce bout de code je pense que le problème est dans mon raisonnement, pas dans la matrice :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def matProjPersp(fov, near, far, asp):
 
    #asp=ratio : ratio de la fenetre (la largeur de la fenetre divisee par sa hauteur)
    #angle : angle de vue de la camera (70° pour un oeil humain)
    #near  : distance la plus proche de la camera qu'il faut afficher
    #far   : distance la plus eloignee de la camera qu'il faut afficher
 
    n = near
    f = far
 
    t = n * radians(fov/2)
    b = -t
    r = t * asp
    l = -r
 
    m11 = (2*n)/(r-l)
    m13 = (r+l)/(r-l)
    m22 = (2*n)/(t-b)
    m23 = (t+b)/(t-b)
    m33 = -((f+n)/(f-n))
    m34 = -((2*f*n)/(f-n))
    m43 = -1
 
    return np.array(((m11,0,m13,0),
                     (0,m22,m23,0),
                     (0,0,m33,m34),
                     (0,0,m43,0)))

Avec ça je n'y arrive pas ... J'obtiens n'importe quoi.
Pour moi la valeur de far doit être placée plus ou moins loin (axe z) derrière les derniers points à afficher. La valeur near à l'inverse, devant le plus proche des points à afficher.
Pour la valeur de ratio j'ai mis 1 (pour le moment), et un angle j'ai joué avec, genre 90 voire 180 degrés.

J'ai testé une autre matrice plus naïve (elle ne gère pas les paramètres near, far, angle, ratio) que j'ai trouvé sur Internet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    # matrice projection perspective (elle est appelée ainsi ...)
    return np.array(((1,0,0,0),
                     (0,1,0,0),
                     (0,0,0,1/f),  #cette valeur f est une sorte de distance focale
                     (0,0,0,1)))

Le résultat après application est assez nul, c'est la même chose qu'avant, je n'arrive pas à obtenir des arêtes de cube de taille différente entre l'avant (proche) et l'arrière (loin). Pire ... quand j'appuie sur mes touches pour modifier doucement les angles de rotation de ma caméra j'ai des points qui reculent vers l'arrière qui disparaissent ... il doit y avoir des inversions de signe ...

Est ce que le raisonnement est correct :
1. définition matrice de caméra
2. translation PUIS rotation de cette matrice de caméra
3. projection perspective (avec quelle matrice ?)
4. affichage des coordonnées x,y (z=0) retournées suite au calcul - et comment filtrer les valeurs négatives ?


Je galère depuis quelques jours, je suis capable de créer et multiplier des matrices mais je ne comprends pas toutes les maths derrière ...

Merci d'avance !


EDIT: Il y avait un souci dans l'affichage de l'axe Y (en raison du système de coordonnées de l'écran). Cependant j'ai tjrs mes problèmes de perspectives.

J'ai fais quelques essais ce soir, en ajoutant un second cube et voilà ce que ça me donne ... les deux cubes (seuls les points sont affichés) font la même taille, et l'un d'entre eux est en avant par rapport à la caméra. Il y a un problème.

[mathieu]

je ne suis pas à l'aise du tout avec les matrices de rotation donc je vais surtout faire une remarque sur la projection.

si on part d'un 1er cube qui est à 1 mètre du plan z et un 2e cube à 15 mètres, alors si on fait une simple projection sur le plan z, les 2 cubes auront la même image.
je pense qu'il faut plutot partir d'un observateur qui est à un point donné et qui regarde autour de lui. le cube qui est plus loin fera alors un angle plus petit avec ce point.

peut-être que la matrice de la fonction matProjPersp fait un calcul de ce genre mais puisque vous avez un résultat qui ne vous plait pas, je vous conseille de simplifier encore plus en prenant juste 2 points qui forment une droite. ensuite vous calculez à la main l'image en 2D de ces points et vous essayez de faire une fonction qui reproduit ce calcul. et à partir de là vous testez votre fonction sur un plus grand nombre de points.

[M4RIN49]

Merci pour votre réponse.

si on part d'un 1er cube qui est à 1 mètre du plan z et un 2e cube à 15 mètres, alors si on fait une simple projection sur le plan z, les 2 cubes auront la même image.

Je suis d'accord avec vous qu'une simple projection donne un résultat que je ne souhaite pas, avec des cubes de la même taille. Le souci que j'ai c'est que les matrices qui servent normalement à gérer ça ne fonctionnent pas dans mon code. Je dois mal m'y prendre.
J'ai contourné le souci hier soir artificiellement, en divisant les coordonnées x,y par un facteur corrélé à z et ça donne un bon effet de perspective. Ainsi, plus la caméra est éloignée de l'objet et le plus les distances x,y sont proches.

je pense qu'il faut plutôt partir d'un observateur qui est à un point donné et qui regarde autour de lui. le cube qui est plus loin fera alors un angle plus petit avec ce point.

Oui. C'est ce sur quoi je travaille désormais. J'ai tout repris et via des tutos je parviens à implémenter une caméra virtuelle qui pointe sur un point donné de l'espace.
+ j'arrive à déplacer ce point d'origine par simple translation, comme si la caméra effectuait un mouvement de translation sans que sa direction de vue ne change au cours du temps.
+ j'ai des soucis pour les rotation hélas ... je voudrais pouvoir modifier ce point ciblé par la caméra en appuyant sur mon clavier et là je m'en sors pas encore. Je ne sais pas dans quel ordre et à quel vecteur appliquer les rotations.

Mon code pas propre pour le moment donne ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
        # deplacement de la caméra dans l espace a chaque iteration d affichage
        self.vx -= 1
 
        # positionner la camera dans l espace (ses coordonnees x,y,z)
        m1,m2,m3 = matRx(self.a1),matRy(self.a2),matRz(self.a3) # les rotations
        X,Y,Z = self.vx,self.vy,self.vz # les coordonnees de la camera/l observateur
        matriceCamera = matT(X,Y,Z) # translation 
        positionCamera = vecteur(matriceCamera[3][0],matriceCamera[3][1],matriceCamera[3][2]) #je recupere les coordonnees de position de la camera
 
        positionCiblee = vecteur(0,0,0) # si 0,0,0 alors la camera VISE l origine depuis SA POSITION ACTUELLE
 
        # si l on veut que la position ciblee suive la meme translation que la direction du mouvement...
        positionCiblee = positionCiblee.dot(matT(X,Y,Z)).dot(m1).dot(m2).dot(m3) # !!! ici les rotations ça marche mal !!!
 
        vertical = (0,1,0,1)
 
        matrice_camera = matRegVers(positionCamera,positionCiblee,vertical)
 
        matrice_vue = matVue(matrice_camera) #inverse la matrice camera
 
        for d_point in ld_points:
 
            x,y,z = d_point["position"]
            s_couleur = d_point["couleur"]
            i_rayon = d_point["rayon"]
 
            v = point(x,y,z)
            x2,y2,z2,_ = v.dot(matrice_vue)
 
            #affichage

Les soucis qui me restent :
+ j'ai l'impression que j'ai des inversions x <-> -x et y <-> -y qui trainent ...
+ les rotations de vecteur de vue

Je continue de creuser, je vais nettoyer tout ça aussi.

Je suis nouvelle dans ce type de calculs et j'avoue que je m'attendais pas à me prendre autant la tête.

[Mat.M]

J'ai lu pas mal à droite et à gauche (y compris sur ce forum) et j'ai découvert les fameuses matrices qui permettent d'effectuer les transformations requises. Cependant, je ne parviens pas à obtenir le résultat souhaité.

j'arrive pas trop bien à comprendre ce que vous voulez faire ; avec Openg GL il y a certainement des fonctions qui font les transformations requises.
Sinon il y a la biblio DxMath de Microsoft totalement disponible sur GitHub, merci qui ? Merci Bill et vous devriez trouver du code utile.
Après des transformations de points en 3d à l'écran ça ne reste que des transformations de points c'est pas visible à l'oeil nu

[M4RIN49]

Merci pour votre réponse

En fait, je cherche, "from scratch", à afficher pléthore de points (étoiles). Je souhaite pouvoir placer la caméra à un endroit de cet ensemble et à pouvoir l'orienter comme je le souhaite, pour voir la situation à partir de ce point.
Pour mes essais, j'ai réduit à un ensemble limité de points car c'est bcp plus visible (je suis partie de cubes, et j'ai fini par ajouter les axes x,y,z pour me repérer).
J'ai codé un petit logiciel d'astronomie qui affiche la position des étoiles des catalogues d'étoiles "classiques" (BSC, UGC, ...) en fonction de la position sur Terre de l'observateur, mais là, la vue était figée. Ce n'est pas du tout le même problème qu'ici.

avec Openg GL il y a certainement des fonctions qui font les transformations requises.

J'ai lu un très bon tuto là dessus. Après c'est à la mise en pratique que je me plante.

Actuellement, ce que j'ai :

+ je récupère la listes des points à afficher
+ j'ai les coordonnées x,y,z de la caméra dans l'espace
+ j'ai les coordonnées de la position visée (en fait un vecteur) par la caméra
+ je remplis la matrice caméra avec ces infos là via cette fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
def remplirMatCam(vCam, vCible, vertical):
    axeZ = normVect(soustrVect(vCam,vCible))
    axeX = prodVect(vVert,axeZ)
    axeY = prodVect(axeZ,axeX)
    return np.array(((axeX[0], axeX[1], axeX[2], 0),
                     (axeY[0], axeY[1], axeY[2], 0),
                     (axeZ[0], axeZ[1], axeZ[2], 0),
                     (vCam[0],vCam[1],vCam[2],1)))

+ en théorie, je dois utiliser l inverse de cette matrice dans la suite des calculs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
matrice_vue = invMatrice(matrice_camera)

+ pour chaque point:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
v = point(x,y,z)
x,y,z,_ = v.dot(matrice_vue) #pour passer les points du monde réel dans le repère caméra
 
#j'applique la perspective (qui marche enfin) via division des coordonnées x,y par un facteur lié à z
 
# j'affiche le point

Ce séquencement semble bien fonctionner (j'ai fait des essais et la caméra pointe bien vers le point ciblé, même si je la met en mouvement de translation), cependant, je ne sais pas comment appliquer les rotations. J'ai d'abord pensé à les appliquer au vecteur camera AVANT inversion mais ça ne fonctionne pas bien. Je suis presque à mon objectif, il faudrait juste que les rotations soient appliquées au vecteur de pointage de la caméra.

[N_I_C_S]

avec Openg GL il y a certainement des fonctions qui font les transformations requises.

Hélas non... Depuis opengl 3 plus rien.

@M4RIN49

Vous devez presque y être, les soucis doivent bien venir de la matrice camera :
déjà il vaut mieux normaliser axeX car ce produit vectoriel doit rarement donner un vecteur unité. Puis la matrice est dans la "mauvaise transposition" pour être compatible avec la matrice projection du 1er post, à moins que vous l'ayez changée. Sinon il faudrait plutôt faire :
axeX[0], axeY[0], axeZ[0], poscam[0],
axeX[1], axeY[1], axeZ[1], poscam[1],
axeX[2], axeY[2], axeZ[2], poscam[2],
0, 0, 0, 1

Sinon je ne comprend pas si vous voulez faire pointer la vue vers un vecteur direction donné, ou donner à la vue des angles de rotation, on dirait que vous voulez faire les 2 et c'est un peu l'un ou l'autre...

[M4RIN49]

Sinon je ne comprend pas si vous voulez faire pointer la vue vers un vecteur direction donné, ou donner à la vue des angles de rotation, on dirait que vous voulez faire les 2 et c'est un peu l'un ou l'autre...

Je cherche à ce que le "regard" donc le vecteur direction pointe une direction donnée et je souhaite pouvoir orienter ce vecteur comme je le souhaite, donc lui faire subir des rotations (par exemple tourner autour de cet axe).
Je pense que j'ai toutes les briques pour le faire mais je dois mal m'y prendre. Et vous avez raison, j'ai un bon moment fait cette confusion entre le pointage du regard et la rotation des objets visés.
Je sais faire tourner les objets, je sais pointer un point précis. Maintenant j'ai des difficultés à manipuler ce vecteur direction. Avec le clavier je voudrais pouvoir modifier les coordonnées du point visé, ainsi que faire subir des rotations à la caméra (mettons pour me retrouver la tête en bas par rapport à un objet).

[N_I_C_S]

Oui, les probèmes viennent forcément de cette "désynchronisation" entre vecteur-direction et angles : on part d'un vecteur-vue ciblant un point et 0 rotations, on tourne le vecteur-vue, on bouge le point-cible mais du coup la vue suit le mouvement du point APRES ROTATION et pas le mouvement du point original !
Tout ça est forcément une source inépuisable de glitch.

une manière plus "standard" de gérer tout ça :
on peut maintenir 3 angles pour définir une matrice de rotation de la caméra, et quand on veut la faire pointer vers une direction donnée on calcule les angles qu'il faut appliquer à l'axe-profondeur (en opengl en principe 0, 0, -1) pour avoir cette direction et on recalcule sa matrice, pour avoir angles et vue toujours à jour.

[M4RIN49]

Le problème est quasiment résolu, mais je me heurte à un dernier mur.

La perspective est OK, je sais faire subir des rotations aux objets, et plus important pour moi je sais faire subir des rotations à la caméra elle même. J'ai corrigé grâce aux informations que vous m'avez donné mon problème d'inversion d'axes. J'ai utilisé une façon peu orthodoxe de déterminer l'objet pointé (au centre de la vue) : je maintiens une liste des objets affichés associés à leurs coordonnées x,y sur l'écran pour trouver l'objet visé.
Tout ceci n'est peut être pas optimal ni parfait mais mon besoin est rempli.

Par contre, et je pense que cela a été une grande cause de problèmes ces derniers jours, je me trouve contrainte par l'ordre d'application des rotations. Comme il y a 3 axes de rotations et que je ne possède pas de matrice qui ferait toutes les rotations en une opération, seule la dernière est en réalité juste. Lorsque je manipule le clavier je me trouve avec une combinaison bancale des 3 rotations, mais la dernière appliquée est juste. C'est dû à l'ordre d'application des matrices. J'ai lu qu'il existe des outils mathématiques plus complexes pour gérer ça (les quaternions je crois).
Donc, en gros, aujourd'hui je fais subir une première rotation, OK. Puis des que je fais des rotations combinées c'est juste faux ...
Si j'arrive à résoudre ça je vois si je peux poster un très court code utilisant matplotlib pour afficher, et je clos le sujet.

[plegat]

Bonsoir,

Si ça peut aider, à une époque lointaine j'avais pondu ça: https://plegat.developpez.com/tutoriels/jogl/pge-camera/

C'était pour du Java avec Jogl pour l'affichage, mais je m'étais fait toute la gestion de la caméra perso. Avec des matrices, et des quaternions...

[M4RIN49]

Merci beaucoup, je vais regarder ça au calme !