Discussion :

[onimusha]

Bonjour à tous,

Au fait, je travaille actuellement sur un petit projet C++/OpenGL et je suis comme bloqué sur un petit problème.

En effet, j'ai deux points 3D p1(x1, y1, z1) et p2(x2, y2, z2). Ces deux points vont constituer un segment de droite [p1 p2].

Ma question c'est, comment peut-on dessiner un Cylindre (glutSolidCylinder) qui aura le segment [p1 p2] comme axe principal? Ça veut dire que p1 et p2 vont être les centres des deux bases circulaires du cylindre.

Merci d'avance pour votre aide.

[LittleWhite]

Bonjour,

Un cylindre est composé des 2 différentes formes.

- La base ( et le plafond ) sont des triangles qui partage tous un point ( qui est le centre d'un cercle ). Plus précisément, on va crée un disque avec des triangles
- Les coté du cylindre c'est juste des rectangles.

Maintenant, en rapprochant à votre problème, nous connaissons presque tout ( il manque le rayon ). Les centres du plafond et de la base sont vos points p1 et p2. Les rectangles pour faire les hauteurs, c'est juste des raccord entre les points de vos triangles.

Sinon, il existe une fonction pour dessiner des cylindre: http://www.opengl.org/sdk/docs/man/x...luCylinder.xml

[onimusha]

Merci pour ton aide LittleWhite, mais je crois que tu n'as pas saisi ma vraie question, je crois que je n'étais pas très clair dans ma problématique.

Au fait, ma question est de trouver les transformations (Rotations, Translations et Scaling) que je dois appliquer sur mon cylindre unitaire (bien évidemment) aue je dessinerai sur l'axe des X par exemple, pour que une fois transformé, il va coincidé avec le segment [P1 P2].

Bon, mais heureusement me penchant avec plus de concentration sur ce sujet j'ai réussi à le régler j'ai même réussi à plaquer des objet .obj 3D modélisé avec 3DS Max correctement.

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
 
// Les deux points extrémités du Segment
float pt1[3] = { x1, y1, z1};
float pt2[3] = {x2, y2, z2};
 
// La longueur du segment
float lgth=sqrt(pow(pt1[0]-pt2[0],2)+pow(pt1[1]-pt2[1],2)+pow(pt1[2]-pt2[2],2));
 
// appel focntion getRotAngle qui calcul l'angle de rotation 3D entre le segment [P1 P2] et le segment [OZ]={0, 0, 1}
// NB: le cylindre unitaire de départ sera dessiné sur [OZ]
float * tts=  getRotAngle(pt1, pt2);
 
//--- le dessin du cylindre
             glPushMatrix();
                // placer l'origine du cylindre à la position P1 ou  au centre (P1+P2)/2 selon votre origine 
                glTranslatef(pt1[0] , pt1[1] , pt1[2]);
	        // appliquer la rotation 
                glRotatef(tts[0], tts[1], tts[2], tts[3]);
 
                // appliquer le scaling
                glScalef(1, 1, lgth);
 
                // dessin du cylindre unitaire sur OZ
	        gluCylinder( quadric, baseRadius, topRadius, 1, slices, stacks );
 
             glPopMatrix();

et maintenant voici le code que j'ai écris pour trouver l'angle de rotation 3D entre OZ et P1P2;

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
float * getRotAngle(float a[3], float b[3])
{
 
// le vecteur
float v[3]={ b[0] - a[0] , b[1] - a[1] , b[2] - a[2] };
 
// la longueur
float lg= distance(a, b);
 
// calcul de rotation par rapport au vecteur OZ;
float OZ[3]= { 0, 0 , 1};
 
float vn[3]= { v[0]/lg , v[1]/lg , v[2]/lg };
 
// produit_normes  =  norm(OZ) * norm(vn);    
float prod_norm= sqrt( pow(OZ[0],2) + pow(OZ[1],2) + pow(OZ[2],2)) * sqrt(pow(vn[0],2) + pow(vn[1],2) + pow(vn[2],2));
 
// produit_scalaire=  dot(OZ , vn);
float prod_scalar= produitScalaire(vn, OZ) ;
 
// produit_vectoriel= cross(OZ , vn);
float prod_vect[3];
      produitVectoriel(OZ, vn, prod_vect); // non-normalisé
 
//cos_phi= produit_scalaire  / produit_normes ;
float cos_phi= prod_scalar / prod_norm;
 
//sin_phi= norm(produit_vectoriel) / produit_normes;
float sin_phi= sqrt( pow(prod_vect[0],2) + pow(prod_vect[1],2) + pow(prod_vect[2],2) ) / prod_norm;
 
float phi=  acos(cos_phi); 
if (phi > PI/2)
   {
      phi = PI - phi;
   }
 
float N[3];
        produitVectoriel(OZ, vn, N);
        int d= normalise(N);
 
float ux= N[0];
float uy= N[1];
float uz= N[2];
 
float c= cos(phi); 
float s= sin(phi);
 
float angle = 180 - 180 * phi / PI;
 
float *output= new float[4];
output[0] = angle;
output[1] = ux;
output[2] = uy;
output[3] = uz;
 
return output;
}

Voilà, enfin j'espère que ce topic va aider quelque uns à s'en sortir mieux avec ces transformations.