home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / gd201.zip / gd-2.0.1 / gd_arc_f_buggy.c < prev    next >
C/C++ Source or Header  |  2001-04-03  |  16KB  |  742 lines
  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.       fprintf (stderr, "Can't create test/arctest.png\n");
  730.       exit (1);
  731.     }
  732.   gdImagePng (im, out);
  733.   fclose (out);
  734.   fprintf (stderr, "Test image written to test/arctest.png\n");
  735.   /* Destroy it */
  736.   gdImageDestroy (im);
  737.  
  738.   return 0;
  739. }
  740.  
  741. #endif
  742.