Génération des sphères en c

**mecaplus** · 24/03/2010, 10h20

Bonjour à vous,

Je souhaite générer un ensemble de sphères de rayon identique (on va dire r=1) dont je connais parfaitement les centres.

En faisant quelques recherches sur internet, je suis arrivé à trouver un code source donné sur ce site. C'est vraiment intéressant et correspond assez bien à ce que je compte faire (en généralisant au cas de plusieurs sphères).

Voici le code source :

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
33
34
 
void CreateUnitSphere(int dtheta,int dphi)
{
   int n;
   int theta,phi;
   XYZ p[4];
 
   for (theta=-90;theta<=90-dtheta;theta+=dtheta) {
      for (phi=0;phi<=360-dphi;phi+=dphi) {
         n = 0;
         p[n].x = cos(theta*DTOR) * cos(phi*DTOR);
         p[n].y = cos(theta*DTOR) * sin(phi*DTOR);
         p[n].z = sin(theta*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos(phi*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin(phi*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos((phi+dphi)*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin((phi+dphi)*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         if (theta > -90 && theta < 90) {
            p[n].x = cos(theta*DTOR) * cos((phi+dphi)*DTOR);
            p[n].y = cos(theta*DTOR) * sin((phi+dphi)*DTOR);
            p[n].z = sin(theta*DTOR);
            n++;
         }
 
         /* Do something with the n vertex facet p */
 
      }
   }
}

Dans ce code, je ne comprends pas ce que représente DTOR, s'agit-il d'une fonction incluse dans les librairies c, d'une simple conversion? Je pense avoir bien regarder sur son site mais aucune explication...

Quelqu'un peut-il m'expliquer ce qu'il a compris de ce code?

La sphère est tracée à partir du système d'équations :

x=cos(theta).cos(phi) (1)
y=cos(theta).sin(phi) (2)
z=sin(theta) (3)

où -90<=theta<=+90 et 0<=phi<=360

Utilisé le code tel qu'il est donné ci-dessus génère bien évidemment des erreurs à la compilation, voici donc le code que j'arrive à compiler sur mon pc sous windows avec MinGW:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
 
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct {
   double x,y,z;
} XYZ;
 
 
 
 
void CreateUnitSphere(int dtheta,int dphi)
{
   int n;
   int theta,phi;
   XYZ p[4]= {0,0,1,  0,0,-1,  -1,-1,0,  1,-1,0};
   double DTOR;
 
   for (theta=-90;theta<=90-dtheta;theta+=dtheta) {
      for (phi=0;phi<=360-dphi;phi+=dphi) {
         n = 0;
         p[n].x = cos(theta*DTOR) * cos(phi*DTOR);
         p[n].y = cos(theta*DTOR) * sin(phi*DTOR);
         p[n].z = sin(theta*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos(phi*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin(phi*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos((phi+dphi)*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin((phi+dphi)*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         if (theta > -90 && theta < 90) {
            p[n].x = cos(theta*DTOR) * cos((phi+dphi)*DTOR);
            p[n].y = cos(theta*DTOR) * sin((phi+dphi)*DTOR);
            p[n].z = sin(theta*DTOR);
            n++;
         }
 
      }
   }
}
 
 
main()
{
 
int dtheta,dphi;
dtheta=1;
dphi=1;
 
 CreateUnitSphere(dtheta,dphi);
 
 return 0;
 
}

Merci à vous pour votre contribution.

**mikhailo** · 24/03/2010, 11h00

Yop,

Je pense que DTOR veut dire "Degree TO Radian", il s'agit donc d'une conversion, car sûrement que les fonctions trigonométriques prennent en argument les radians. Tu peux implémenter la fonction toi-même, je pense que ce sera plus rapide que de la chercher quelque part (bien qu'à mon avis, elle doit exister déjà). Et j'ai trouvé ce post sur notre beau forum:

http://www.developpez.net/forums/d36...e/#post2229910

**jeroman** · 24/03/2010, 11h01

Salut,

Dans ce code, je ne comprends pas ce que représente DTOR, s'agit-il d'une fonction incluse dans les librairies c, d'une simple conversion? Je pense avoir bien regarder sur son site mais aucune explication...

Non, c'est juste une macro permettant de convertir les degrés en radians (car les fonction trigo en C fonctionnent en radian et non en degrés).
C'est une macro du style :

Code :

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

#define DTOR (M_PI/180.0)

Si M_PI n'est pas défini, il faut rajouter avant :

Code :

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

#define M_PI 3.141592653589793238462643

Pour l'explication du code, il s'agit simplement de quadriller une sphère en éléments vertex, comme le montrent les images sur le site.
Un vertex est composé de plusieurs points, qui sont reliés et sur lequel il y a éventuellement une texture. Chacun de ces points a donc des coordonnées différentes, tout comme les points d'un rectangle aurait 4 coordonnées différentes, à savoir : (x,y), (x+dx,y), (x+dx, y+dy), (x,y+dy). Sauf que là, il s'agit de quadriller une sphère, et donc on calcule, pour chaque polygone, les coordonnées de chacun de ses points en utilisant les équations qui permettent de convertir les coordonnées sphériques en coordonnées cartésiennes.

**mecaplus** · 24/03/2010, 12h28

Merci pour vos réponses.

La conversion des angles je sais la faire c'est juste que ça ne m'ai pas venu à l'esprit de penser que ça pouvait simplement signifier "Degree TO Radian".

Ok! Donc si je comprends bien, dtheta et dphi sont des incréments d'angles et p[n] les différents points du maillage qui sont calculés (les sommets des n facettes).

il faut donc énormément de points pour tracer une sphère représentative...
et reconvertir ces points en degré pour les ploter?

voici le code modifier en tenant compte de vos remarques/conseils

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
 
 
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define DTOR (M_PI/180.0)
 
 
typedef struct {
   double x,y,z;
} XYZ;
 
 
 
 
void CreateUnitSphere(int dtheta,int dphi)
{
   int n;
   int theta,phi;
   XYZ p[4];
 
 
   for (theta=-90;theta<=90-dtheta;theta+=dtheta) {
      for (phi=0;phi<=360-dphi;phi+=dphi) {
         n = 0;
         p[n].x = cos(theta*DTOR) * cos(phi*DTOR);
         p[n].y = cos(theta*DTOR) * sin(phi*DTOR);
         p[n].z = sin(theta*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos(phi*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin(phi*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         p[n].x = cos((theta+dtheta)*DTOR) * cos((phi+dphi)*DTOR);
         p[n].y = cos((theta+dtheta)*DTOR) * sin((phi+dphi)*DTOR);
         p[n].z = sin((theta+dtheta)*DTOR);
         n++;
         if (theta > -90 && theta < 90) {
            p[n].x = cos(theta*DTOR) * cos((phi+dphi)*DTOR);
            p[n].y = cos(theta*DTOR) * sin((phi+dphi)*DTOR);
            p[n].z = sin(theta*DTOR);
            n++;
         }
 
 printf("p1=%lf  p2=%lf p3=%lf p4=%lf\n",p[0].x*(180/M_PI),p[1].x*(180/M_PI),p[2].x*(180/M_PI),p[3].x*(180/M_PI));
         /* Do something with the n vertex facet p */
 
      }
 
   }
 
 
}
 
 
main()
{
 
int dtheta,dphi;
dtheta=10;
dphi=10;
 
 CreateUnitSphere(dtheta,dphi);
 
 return 0;
 
}

Pensez-vous que de cette manière je peux générer des milliers de sphères de même rayon avec des positions différentes, en modifiant les équations comme suit :

Code :

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

1
2
3
4
 
x[i]=x0[i]+r*cos(theta)*cos(phi)      (1)
y[i]=y0[i]+r*cos(theta).sin(phi)      (2)
z[i]=z0[i]+r*sin(theta)               (3)

avec i l'indice sphère x0,y0,z0 les coordonnées de son centre dans le repère cartésien.

c'est lourd... je vais essayer déjà avec une sphère pour voir si ce code me permet de tracer une sphère. Il faut environ 2500 facettes pour avoir quelque chose de correcte.

**jeroman** · 24/03/2010, 12h58

Code :

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

 printf("p1=%lf  p2=%lf p3=%lf p4=%lf\n",p[0].x*(180/M_PI),p[1].x*(180/M_PI),p[2].x*(180/M_PI),p[3].x*(180/M_PI));

Pourquoi est-ce que tu multiplies x par (180/M_PI) ?

p[indice].x, p[indice].y et p[indice].z correspondent aux coordonnées dans le système cartésien. Il n'y a plus de question d'angle ici, tout est déjà calculé à ce stade.

Pensez-vous que de cette manière je peux générer des milliers de sphères de même rayon avec des positions différentes, en modifiant les équations comme suit :
Code :

x[i]=x0[i]+r*cos(theta)*cos(phi) (1)
y[i]=y0[i]+r*cos(theta).sin(phi) (2)
z[i]=z0[i]+r*sin(theta) (3)

Oui, tu peux même modifier le prototype de la fonction, en faisant quelque chose dans ce style :

Code :

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

1
2
3
4
5
6
7
8
9
10
void CreateUnitSphere(int dtheta , int dphi , double rayon , XYZ centre)
{
(...)
(boucle)
    p[n].x = centre.x + rayon * cos(theta*DTOR) * cos(phi*DTOR);
    p[n].y = centre.y + rayon * cos(theta*DTOR) * sin(phi*DTOR);
    p[n].z = centre.z + rayon * sin(theta*DTOR);
    (...suite...)
(...)
}

... où rayon (au cas où tu voudrais éventuellement faire des sphères de rayons différents) et centre seront passés en paramètre par la fonction appelante.