Discussion :

[piponux]

Bonjour,
je suis en train de programmer un petit editeur de sprites / dessins en langage c avec SDL2.
J'en suis aux ellipses, que je veux faire pivoter selon un certain angle et à partir d'une origine en x et y.
Pour l'instant, je n'ai programmé que les angles 300°, 315°, 330° et 345°.
voici le résultat où l'origine est en (0,0).

ma question est la suivante : l'écrasement des ellipses est il un phénomène normal? et comment résoudre le problème des trous?

[foetus]

Souvent en 2D, un truc simple et assez rapide pour rendre plus joli son "programme": augmenter la définition
Sérieux, tu travailles en 80x60 tu veux faire quoi

Parce que ton histoire de trous doit venir du fait qu'en affichage, on travaille en espace discret (avec des entiers et non pas des flottants)
Des algos comme celui de Bresenham permettent de faire fi, en partie, de cette particularité: cherche-en 1 pour tracer des ellipses

[piponux]

Sérieux, tu travailles en 80x60 tu veux faire quoi

Salut, je veux m'éclater en apprenant à programmer et en voyant de près comment ça marche. Je ne suis pas du tout du métier, donc je travaille sans pression et sans impératif, et celà reste un plaisir et un loisir avant tout.
Je n'avais pas pensé à Bresenham: merci pour l'idée!
j'ai trouvé ce lien : http://raphaello.univ-fcomte.fr/ig/a...orithmique.htm
mais je ne suis pas sûr que les trous viennent de l'agorithme de tracé, mais plutot de la rotation d'un tracé existant.
Mon but est de dessiner une forme quelle qu'elle soit, et de la faire pivoter à volonté.

[dalfab]

mais je ne suis pas sûr que les trous viennent de l'agorithme de tracé, mais plutot de la rotation d'un tracé existant.
Mon but est de dessiner une forme quelle qu'elle soit, et de la faire pivoter à volonté.

Justement, si on effectue une rotation d'un tracé on ne peut obtenir qu'une dégradation du tracé initial. En faisant "tourner" chaque pixel, sa coordonnée finale devant être arrondie et l'orientation de son dessin restant constante, on obtient un résultat forcément déplorable.
Sur une figure avec une résolution énorme (avec une épaisseur de trait de plus de 10 pixels), le problème est moins visible, mais existera toujours.
Seul moyen pour un tracé correct : recalculer entièrement l'ellipse.

[Obsidian]

Bonjour,

Je n'avais pas pensé à Bresenham: merci pour l'idée!

Ah ? Ce n'est pas là-dessus que tu es parti depuis le départ ? Il y a écrit « BRESENHAM CIRCLE » au bas de ta capture d'écran…

j'ai trouvé ce lien : http://raphaello.univ-fcomte.fr/ig/a...orithmique.htm
mais je ne suis pas sûr que les trous viennent de l'agorithme de tracé, mais plutot de la rotation d'un tracé existant.
Mon but est de dessiner une forme quelle qu'elle soit, et de la faire pivoter à volonté.

Faire pivoter une ellipse, quand on n'est pas une brute en mathématiques, est effectivement un serpent de mer.

Ici, le résultat que tu obtiens dépend beaucoup de la manière dont tu effectues ta rotation, ce qui n'est pas précisé ici.

Le principe de l'algo de Bresenham est double : d'une part, il s'agit de garantir un tracé continu et, de l'autre, de minimiser les calculs à effectuer de façon à obtenir un tracé rapide, ce qui était critique avec les ordinateurs d'ancienne génération, notamment les huit bits (et aujourd'hui, les micro-contrôleurs). Ceux qui ont connu cette époque étaient tous habitués à avoir une commande CIRCLE en Basic et ça paraissait normal, mais peu savent ce qu'ils doivent aux algos optimisés. C'est aussi intéressant d'aller voir comment cela était implémenté en assembleur à l'époque (et pas compilé depuis le C). Les quelques lignes de C qui suffisent à l'implémenter (principalement parce qu'il s'agit d'une formule mathématique) se traduisaient par une routine occupant 4 % de l'espace total de l'une des deux banques ROM consacrées au langage.

