![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd_arc_f_buggy.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd|
Return to gd_arc_f_buggy.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd |
1.1 misho 1: /* This is potentially great stuff, but fails against the test
2: program at the end. This would probably be much more
3: efficent than the implementation currently in gd.c if the
4: errors in the output were corrected. TBB */
5:
6: #if 0
7:
8: #include "gd.h"
9: #include <math.h>
10:
11: /* Courtesy of F J Franklin. */
12:
13: static gdPoint gdArcClosest (int width, int height, int angle);
14:
15: void
16: gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int width, int height, int color)
17: {
18: gdImageFilledArc (im, cx, cy, width, height, 0, 360, color, gdChord);
19: }
20:
21: void
22: gdImageFilledArc (gdImagePtr im, int cx, int cy, int width, int height, int s, int e, int color, int style)
23: {
24: gdPoint pt[7];
25: gdPoint axis_pt[4];
26:
27: int angle;
28:
29: int have_s = 0;
30: int have_e = 0;
31:
32: int flip_x = 0;
33: int flip_y = 0;
34:
35: int conquer = 0;
36:
37: int i;
38:
39: int a;
40: int b;
41:
42: int x;
43: int y;
44:
45: long s_sin = 0;
46: long s_cos = 0;
47: long e_sin = 0;
48: long e_cos = 0;
49:
50: long w; /* a * 2 */
51: long h; /* b * 2 */
52:
53: long x2; /* x * 2 */
54: long y2; /* y * 2 */
55: long lx2; /* x * 2 (line) */
56: long ly2; /* y * 2 (line) */
57:
58: long ws; /* (a * 2)^2 */
59: long hs; /* (b * 2)^2 */
60:
61: long whs; /* (a * 2)^2 * (b * 2)^2 */
62:
63: long g; /* decision variable */
64: long lg; /* decision variable (line) */
65:
66: width = (width & 1) ? (width + 1) : (width);
67: height = (height & 1) ? (height + 1) : (height);
68:
69: a = width / 2;
70: b = height / 2;
71:
72: axis_pt[0].x = a;
73: axis_pt[0].y = 0;
74: axis_pt[1].x = 0;
75: axis_pt[1].y = b;
76: axis_pt[2].x = -a;
77: axis_pt[2].y = 0;
78: axis_pt[3].x = 0;
79: axis_pt[3].y = -b;
80:
81: if (s == e)
82: return;
83:
84: if ((e - s) >= 360)
85: {
86: s = 0;
87: e = 0;
88: }
89:
90: while (s < 0)
91: s += 360;
92: while (s >= 360)
93: s -= 360;
94: while (e < 0)
95: e += 360;
96: while (e >= 360)
97: e -= 360;
98:
99: if (e <= s)
100: e += 360;
101:
102: /* I'm assuming a chord-rule at the moment. Need to add origin to get a
103: * pie-rule, but will need to set chord-rule before recursion...
104: */
105:
106: for (i = 0; i < 4; i++)
107: {
108: if ((s < (i + 1) * 90) && (e > (i + 1) * 90))
109: {
110: gdImageFilledArc (im, cx, cy, width, height, s, (i + 1) * 90, color, gdChord);
111: pt[0] = gdArcClosest (width, height, s);
112: pt[0].x += cx;
113: pt[0].y += cy;
114: pt[1].x = cx + axis_pt[(i + 1) & 3].x;
115: pt[1].y = cy + axis_pt[(i + 1) & 3].y;
116: if (e <= (i + 2) * 90)
117: {
118: gdImageFilledArc (im, cx, cy, width, height, (i + 1) * 90, e, color, gdChord);
119: pt[2] = gdArcClosest (width, height, e);
120: pt[2].x += cx;
121: pt[2].y += cy;
122: if (style == gdChord)
123: {
124: gdImageFilledPolygon (im, pt, 3, color);
125: gdImagePolygon (im, pt, 3, color);
126: }
127: else if (style == gdPie)
128: {
129: pt[3].x = cx;
130: pt[3].y = cy;
131: gdImageFilledPolygon (im, pt, 4, color);
132: gdImagePolygon (im, pt, 4, color);
133: }
134: }
135: else
136: {
137: gdImageFilledArc (im, cx, cy, width, height, (i + 1) * 90, (i + 2) * 90, color, gdChord);
138: pt[2].x = cx + axis_pt[(i + 2) & 3].x;
139: pt[2].y = cy + axis_pt[(i + 2) & 3].y;
140: if (e <= (i + 3) * 90)
141: {
142: gdImageFilledArc (im, cx, cy, width, height, (i + 2) * 90, e, color, gdChord);
143: pt[3] = gdArcClosest (width, height, e);
144: pt[3].x += cx;
145: pt[3].y += cy;
146: if (style == gdChord)
147: {
148: gdImageFilledPolygon (im, pt, 4, color);
149: gdImagePolygon (im, pt, 4, color);
150: }
151: else if (style == gdPie)
152: {
153: pt[4].x = cx;
154: pt[4].y = cy;
155: gdImageFilledPolygon (im, pt, 5, color);
156: gdImagePolygon (im, pt, 5, color);
157: }
158: }
159: else
160: {
161: gdImageFilledArc (im, cx, cy, width, height, (i + 2) * 90, (i + 3) * 90, color, gdChord);
162: pt[3].x = cx + axis_pt[(i + 3) & 3].x;
163: pt[3].y = cy + axis_pt[(i + 3) & 3].y;
164: if (e <= (i + 4) * 90)
165: {
166: gdImageFilledArc (im, cx, cy, width, height, (i + 3) * 90, e, color, gdChord);
167: pt[4] = gdArcClosest (width, height, e);
168: pt[4].x += cx;
169: pt[4].y += cy;
170: if (style == gdChord)
171: {
172: gdImageFilledPolygon (im, pt, 5, color);
173: gdImagePolygon (im, pt, 5, color);
174: }
175: else if (style == gdPie)
176: {
177: pt[5].x = cx;
178: pt[5].y = cy;
179: gdImageFilledPolygon (im, pt, 6, color);
180: gdImagePolygon (im, pt, 6, color);
181: }
182: }
183: else
184: {
185: gdImageFilledArc (im, cx, cy, width, height, (i + 3) * 90, (i + 4) * 90, color, gdChord);
186: pt[4].x = cx + axis_pt[(i + 4) & 3].x;
187: pt[4].y = cy + axis_pt[(i + 4) & 3].y;
188:
189: gdImageFilledArc (im, cx, cy, width, height, (i + 4) * 90, e, color, gdChord);
190: pt[5] = gdArcClosest (width, height, e);
191: pt[5].x += cx;
192: pt[5].y += cy;
193: if (style == gdChord)
194: {
195: gdImageFilledPolygon (im, pt, 6, color);
196: gdImagePolygon (im, pt, 6, color);
197: }
198: else if (style == gdPie)
199: {
200: pt[6].x = cx;
201: pt[6].y = cy;
202: gdImageFilledPolygon (im, pt, 7, color);
203: gdImagePolygon (im, pt, 7, color);
204: }
205: }
206: }
207: }
208: return;
209: }
210: }
211:
212: /* At this point we have only arcs that lies within a quadrant -
213: * map this to first quadrant...
214: */
215:
216: if ((s >= 90) && (e <= 180))
217: {
218: angle = s;
219: s = 180 - e;
220: e = 180 - angle;
221: flip_x = 1;
222: }
223: if ((s >= 180) && (e <= 270))
224: {
225: s = s - 180;
226: e = e - 180;
227: flip_x = 1;
228: flip_y = 1;
229: }
230: if ((s >= 270) && (e <= 360))
231: {
232: angle = s;
233: s = 360 - e;
234: e = 360 - angle;
235: flip_y = 1;
236: }
237:
238: if (s == 0)
239: {
240: s_sin = 0;
241: s_cos = (long) ((double) 32768);
242: }
243: else
244: {
245: s_sin = (long) ((double) 32768 * sin ((double) s * M_PI / (double) 180));
246: s_cos = (long) ((double) 32768 * cos ((double) s * M_PI / (double) 180));
247: }
248: if (e == 0)
249: {
250: e_sin = (long) ((double) 32768);
251: e_cos = 0;
252: }
253: else
254: {
255: e_sin = (long) ((double) 32768 * sin ((double) e * M_PI / (double) 180));
256: e_cos = (long) ((double) 32768 * cos ((double) e * M_PI / (double) 180));
257: }
258:
259: w = (long) width;
260: h = (long) height;
261:
262: ws = w * w;
263: hs = h * h;
264:
265: whs = 1;
266: while ((ws > 32768) || (hs > 32768))
267: {
268: ws = (ws + 1) / 2; /* Unfortunate limitations on integers makes */
269: hs = (hs + 1) / 2; /* drawing large ellipses problematic... */
270: whs *= 2;
271: }
272: while ((ws * hs) > (0x04000000L / whs))
273: {
274: ws = (ws + 1) / 2;
275: hs = (hs + 1) / 2;
276: whs *= 2;
277: }
278: whs *= ws * hs;
279:
280: pt[0].x = w / 2;
281: pt[0].y = 0;
282:
283: pt[2].x = 0;
284: pt[2].y = h / 2;
285:
286: have_s = 0;
287: have_e = 0;
288:
289: if (s == 0)
290: have_s = 1;
291: if (e == 90)
292: have_e = 1;
293:
294: x2 = w;
295: y2 = 0; /* Starting point is exactly on ellipse */
296:
297: g = x2 - 1;
298: g = g * g * hs + 4 * ws - whs;
299:
300: while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
301: {
302: y2 += 2;
303: g += ws * 4 * (y2 + 1);
304:
305: if (g > 0) /* Need to drop */
306: {
307: x2 -= 2;
308: g -= hs * 4 * x2;
309: }
310:
311: if ((have_s == 0) && ((s_sin * x2) <= (y2 * s_cos)))
312: {
313: pt[0].x = (int) (x2 / 2);
314: pt[0].y = (int) (y2 / 2);
315: have_s = 1;
316: }
317:
318: if ((have_e == 0) && ((e_sin * x2) <= (y2 * e_cos)))
319: {
320: pt[2].x = (int) (x2 / 2);
321: pt[2].y = (int) (y2 / 2);
322: have_e = 1;
323: }
324: }
325: pt[1].x = (int) (x2 / 2);
326: pt[1].y = (int) (y2 / 2);
327:
328: x2 = 0;
329: y2 = h; /* Starting point is exactly on ellipse */
330:
331: g = y2 - 1;
332: g = g * g * ws + 4 * hs - whs;
333:
334: while ((x2 * hs) < (y2 * ws))
335: {
336: x2 += 2;
337: g += hs * 4 * (x2 + 1);
338:
339: if (g > 0) /* Need to drop */
340: {
341: y2 -= 2;
342: g -= ws * 4 * y2;
343: }
344:
345: if ((have_s == 0) && ((s_sin * x2) >= (y2 * s_cos)))
346: {
347: pt[0].x = (int) (x2 / 2);
348: pt[0].y = (int) (y2 / 2);
349: have_s = 1;
350: }
351:
352: if ((have_e == 0) && ((e_sin * x2) >= (y2 * e_cos)))
353: {
354: pt[2].x = (int) (x2 / 2);
355: pt[2].y = (int) (y2 / 2);
356: have_e = 1;
357: }
358: }
359:
360: if ((have_s == 0) || (have_e == 0))
361: return; /* Bizarre case */
362:
363: if (style == gdPie)
364: {
365: pt[3] = pt[0];
366: pt[4] = pt[1];
367: pt[5] = pt[2];
368:
369: pt[0].x = cx + (flip_x ? (-pt[0].x) : pt[0].x);
370: pt[0].y = cy + (flip_y ? (-pt[0].y) : pt[0].y);
371: pt[1].x = cx;
372: pt[1].y = cy;
373: pt[2].x = cx + (flip_x ? (-pt[2].x) : pt[2].x);
374: pt[2].y = cy + (flip_y ? (-pt[2].y) : pt[2].y);
375: gdImageFilledPolygon (im, pt, 3, color);
376: gdImagePolygon (im, pt, 3, color);
377:
378: pt[0] = pt[3];
379: pt[1] = pt[4];
380: pt[2] = pt[5];
381: }
382:
383: if (((s_cos * hs) > (s_sin * ws)) && ((e_cos * hs) < (e_sin * ws)))
384: { /* the points are on different parts of the curve...
385: * this is too tricky to try to handle, so divide and conquer:
386: */
387: pt[3] = pt[0];
388: pt[4] = pt[1];
389: pt[5] = pt[2];
390:
391: pt[0].x = cx + (flip_x ? (-pt[0].x) : pt[0].x);
392: pt[0].y = cy + (flip_y ? (-pt[0].y) : pt[0].y);
393: pt[1].x = cx + (flip_x ? (-pt[1].x) : pt[1].x);
394: pt[1].y = cy + (flip_y ? (-pt[1].y) : pt[1].y);
395: pt[2].x = cx + (flip_x ? (-pt[2].x) : pt[2].x);
396: pt[2].y = cy + (flip_y ? (-pt[2].y) : pt[2].y);
397: gdImageFilledPolygon (im, pt, 3, color);
398: gdImagePolygon (im, pt, 3, color);
399:
400: pt[0] = pt[3];
401: pt[2] = pt[4];
402:
403: conquer = 1;
404: }
405:
406: if (conquer || (((s_cos * hs) > (s_sin * ws)) && ((e_cos * hs) > (e_sin * ws))))
407: { /* This is the best bit... */
408: /* steep line + ellipse */
409: /* go up & left from pt[0] to pt[2] */
410:
411: x2 = w;
412: y2 = 0; /* Starting point is exactly on ellipse */
413:
414: g = x2 - 1;
415: g = g * g * hs + 4 * ws - whs;
416:
417: while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
418: {
419: if ((s_sin * x2) <= (y2 * s_cos))
420: break;
421:
422: y2 += 2;
423: g += ws * 4 * (y2 + 1);
424:
425: if (g > 0) /* Need to drop */
426: {
427: x2 -= 2;
428: g -= hs * 4 * x2;
429: }
430: }
431:
432: lx2 = x2;
433: ly2 = y2;
434:
435: lg = lx2 * (pt[0].y - pt[2].y) - ly2 * (pt[0].x - pt[2].x);
436: lg = (lx2 - 1) * (pt[0].y - pt[2].y) - (ly2 + 2) * (pt[0].x - pt[2].x) - lg;
437:
438: while (y2 < (2 * pt[2].y))
439: {
440: y2 += 2;
441: g += ws * 4 * (y2 + 1);
442:
443: if (g > 0) /* Need to drop */
444: {
445: x2 -= 2;
446: g -= hs * 4 * x2;
447: }
448:
449: ly2 += 2;
450: lg -= 2 * (pt[0].x - pt[2].x);
451:
452: if (lg < 0) /* Need to drop */
453: {
454: lx2 -= 2;
455: lg -= 2 * (pt[0].y - pt[2].y);
456: }
457:
458: y = (int) (y2 / 2);
459: for (x = (int) (lx2 / 2); x <= (int) (x2 / 2); x++)
460: {
461: gdImageSetPixel (im, ((flip_x) ? (cx - x) : (cx + x)),
462: ((flip_y) ? (cy - y) : (cy + y)), color);
463: }
464: }
465: }
466: if (conquer)
467: {
468: pt[0] = pt[4];
469: pt[2] = pt[5];
470: }
471: if (conquer || (((s_cos * hs) < (s_sin * ws)) && ((e_cos * hs) < (e_sin * ws))))
472: { /* This is the best bit... */
473: /* gradual line + ellipse */
474: /* go down & right from pt[2] to pt[0] */
475:
476: x2 = 0;
477: y2 = h; /* Starting point is exactly on ellipse */
478:
479: g = y2 - 1;
480: g = g * g * ws + 4 * hs - whs;
481:
482: while ((x2 * hs) < (y2 * ws))
483: {
484: x2 += 2;
485: g += hs * 4 * (x2 + 1);
486:
487: if (g > 0) /* Need to drop */
488: {
489: y2 -= 2;
490: g -= ws * 4 * y2;
491: }
492:
493: if ((e_sin * x2) >= (y2 * e_cos))
494: break;
495: }
496:
497: lx2 = x2;
498: ly2 = y2;
499:
500: lg = lx2 * (pt[0].y - pt[2].y) - ly2 * (pt[0].x - pt[2].x);
501: lg = (lx2 + 2) * (pt[0].y - pt[2].y) - (ly2 - 1) * (pt[0].x - pt[2].x) - lg;
502:
503: while (x2 < (2 * pt[0].x))
504: {
505: x2 += 2;
506: g += hs * 4 * (x2 + 1);
507:
508: if (g > 0) /* Need to drop */
509: {
510: y2 -= 2;
511: g -= ws * 4 * y2;
512: }
513:
514: lx2 += 2;
515: lg += 2 * (pt[0].y - pt[2].y);
516:
517: if (lg < 0) /* Need to drop */
518: {
519: ly2 -= 2;
520: lg += 2 * (pt[0].x - pt[2].x);
521: }
522:
523: x = (int) (x2 / 2);
524: for (y = (int) (ly2 / 2); y <= (int) (y2 / 2); y++)
525: {
526: gdImageSetPixel (im, ((flip_x) ? (cx - x) : (cx + x)),
527: ((flip_y) ? (cy - y) : (cy + y)), color);
528: }
529: }
530: }
531: }
532:
533: static gdPoint
534: gdArcClosest (int width, int height, int angle)
535: {
536: gdPoint pt;
537:
538: int flip_x = 0;
539: int flip_y = 0;
540:
541: long a_sin = 0;
542: long a_cos = 0;
543:
544: long w; /* a * 2 */
545: long h; /* b * 2 */
546:
547: long x2; /* x * 2 */
548: long y2; /* y * 2 */
549:
550: long ws; /* (a * 2)^2 */
551: long hs; /* (b * 2)^2 */
552:
553: long whs; /* (a * 2)^2 * (b * 2)^2 */
554:
555: long g; /* decision variable */
556:
557: w = (long) ((width & 1) ? (width + 1) : (width));
558: h = (long) ((height & 1) ? (height + 1) : (height));
559:
560: while (angle < 0)
561: angle += 360;
562: while (angle >= 360)
563: angle -= 360;
564:
565: if (angle == 0)
566: {
567: pt.x = w / 2;
568: pt.y = 0;
569: return (pt);
570: }
571: if (angle == 90)
572: {
573: pt.x = 0;
574: pt.y = h / 2;
575: return (pt);
576: }
577: if (angle == 180)
578: {
579: pt.x = -w / 2;
580: pt.y = 0;
581: return (pt);
582: }
583: if (angle == 270)
584: {
585: pt.x = 0;
586: pt.y = -h / 2;
587: return (pt);
588: }
589:
590: pt.x = 0;
591: pt.y = 0;
592:
593: if ((angle > 90) && (angle < 180))
594: {
595: angle = 180 - angle;
596: flip_x = 1;
597: }
598: if ((angle > 180) && (angle < 270))
599: {
600: angle = angle - 180;
601: flip_x = 1;
602: flip_y = 1;
603: }
604: if ((angle > 270) && (angle < 360))
605: {
606: angle = 360 - angle;
607: flip_y = 1;
608: }
609:
610: a_sin = (long) ((double) 32768 * sin ((double) angle * M_PI / (double) 180));
611: a_cos = (long) ((double) 32768 * cos ((double) angle * M_PI / (double) 180));
612:
613: ws = w * w;
614: hs = h * h;
615:
616: whs = 1;
617: while ((ws > 32768) || (hs > 32768))
618: {
619: ws = (ws + 1) / 2; /* Unfortunate limitations on integers makes */
620: hs = (hs + 1) / 2; /* drawing large ellipses problematic... */
621: whs *= 2;
622: }
623: while ((ws * hs) > (0x04000000L / whs))
624: {
625: ws = (ws + 1) / 2;
626: hs = (hs + 1) / 2;
627: whs *= 2;
628: }
629: whs *= ws * hs;
630:
631: if ((a_cos * hs) > (a_sin * ws))
632: {
633: x2 = w;
634: y2 = 0; /* Starting point is exactly on ellipse */
635:
636: g = x2 - 1;
637: g = g * g * hs + 4 * ws - whs;
638:
639: while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
640: {
641: y2 += 2;
642: g += ws * 4 * (y2 + 1);
643:
644: if (g > 0) /* Need to drop */
645: {
646: x2 -= 2;
647: g -= hs * 4 * x2;
648: }
649:
650: if ((a_sin * x2) <= (y2 * a_cos))
651: {
652: pt.x = (int) (x2 / 2);
653: pt.y = (int) (y2 / 2);
654: break;
655: }
656: }
657: }
658: else
659: {
660: x2 = 0;
661: y2 = h; /* Starting point is exactly on ellipse */
662:
663: g = y2 - 1;
664: g = g * g * ws + 4 * hs - whs;
665:
666: while ((x2 * hs) < (y2 * ws))
667: {
668: x2 += 2;
669: g += hs * 4 * (x2 + 1);
670:
671: if (g > 0) /* Need to drop */
672: {
673: y2 -= 2;
674: g -= ws * 4 * y2;
675: }
676:
677: if ((a_sin * x2) >= (y2 * a_cos))
678: {
679: pt.x = (int) (x2 / 2);
680: pt.y = (int) (y2 / 2);
681: break;
682: }
683: }
684: }
685:
686: if (flip_x)
687: pt.x = -pt.x;
688: if (flip_y)
689: pt.y = -pt.y;
690:
691: return (pt);
692: }
693:
694: #include "gd.h"
695: #include <string.h>
696: #include <math.h>
697:
698: #define WIDTH 500
699: #define HEIGHT 300
700:
701: int
702: main (int argc, char *argv[])
703: {
704: gdImagePtr im = gdImageCreate (WIDTH, HEIGHT);
705: int white = gdImageColorResolve (im, 0xFF, 0xFF, 0xFF), black = gdImageColorResolve (im, 0, 0, 0),
706: red = gdImageColorResolve (im, 0xFF, 0xA0, 0xA0);
707: FILE *out;
708:
709: /* filled arc - circle */
710: gdImageFilledArc (im, WIDTH / 5, HEIGHT / 4, 200, 200, 45, 90, red, gdPie);
711: gdImageArc (im, WIDTH / 5, HEIGHT / 4, 200, 200, 45, 90, black);
712:
713: /* filled arc - ellipse */
714: gdImageFilledArc (im, WIDTH / 2, HEIGHT / 4, 200, 150, 45, 90, red, gdPie);
715: gdImageArc (im, WIDTH / 2, HEIGHT / 4, 200, 150, 45, 90, black);
716:
717:
718: /* reference lines */
719: gdImageLine (im, 0, HEIGHT / 4, WIDTH, HEIGHT / 4, black);
720: gdImageLine (im, WIDTH / 5, 0, WIDTH / 5, HEIGHT, black);
721: gdImageLine (im, WIDTH / 2, 0, WIDTH / 2, HEIGHT, black);
722: gdImageLine (im, WIDTH / 2, HEIGHT / 4, WIDTH / 2 + 300, HEIGHT / 4 + 300, black);
723: gdImageLine (im, WIDTH / 5, HEIGHT / 4, WIDTH / 5 + 300, HEIGHT / 4 + 300, black);
724:
725: /* TBB: Write img to test/arctest.png */
726: out = fopen ("test/arctest.png", "wb");
727: if (!out)
728: {
729: php_gd_error("Can't create test/arctest.png");
730: exit (1);
731: }
732: gdImagePng (im, out);
733: fclose (out);
734: php_gd_error("Test image written to test/arctest.png");
735: /* Destroy it */
736: gdImageDestroy (im);
737:
738: return 0;
739: }
740:
741: #endif