Discussion :

[LaTo59]

Bonjour,


J'ai besoin de tracer un angle entre 2 droites:

- pour calculer un angle, pas de problème
- pour tracer un cercle, pas de problème

- pour tracer l'arc de cercle correspondant à l'angle (en ne dépassant pas les 2 droites), je coince

Les seules informations disponibles sont les 3 points formant l'angle et le rayon du cercle.



J'ai essayé ceci mais ça ne fonctionne pas, en 4 étapes:

- calcul de la bissectrice de l'angle
- calcul de la tangente du cercle au niveau de la bissectrice

- intersection entre la tangente et la droite "point1 -> point2" (point bleu)
- intersection entre la tangente et la droite "point2 -> point3" (point bleu)

- intersection entre le cercle et la droite "point1 -> point2" (point rouge)
- intersection entre le cercle et la droite "point2 -> point3" (point rouge)

- intersection entre une parallèle à la bissectrice passant par le 1er point bleu et la droite passant par les 2 points rouges (point bleu)
- intersection entre une parallèle à la bissectrice passant par le 2eme point bleu et la droite passant par les 2 points rouges (point bleu)

Si les coordonnées du point du cercle sont dans le rectangle formé par les points bleus, alors on trace, sinon on ne trace pas.




Un petit schéma sous paint sinon c'est vraiment pas clair :


Si quelqu'un a une meilleure idée

Merci d'avance!!!


PS: je travaille avec la SDL mais ça ne change pas le problème

[FR119492]

Salut!
Tout dépend du logiciel que tu utilises. Par exemple, avec le module PSTricks de LaTeX, ça ne pose aucun problème.
Jean-Marc Blanc

[LaTo59]

Je code en C avec la SDL, la fonction que j'utilise pour tracer le cercle est celle ci:

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
void TracerCercle(int cx, int cy, int rayon, int coul)
{
  float t = 0;
  int x = rayon;
  int y = 0;
 
  float distance,dist_frac;
 
  while (x > y+1) {
 
    distance = sqrt( rayon*rayon, y*y );
    dist_frac = ceil(distance) - distance;
    if( dist_frac < t ) x--;
 
    PutPixel(cx + x, cy + y, coul);
    PutPixel(cx + y, cy + x, coul);
    PutPixel(cx - x, cy + y, coul);
    PutPixel(cx - y, cy + x, coul);
    PutPixel(cx + x, cy - y, coul);
    PutPixel(cx + y, cy - x, coul);
    PutPixel(cx - x, cy - y, coul);
    PutPixel(cx - y, cy - x, coul);
 
    t = dist_frac;
    y++;
  }
}

[souviron34]

déjà un problème : tu utilises des fonctions qui sortent des doubles et tu stockes dans un float...


Sinon c'est assez bête :

X^2+Y^2=R^2


De A(x1,y1) (alpha1) à B(X2,y2) (alpha2), par incrément de Delta.. calculer C(x,y) (alpha)..

[Kangourou]

salut,

Une possibilité est de passer par la représentation paramétrique du cercle :

1) calculer theta1, l'angle que fait avec l'horizontale la droite entre les points 1 et 2
2) calculer theta2, l'angle que fait avec l'horizontale la droite entre les points 1 et 3
3) pour t qui varie de theta1 a theta2, tracer un point de coordonnées :
x = r*cos(t) + x0
y = r*sin(t) + y0

ou un peu plus propre, tracer des segments de droite.

Il y a qlq précautions a prendre avec la gestion des angles (si theta1 > theta2, il faut itérer de theta1 a theta2+2*pi), mais ca devrait pas être trop méchant.

A+

[pseudocode]

Je code en C avec la SDL, la fonction que j'utilise pour tracer le cercle est celle ci:

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
void TracerCercle(int cx, int cy, int rayon, int coul)
{
  float t = 0;
  int x = rayon;
  int y = 0;
 
  float distance,dist_frac;
 
  while (x > y+1) {
 
    distance = sqrt( rayon*rayon, y*y );
    dist_frac = ceil(distance) - distance;
    if( dist_frac < t ) x--;
 
    PutPixel(cx + x, cy + y, coul);
    PutPixel(cx + y, cy + x, coul);
    PutPixel(cx - x, cy + y, coul);
    PutPixel(cx - y, cy + x, coul);
    PutPixel(cx + x, cy - y, coul);
    PutPixel(cx + y, cy - x, coul);
    PutPixel(cx - x, cy - y, coul);
    PutPixel(cx - y, cy - x, coul);
 
    t = dist_frac;
    y++;
  }
}

C'est la technique du MidPoint. Cette technique marche en découpant le plan en 8 octants (= portions de 45°). Donc pour adapter cette technique au tracé d'un arc, il faut identifier les octants traversés par l'arc.
- pour les octants traversés totalement, tu utilises l'algo ci-dessus
- pour les octants traversés partiellement (début/fin de l'arc), il faut modifier la conditon du "while" pour s'arrêter aux extrémités.

[Mac LAK]

Au passage, ça tracerait plus vite si tu utilisais l'algo de Bresenham pour calculer le prochain point au lieu de formules en virgule flottante...