Discussion :

[chtugaa]

Bonjour à tous,

Mon problème est le suivant : J'essaie d'afficher une sorte de faisceau lumineux sous X11. Je dessine donc un arc de cercle centré sur le point où je viens de cliquer puis j'affiche les traits qui bordent le faisceau : ceux qui partent du centre et qui rejoignent le bord de l'arc. je vous ai dessiné un exemple dans le fichier joint (le point P est l'endroit où j'ai cliqué et les points A et B sont les intersections des traits et de l'arc).

Pour l'affichage, je connais les fonctions en X11. Cependant, pour les coordonnées des deux points reliant les traits et l'arc c'est une autre histoire… je n'arrive pas à trouver de formule !

Voici le bout de code que j'ai fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void draw_Light(int r, int arg1, int arg2,Point P){
     XClearWindow(display, window);
     double xA = P.x+(r/2)*cos(arg1/64*(3.14/180));
     double yA = P.y+(r/2)*sin(arg1/64*(3.14/180));
     double xB = P.x+(r/2)*cos(arg2/64*(3.14/180));
     double yB = P.y+(r/2)*sin(arg2/64*(3.14/180));
     setLineWidth_Color(1,BLUE); 
     XDrawArc(display,window,graphicContext,P.x-(r/2),P.y-(r/2),r,r,arg1<<6,arg2<<6);
     setLineWidth_Color(1,BLUE); 
     XDrawLine(DX11,P.x,P.y,xB,yB);
     setLineWidth_Color(1,BLUE); 
     XDrawLine(DX11,P.x,P.y,xA,yA);
     XFlush(display);
}

Que devrais-je rentrer pour les coordonnées des points A et B ?

J'espère vraiment que vous pourrez m'aider parce que je suis dessus depuis une semaine et je n'y arrive toujours pas !

Je vous remercie d'avance.

Bonne journée !

[gerald3d]

J'ai du mal à saisir ton problème. Tu désires connaître les coordonnées de A et B, c'est bien ca ?

Si tu connais l'angle alors les coordonnées des points sont :

Code :

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

1
2
A (cos arg1, sin arg1)
B (cos arg2, sin arg2)

Tu peux ensuite multiplier chaque membre des deux points par un facteur pour avoir une longueur de trait supérieur à 1 dans le meilleur des cas.

Par exemple F = 10

Code :

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

1
2
A (F*cos arg1, F*sin arg1)
B (F*cos arg2, F*sin arg2)

Bon, j'ai fait de tête. En espérant ne pas être trop fatigué

[diogene]

En quelle unité sont exprimés les angles arg1 et arg2 ?

Si on regarde les arguments dans le calcul des sin/cos, arg1/64*(3.14/180) , arg1/64 est en degré et arg1 == 64 correspond à un angle de 1 degré

Par contre dans XDrawArc(), la doc dit que l'argument est l'angle en degré multiplié par 64. Pour arg1 ==1 , l'argument utilisé vaut 64 donc correspond à 1 degré.

Alors, arg1 est-il exprimé en degré ou en 1/64-ième de degré ?

[chtugaa]

Merci pour vos réponses,

Pour diogene, les angles arg1 et arg2 sont exprimés en 64eme de degré. (je ne sais pas pourquoi mais c'est ce que m'a expliqué mon prof)
Je pense que le soucis ce situe à la fois au niveau de la conversion *64 ou /64 et en plus j'ai le problème de l'unité des angles, dans XDrawArc les angles doivent etre en degré et dans cos et sin ils doivent etre en radian.
C'est pour cela que j'avais rajouté la conversion *(3,14/180).

Je ne vois pas pourquoi sa bloque..

[Obsidian]

Hello,

Pour diogene, les angles arg1 et arg2 sont exprimés en 64eme de degré. (je ne sais pas pourquoi mais c'est ce que m'a expliqué mon prof)

Fort probablement parce que le registre qui contient ton angle utilise une virgule fixe, ce qui est très courant, spécialement dans les mesures d'angle. Ainsi, il te suffit d'utiliser des entiers pour les stocker et tu peux directement les additionner entre eux sans te soucier du reste. Avec des soixante-quatrièmes d'angle, ce sont tes six bits de poids faible qui mesurent la partie fractionnaire.

