Discussion :

[lalaurie40]

Bonjour,

je cherche à modéliser une sphère en 3D par triangulation mais j'ai quelques problèmes d'algo. Je travaille en langage C avec la librairie d'OpenGL.

Code :

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

1
2
3
4
5
6
7
8
struct StructSphere {
 
  int _nbTriangles; // nombre de triangles à modéliser
 
  GLfloat (*vertices)[3]; // tableau de sommets : l'indice du tableau est le numéro du sommet. Pour chaque sommet on stocke ses coordonnées x, y et z.  
  GLint (*triangles)[3]; // d'un tableau de triangles : l'indice du tableau est le numéro du triangle. Pour chaque triangle on stocke les indices de ses trois sommets 
  GLfloat (*normalsT)[3]; // d'un tableau de normales : dans la version simple on a autant de normales que de triangles. Ces normales sont les vecteurs normaux à chaque triangle. 
};

L'algo trace des disques superposés en modifiant juste le rayon mais je pense que ce n'est pas le meilleur

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/*--- Sphere ---*/
 
void initSphere (Sphere * sphere , int nvertices)
{
  int i;                 
  int j;                 
  int nbT;               
  nbT=0;                 
  int nbD;               
  int nbV;               
  float r;               
  r = RAYON;
  float rapport;
  float aux; 
  aux = (nvertices/2) +1;
  int i_sauv;            
  rapport = 1 / aux;
  float h;               
  h = 0;
 
  int disk;              
  disk = 0;
 
  int nv;
  nv = ( (nvertices+1) * nvertices) + 2;
 
 // initialisation _nbTriangles  wether nvertices is PAIR or IMPAIR
  if ( (nvertices %2) == 0) sphere->_nbTriangles = (2*nvertices + 2) * nvertices;
  else sphere->_nbTriangles = 2 * nvertices * nvertices;
 
// allocation dynamiqe
  sphere->vertices = malloc(nv * sizeof (*sphere->vertices));
  sphere->triangles = malloc(sphere->_nbTriangles * sizeof (*sphere->triangles));
  sphere->normalsT = malloc(sphere->_nbTriangles * sizeof (*sphere->normalsT));
 
// calcul de l'angle
  float teta = (2 * M_PI) /nvertices;
 
 
   // premier disque du milieu
   for (i=0; i<nvertices; i++) {
    sphere->vertices[i][0] = r * cos(i*teta);
    sphere->vertices[i][1] = r * sin(i*teta);
    sphere->vertices[i][2]  = 0;                      
 
}
 
  // les autres disques
   for( nbD=1; nbD<nvertices; nbD=nbD+2) {
      h = h + rapport; // calcul pour diminuer la hauteur de chaque disque
      r = r - (RAYON*rapport); // calcul pour diminuer le rayon de chaque disque
 
     for( i=0; i<nvertices; i++) {
       sphere->vertices[(nbD*nvertices)+i][0] = r * cos(i*teta);
       sphere->vertices[(nbD*+nvertices)+i][1] = r * sin(i*teta);
       sphere->vertices[(nbD*nvertices)+i][2]  = h;                         
 
       sphere->vertices[( (nbD+1)*nvertices) +i][0] = r * cos(i*teta);
       sphere->vertices[( (nbD+1)*nvertices) +i][1] = r * sin(i*teta);
       sphere->vertices[( (nbD+1)*nvertices) +i][2]  = -h; 
 
     }
   }
 
   // dernier triangle du haut
   sphere->vertices[nbD*nvertices][0] = 0;
   sphere->vertices[nbD*nvertices][1] = 0;
   sphere->vertices[nbD*nvertices][2]  = RAYON;   
 
   // dernier triangle du bas
   sphere->vertices[(nbD*nvertices)+1][0] = 0;
   sphere->vertices[(nbD*nvertices)+1][1] = 0;
   sphere->vertices[(nbD*nvertices)+1][2]  = -RAYON;     
 
 
   // triangulation
   for (nbD=0; nbD<nvertices; nbD++) {
 
     // premier disque
     if (nbD == 0) i_sauv = (nvertices-1) * nvertices;
     else { 
       if (disk) { i_sauv = 0;  disk = 0;  }
       else i_sauv = abs(i_sauv - 2*nvertices);
     }
 
 
     for(nbV=0; nbV<nvertices-1; nbV++) {
       i = i_sauv + nbV;
 
       // cas du disk au dessus du centre
       j = i - 2*nvertices;
 
       if ( j<0  && j>=-nvertices)  {
         j += nvertices; 
         disk = 1;
 
       }
       j = abs(j);
 
       sphere->triangles[nbT][0] = i;
       sphere->triangles[nbT][1] = j;
       sphere->triangles[nbT][2] = j + 1;
 
       sphere->triangles[nbT+1][0] = i;
       sphere->triangles[nbT+1][1] = j + 1;
       sphere->triangles[nbT+1][2] = i + 1;
 
       nbT += 2;
     }
 
 
      i = i + 1;
      j = i - 2*nvertices;
 
      if ( disk)  {
        j += nvertices; 
      }
 
      // les 2 derniers triangles d'un disque
      sphere->triangles[nbT][0] = i;
      sphere->triangles[nbT][1] = j;
      sphere->triangles[nbT][2] = j - nvertices + 1;
 
	  sphere->triangles[nbT+1][0] = i;
      sphere->triangles[nbT+1][1] = j - nvertices + 1;
      sphere->triangles[nbT+1][2] = i_sauv;
 
      nbT += 2;
     }
 
 
   // les triangles du haut
   for(nbV=0; nbV<nvertices; nbV++) {
     sphere->triangles[nbT][0] = nv-2;
     sphere->triangles[nbT][1] = ( (nvertices-1) * nvertices) + 1 + nbV;
     sphere->triangles[nbT][2] = ( (nvertices-1) * nvertices) + nbV;
      nbT++;
   }
 
  // les triangles du bas
   for(nbV=0; nbV<nvertices; nbV++) {
     sphere->triangles[nbT][0] = nv-1;
     sphere->triangles[nbT][1] = nvertices * nvertices + nbV;
     sphere->triangles[nbT][2] = nvertices * nvertices + 1 + nbV;
 
   nbT++;
   }
 
}

