root/ext/gd/libgd/gd_arc_f_buggy.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. gdImageFilledEllipse
  2. gdImageFilledArc
  3. gdArcClosest
  4. main
   1 /* This is potentially great stuff, but fails against the test
   2    program at the end. This would probably be much more
   3    efficient 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
/* [<][>][^][v][top][bottom][index][help] */