Je me souviens que mon TO8D de 1985 embarquait un BASIC qui émulaient certaines fonctions du LOGO, dont « la tortue » et qu'à l'époque déjà, on mesurait les angles en 256ième de degrés. Ainsi sur un registre 16 bits, la partie de gauche mesurait automatiquement la partie entière et celle de droite la partie rationnelle. Une telle précision était nécessaire et le système de virgule fixe était bien pratique sur un micro-processeur 8 bits (enfin 8/16) et sans aucun co-processeur mathématique, il aurait été extrêmement coûteux de tout mettre sur des float (voire des double, comme on le fait systématiquement aujourd'hui).

[diogene]

Si arg1 est en 1/64-ième de degré, alors l'argument dans les sin/cos doit être

Code :

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

arg1/64.0*(3.14/180)

Attention, à écrire 64.0 et non pas 64 sinon la division arg1/64 est une division entière.

Par contre, la doc de XDrawArc() dit que l'angle doit être exprimé avec pour unité 1/64-ième de degré

Code :

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

1
2
3
4
5
6
7
XDrawArc(display, d, gc, x, y, width, height, angle1, angle2)
      Display *display;
      Drawable d;
      GC gc;
      int x, y;
      unsigned int width, height;
      int angle1, angle2;

....
angle1 Specifies the start of the arc relative to the three-o'clock position from the center, in units of degrees * 64.
angle2 Specifies the path and extent of the arc relative to the start of the arc, in units of degrees * 64.

Alors, on devrait avoir

Code :

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

 XDrawArc(...,arg1,arg2-arg1);

[chtugaa]

Je suis sure qu'il est nécéssaire d'avoir *64 dans les arguments concerant les angles dans la fonction XDrawArc, j'ai utilisé sans et j'angle se résume à 2 ou 3 pixels.
Dans ce cas cela veut-il dire que arg1 et arg2 ne sont pas en 64eme de degré mais en *64 ?
Je suis un peu perdue avec toute ses conversions.
Voici la dernière fonction que j'ai utilisée et qui ne marchait pas :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void draw_Light(int r, int arg1, int arg2,Point P,float m){
	XClearWindow(display,window);
             double xA = P.x+(r/2)*cos((arg1/64.0)*(3.14/180));
	double yA = P.y+(r/2)*sin((arg1/64.0)*(3.14/180));
	double xB = P.x+(r/2)*cos(((arg2-arg1)/64.0)*(3.14/180));
	double yB = P.y+(r/2)*sin(((arg2-arg1)/64.0)*(3.14/180));
	setLineWidth_Color(1,BLUE);	
	XDrawArc(display,window,graphicContext,P.x-(r/2),P.y-(r/2),r,r,arg1*64,arg2*64); 
	XDrawLine(DX11,P.x,P.y,xB,yB);
	setLineWidth_Color(1,BLUE);	
	XDrawLine(DX11,P.x,P.y,xA,yA);
	XFlush(display);
}

J'ai également essayée de remplacer les" P.x+(r/2)" par "P.x-(r/2)" dans les expressions des 2 y car je sais que l'axe des y est vertical descendant mais cela ne fonctionne pas non plus.

[diogene]

C'est un peu n'importe quoi, il faut cesser d'écrire du code au hasard : Comment peut-on écrire une fonction dont on ne sait même pas à quoi doivent correspondre ses arguments ? Et voila maintenant en plus que la définition de arg1 et arg2 a changé et ne correspond plus à la figure du premier post : il faut savoir si arg1 et arg2 sont les angles correspondant aux points A et B ou si arg2 est l'angle BPA

Si il faut (?) *64 dans XDrawArc(), alors arg1 et arg2 sont en degré et il ne faut pas /64.0 dans les sin/cos
Si il ne faut pas *64 dans XDrawArc(), alors arg1 et arg2 sont en 1/64-iéme de degré et il faut /64.0 dans les sin/cos