Génération des sphères en c

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

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, 12h00

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, 12h01

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, 13h28

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, 13h58

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.

**mecaplus** · 26/03/2010, 12h05

Ok! Merci Jeroman, je vais regarder ça et te tiens au courant.

**mecaplus** · 27/03/2010, 21h11

J'ai généré mes sphères maintenant la grande question c'est comment les tracer? Avec quel logiciel?

**Elijha** · 28/03/2010, 19h04

Salut,

Envoyé par mecaplus

J'ai généré mes sphères maintenant la grande question c'est comment les tracer? Avec quel logiciel?

Tu pourrais essayer de sortir un fichier de données (binaire ou CSV) et d'utiliser gnuplot.

**Jackyzgood** · 28/03/2010, 21h18

Envoyé par mecaplus

J'ai généré mes sphères maintenant la grande question c'est comment les tracer? Avec quel logiciel?

Pourquoi pas en OpenGL ? En plus il y a certaine librairie qui contienne déjà les primitive de sphère, il ne te reste plus qu'a donner le rayon et le nombre de divisions.

**mecaplus** · 30/03/2010, 10h31

Merci pour vos propositions. J'ai finalement choisi d'utiliser la librairie VTK pour visualiser avec Paraview. Je ne sais pas encore comment fonctionne OpenGL mais apparemment il permet de faire des trucs sympa. Je regarderai le moment venu, pas évident de se lancer...

J'ai aussi essayé Matlab et Autocad, les deux marchent aussi mais la génération des sphères est très lourde. Pour Autocad, la manipulation est ensuite fluide.

Je ne pense pas que Gnuplot me donne un résultat meilleur pour ce genre de tracé.

**Jackyzgood** · 30/03/2010, 10h45

L'openGL. Tu verra ce n'est pas compliqué et oui ça peut donner des trucs sympa.

**mecaplus** · 30/03/2010, 12h13

Merci mais a priori il faut connaître le C++. Je suis encore au C et ça ne fait que 3 mois que j'essaie de coder en C donc c'est peut être un peu prématuré.

Mais mon objectif à long terme de savoir utiliser cette librairie pour développer des petites choses qui me font rêver...