Pour faire cela, donc, Bresenham trace un quart de cercle en faisant « avancer » un pixel, en partant de la gauche puis le déplace soit vers la droite si on est au dessus d'un certain seuil, soit vers le haut si on est en dessous. Et pour connaître ces seuils, il dérive initialement deux fois l'équation du cercle, de sorte que la différence entre deux pixels diffère — elle-même — d'une valeur constante à chaque fois. Il est donc très facile de mettre les compteurs à jour à chaque étape. Une simple addition et une multiplication, qui étaient déjà coûteuses à l'époque parce qu'elles étaient purement logicielles, et parce qu'elles étaient obligatoirement sur 32 bits, ce qui n'était pas du tout le format naturel des machines de l'époque (un 6809, par exemple, avait des registres de 8 et 16 bits. Au dessus, il fallait faire l'addition à la main). Mais par contre, ça permettait de s'affranchir du calcul de la prohibitive racine carrée…

Tout cela pour dire que ce n'est pas forcément très difficile MAIS que l'algo en question dépend fortement du repère dans lequel il travaille : si tu veux faire pivoter ton ellipse tout en gardant un tracé rapide et continu, tu es en fait obligé de tracer une autre courbe et il faut donc modifier l'équation. Avec cela, il faut tenir compte du fait qu'en temps normal et à l'origine, une ellipse admet les axes x et y comme axes de symétrie et se comporte comme une fonction sur le quadrant traité, ce qui n'est plus possible dès lors qu'on la fait pivoter.

[piponux]

il est écrit "bresenham circle" car lorsque j'ai pris la capture d'écran, la zone selectionnée était le cercle. L'ellipse, quant à elle, est encore calculée en mode de sélection non graphique.
voici le code des ellipses (ex 1er quadrant):

Code c :

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
void Ellipse_1er_quadrant(image I, int x1, int y1, int longueur, int pente, colour c)
{
 int x = -longueur, y = 0;
 
 long e2 = (long)pente*pente, err = x*(2*e2+x)+e2;
 
 do {
 image_putpixel(I, x1-x, y1-y, c);/*1er quadrant*/
 e2 = 2*err;
 if (e2 >= (x*2+1)*(long)pente*pente)
 err += (++x*2+1)*(long)pente*pente;
 if (e2 <= (y*2+1)*(long)longueur*longueur)
 err += (++y*2+1)*(long)longueur*longueur;
 } while (x <= 0);
 
 
 while (y++ < pente) {
 image_putpixel(I, x1, y1+y, c);
 image_putpixel(I, x1, y1-y, c);
 }
}

et voici le code de la rotation d'un pixel:

Code c :

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
void image_putpixel_with_angle (image I, int Origine_en_x, int Origine_en_y, int angle, int x, int y, colour c)
{
      int origine_en_x = Origine_en_x;
      int origine_en_y = Origine_en_y;
 
      int px1 = origine_en_x;
      int py1 = origine_en_y;
      int px2 = origine_en_x + x;
      int py2 = origine_en_y + y;
 
      int distanceX = px2 - px1;
      int distanceY = py2 - py1;
      int Distance = sqrt((distanceX * distanceX) + (distanceY * distanceY));
 
      int coordonnees_du_point_en_x;
      int coordonnees_du_point_en_y;
 
 
 
        switch (angle)
        {
         case 285 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(6) - sqrt(2)) / 4);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(6) + sqrt(2)) / 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {    
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
 
 
         case 300 :
         coordonnees_du_point_en_x = origine_en_x + (Distance / 2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(3) /  2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
 
         case 315 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * sqrt(2) /  2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * sqrt(2) /  2);
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         break; 
 
         case 330 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * sqrt(3) /  2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance /  2);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {          
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 345 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(6) + sqrt(2)) / 4);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(6) - sqrt(2)) /  4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {          
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 255 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * (sqrt(6) - sqrt(2)) / 4);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(6) + sqrt(2)) /  4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 240 :
         coordonnees_du_point_en_x = origine_en_x - (Distance /2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(3)  /  2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         { 
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 225 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * sqrt(2) /2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance * (sqrt(2)  /  2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 210 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * sqrt(3) /2);
         coordonnees_du_point_en_y = origine_en_y + y + (Distance  /  2);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 195 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * ((sqrt(6) + sqrt(2)) / 4));
         coordonnees_du_point_en_y = origine_en_y + y + (Distance  * (sqrt(6) - sqrt(2)) / 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 165 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * ((sqrt(6) + sqrt(2)) / 4));
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(6) - sqrt(2)) / 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 150 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * (sqrt(3)  / 2));
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  / 2);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 135 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * (sqrt(2)  / 2));
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(2)/ 2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 120 :
         coordonnees_du_point_en_x = origine_en_x - (Distance / 2);
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(3)/ 2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 105 :
         coordonnees_du_point_en_x = origine_en_x - (Distance * (sqrt(6) - sqrt(2)) / 4);
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(6) + sqrt(2))/ 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 75 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(6) - sqrt(2)) / 4);
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(6) + sqrt(2))/ 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 60 :
         coordonnees_du_point_en_x = origine_en_x + (Distance  / 2);
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(3) / 2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 45 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(2)  / 2));
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  * (sqrt(2) / 2));
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 30 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(3)  / 2));
         coordonnees_du_point_en_y = origine_en_y - y - (Distance  / 2);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {          
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 15 :
         coordonnees_du_point_en_x = origine_en_x + (Distance * (sqrt(6) + sqrt(2))  / 4);
         coordonnees_du_point_en_y = origine_en_y - y - (Distance * (sqrt(6) - sqrt(2)) / 4);
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 90 :
         coordonnees_du_point_en_x = origine_en_x ;
         coordonnees_du_point_en_y = origine_en_y - y - Distance;
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 180 :
         coordonnees_du_point_en_x = origine_en_x - Distance;
         coordonnees_du_point_en_y = origine_en_y ;
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 270 :
         coordonnees_du_point_en_x = origine_en_x ;
         coordonnees_du_point_en_y = origine_en_y + y + Distance;
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         case 360 :
         coordonnees_du_point_en_x = origine_en_x + Distance ;
         coordonnees_du_point_en_y = origine_en_y;
         if (coordonnees_du_point_en_x >= 0 && coordonnees_du_point_en_x < I->w &&
             coordonnees_du_point_en_y >= 0 && coordonnees_du_point_en_y < I->h)
         {         
         image_putpixel(I, px2, py2 , 0xff0000ff); 
         image_putpixel(I, coordonnees_du_point_en_x, coordonnees_du_point_en_y , c);
         }
         break; 
 
         default :
         break;
 
 
      }
}

et donc, ci dessous, on voit le point jaune qui est l'image (je pense qu'on dit comme ça - car effectivement je suis loin d'être un brute en maths) du point rouge, avec un angle de 60°.

[Obsidian]

Sauf erreur de ma part, il manque quelque chose dans ton code.

Le premier extrait semble être Bresenham, qui te trace donc un quart d'ellipse alignée le long des axes, et le second a l'air de faire une translation de ta figure le long d'un rayon du cercle, avec des angles spéciaux. Ça va déplacer ton ellipse mais ça ne devrait pas la faire tourner elle-même…