J'ai trouvé sinon l'équation paramétrique d'un sphère mais je ne sais pas comment l'utiliser
x = R cos u cos v
y = R cos u sin v
z = R sin u

peut etre que les paramètres passés à la fonction init ne sont pas bien choisis

[plegat]

Salut,

je cherche à modéliser une sphère en 3D par triangulation mais j'ai quelques problèmes d'algo.

et c'est quoi les problèmes au juste?

Je n'ai pas lu ton code, je suis allergique aux romans en C... (surtout dans le forum algorithmes)
Une méthode simple que tu peux utiliser est de découper ta sphère grâce à des parallèles (comme tes disques superposés) et des méridiens. Ca te définit des carrés (sauf aux pôles où tu as directement des triangles). Il ne reste plus qu'à diviser chaque carré en deux triangles. Eventuellement si tu veux que ce soit plus "joli", tu fais tourner chaque parallèle d'une demi largeur de carré autour de l'axe des pôles à la fin.

[lalaurie40]

c'est l'algo que je voulais implémenter mais j'avais pas de méridien. est ce qu'ils sont vraiment utiles ou est ce qu'on peut faire juste avec des parallèles.
et comment se déplacer dans la sphere pour tracer les triangles?

[plegat]

Avec les parallèles et méridiens, tu as les points de tes triangles direct.

Exemple, parallèles 0° et 10°, méridien 0° et 10°, tu auras les quatre points définis par les couples (u,v) suivants: A=(0,0), B=(0,10), C=(10,0) et D=(10,10).
Les formules que tu as données dans ton premier post te permettent d'avoir les coordonnées (x,y,z) correspondantes.
Ce qui te donnent ensuite les triangles ABD et ACD (ou ADC si tu veux garder la même orientation des normales)