Back to index

plt-scheme  4.2.1
Classes | Defines | Functions | Variables
gd.c File Reference
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"
#include "gdhelpers.h"

Go to the source code of this file.

Classes

struct  RGBType
struct  HWBType

Defines

#define gdImageBoundsSafeMacro(im, x, y)   (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2))))
#define ASC(ch)   ch
#define RETURN_HWB(h, w, b)   {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}
#define RETURN_RGB(r, g, b)   {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}
#define HWB_UNDEFINED   -1
#define SETUP_RGB(s, r, g, b)   {s.R = r/255.0; s.G = g/255.0; s.B = b/255.0;}
#define MIN(a, b)   ((a)<(b)?(a):(b))
#define MIN3(a, b, c)   ((a)<(b)?(MIN(a,c)):(MIN(b,c)))
#define MAX(a, b)   ((a)<(b)?(b):(a))
#define MAX3(a, b, c)   ((a)<(b)?(MAX(b,c)):(MAX(a,c)))
#define floor2(exp)   ((long) exp)

Functions

static void gdImageBrushApply (gdImagePtr im, int x, int y)
static void gdImageTileApply (gdImagePtr im, int x, int y)
static void gdImageAntiAliasedApply (gdImagePtr im, int x, int y)
static int gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
gdImagePtr gdImageCreate (int sx, int sy)
gdImagePtr gdImageCreateTrueColor (int sx, int sy)
void gdImageDestroy (gdImagePtr im)
int gdImageColorClosest (gdImagePtr im, int r, int g, int b)
int gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
static HWBTypeRGB_to_HWB (RGBType RGB, HWBType *HWB)
static float HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2)
int gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
int gdImageColorExact (gdImagePtr im, int r, int g, int b)
int gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
int gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
int gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
int gdImageColorResolve (gdImagePtr im, int r, int g, int b)
int gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
void gdImageColorDeallocate (gdImagePtr im, int color)
void gdImageColorTransparent (gdImagePtr im, int color)
void gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
static int clip_1d (int *x0, int *y0, int *x1, int *y1, int maxdim)
void gdImageSetPixel (gdImagePtr im, int x, int y, int color)
int gdImageGetPixel (gdImagePtr im, int x, int y)
void gdImageAABlend (gdImagePtr im)
void gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
static void dashedSet (gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert)
void gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
int gdImageBoundsSafe (gdImagePtr im, int x, int y)
void gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
void gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
void gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
void gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
static int strlen16 (unsigned short *s)
void gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
void gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
long lsqrt (long n)
void gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color)
void gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style)
void gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, int color)
void gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
void gdImageFill (gdImagePtr im, int x, int y, int color)
void gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
void gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
void gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
void gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
void gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
void gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
void gdImageCopyRotated (gdImagePtr dst, gdImagePtr src, double dstX, double dstY, int srcX, int srcY, int srcWidth, int srcHeight, int angle)
void gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
gdImagePtr gdImageCreateFromXbm (FILE *fd)
void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
int gdCompareInt (const void *a, const void *b)
void gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
void gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
void gdImageSetThickness (gdImagePtr im, int thickness)
void gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
void gdImageSetTile (gdImagePtr im, gdImagePtr tile)
void gdImageSetAntiAliased (gdImagePtr im, int c)
void gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend)
void gdImageInterlace (gdImagePtr im, int interlaceArg)
int gdImageCompare (gdImagePtr im1, gdImagePtr im2)
int gdAlphaBlend (int dst, int src)
void gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
void gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
void gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2)
void gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P)

Variables

int gdCosT []
int gdSinT []

Class Documentation

struct RGBType

Definition at line 263 of file gd.c.

Class Members
float B
float G
float R
struct HWBType

Definition at line 268 of file gd.c.

Class Members
float B
float H
float W

Define Documentation

#define ASC (   ch)    ch

Definition at line 24 of file gd.c.

#define floor2 (   exp)    ((long) exp)

Definition at line 2453 of file gd.c.

#define gdImageBoundsSafeMacro (   im,
  x,
  y 
)    (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2))))

Definition at line 15 of file gd.c.

#define HWB_UNDEFINED   -1

Definition at line 249 of file gd.c.

#define MAX (   a,
  b 
)    ((a)<(b)?(b):(a))

Definition at line 254 of file gd.c.

#define MAX3 (   a,
  b,
 
)    ((a)<(b)?(MAX(b,c)):(MAX(a,c)))

Definition at line 255 of file gd.c.

#define MIN (   a,
  b 
)    ((a)<(b)?(a):(b))

Definition at line 252 of file gd.c.

#define MIN3 (   a,
  b,
 
)    ((a)<(b)?(MIN(a,c)):(MIN(b,c)))

Definition at line 253 of file gd.c.

#define RETURN_HWB (   h,
  w,
  b 
)    {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}

Definition at line 247 of file gd.c.

#define RETURN_RGB (   r,
  g,
  b 
)    {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}

Definition at line 248 of file gd.c.

#define SETUP_RGB (   s,
  r,
  g,
  b 
)    {s.R = r/255.0; s.G = g/255.0; s.B = b/255.0;}

Definition at line 250 of file gd.c.


Function Documentation

static int clip_1d ( int x0,
int y0,
int x1,
int y1,
int  maxdim 
) [static]

Definition at line 666 of file gd.c.

{
  double m;                 /* gradient of line */
  if (*x0 < 0)
    {                       /* start of line is left of window */
      if (*x1 < 0)          /* as is the end, so the line never cuts the window */
       return 0;
      m = (*y1 - *y0) / (double) (*x1 - *x0);    /* calculate the slope of the line */
      /* adjust x0 to be on the left boundary (ie to be zero), and y0 to match */
      *y0 -= m * *x0;
      *x0 = 0;
      /* now, perhaps, adjust the far end of the line as well */
      if (*x1 > maxdim)
       {
         *y1 += m * (maxdim - *x1);
         *x1 = maxdim;
       }
      return 1;
    }
  if (*x0 > maxdim)
    {                       /* start of line is right of window -
                               complement of above */
      if (*x1 > maxdim)            /* as is the end, so the line misses the window */
       return 0;
      m = (*y1 - *y0) / (double) (*x1 - *x0);    /* calculate the slope of the line */
      *y0 += m * (maxdim - *x0);   /* adjust so point is on the right
                                      boundary */
      *x0 = maxdim;
      /* now, perhaps, adjust the end of the line */
      if (*x1 < 0)
       {
         *y1 -= m * *x1;
         *x1 = 0;
       }
      return 1;
    }
  /* the final case - the start of the line is inside the window */
  if (*x1 > maxdim)
    {                       /* other end is outside to the right */
      m = (*y1 - *y0) / (double) (*x1 - *x0);    /* calculate the slope of the line */
      *y1 += m * (maxdim - *x1);
      *x1 = maxdim;
      return 1;
    }
  if (*x1 < 0)
    {                       /* other end is outside to the left */
      m = (*y1 - *y0) / (double) (*x1 - *x0);    /* calculate the slope of the line */
      *y1 -= m * *x1;
      *x1 = 0;
      return 1;
    }
  /* only get here if both points are inside the window */
  return 1;
}

Here is the caller graph for this function:

static void dashedSet ( gdImagePtr  im,
int  x,
int  y,
int  color,
int onP,
int dashStepP,
int  wid,
int  vert 
) [static]

Definition at line 1460 of file gd.c.

{
  int dashStep = *dashStepP;
  int on = *onP;
  int w, wstart;

  dashStep++;
  if (dashStep == gdDashSize)
    {
      dashStep = 0;
      on = !on;
    }
  if (on)
    {
      if (vert)
       {
         wstart = y - wid / 2;
         for (w = wstart; w < wstart + wid; w++)
           gdImageSetPixel (im, x, w, color);
       }
      else
       {
         wstart = x - wid / 2;
         for (w = wstart; w < wstart + wid; w++)
           gdImageSetPixel (im, w, y, color);
       }
    }
  *dashStepP = dashStep;
  *onP = on;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdAlphaBlend ( int  dst,
int  src 
)

Definition at line 3040 of file gd.c.

{
  /* 2.0.12: TBB: alpha in the destination should be a 
     component of the result. Thanks to Frank Warmerdam for
     pointing out the issue. */
  return ((((gdTrueColorGetAlpha (src) *
            gdTrueColorGetAlpha (dst)) / gdAlphaMax) << 24) +
         ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
            gdTrueColorGetRed (src) / gdAlphaMax) +
           (gdTrueColorGetAlpha (src) *
            gdTrueColorGetRed (dst)) / gdAlphaMax) << 16) +
         ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
            gdTrueColorGetGreen (src) / gdAlphaMax) +
           (gdTrueColorGetAlpha (src) *
            gdTrueColorGetGreen (dst)) / gdAlphaMax) << 8) +
         (((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
           gdTrueColorGetBlue (src) / gdAlphaMax) +
          (gdTrueColorGetAlpha (src) *
           gdTrueColorGetBlue (dst)) / gdAlphaMax));
}

Here is the caller graph for this function:

int gdCompareInt ( const void a,
const void b 
)

Definition at line 2860 of file gd.c.

{
  return (*(const int *) a) - (*(const int *) b);
}

Here is the caller graph for this function:

Definition at line 1038 of file gd.c.

{
  float p_alpha, old_alpha;
  int color = im->AA_color, color_red, color_green, color_blue;
  int old_color, old_red, old_green, old_blue;
  int p_color, p_red, p_green, p_blue;
  int px, py;

  color_red = gdImageRed (im, color);
  color_green = gdImageGreen (im, color);
  color_blue = gdImageBlue (im, color);

  /* Impose the anti-aliased drawing on the image. */
  for (py = 0; py < im->sy; py++)
    {
      for (px = 0; px < im->sx; px++)
       {
         if (im->AA_opacity[py][px] != 0)
           {
             old_color = gdImageGetPixel (im, px, py);

             if ((old_color != color)
                && ((old_color != im->AA_dont_blend)
                    || (im->AA_opacity[py][px] == 255)))
              {
                /* Only blend with different colors that aren't the 
                 * dont_blend color. */
                p_alpha = (float) (im->AA_opacity[py][px]) / 255.0;
                old_alpha = 1.0 - p_alpha;

                if (p_alpha >= 1.0)
                  p_color = color;
                else
                  {
                    old_red = gdImageRed (im, old_color);
                    old_green = gdImageGreen (im, old_color);
                    old_blue = gdImageBlue (im, old_color);

                    p_red = (int) (((float) color_red * p_alpha) +
                                 ((float) old_red * old_alpha));
                    p_green = (int) (((float) color_green * p_alpha) +
                                   ((float) old_green * old_alpha));
                    p_blue = (int) (((float) color_blue * p_alpha) +
                                  ((float) old_blue * old_alpha));
                    p_color =
                     gdImageColorResolve (im, p_red, p_green, p_blue);
                  }
                gdImageSetPixel (im, px, py, p_color);
              }
           }
       }
      /* Clear the AA_opacity array behind us. */
      memset (im->AA_opacity[py], 0, im->sx);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageAlphaBlending ( gdImagePtr  im,
int  alphaBlendingArg 
)

Definition at line 3062 of file gd.c.

{
  im->alphaBlendingFlag = alphaBlendingArg;
}
static void gdImageAntiAliasedApply ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 938 of file gd.c.

{
  float p_dist, p_alpha;
  unsigned char opacity;

  /* 
   * Find the perpendicular distance from point C (px, py) to the line 
   * segment AB that is being drawn.  (Adapted from an algorithm from the
   * comp.graphics.algorithms FAQ.)
   */

  int LAC_2, LBC_2;

  int Ax_Cx = im->AAL_x1 - px;
  int Ay_Cy = im->AAL_y1 - py;

  int Bx_Cx = im->AAL_x2 - px;
  int By_Cy = im->AAL_y2 - py;
  /* 2.0.13: bounds check! AA_opacity is just as capable of
    overflowing as the main pixel array. Arne Jorgensen. 
    2.0.14: typo fixed. 2.0.15: moved down below declarations
    to satisfy non-C++ compilers. */
  if (!gdImageBoundsSafeMacro (im, px, py))
  {
    return;
  }
  /* Get the squares of the lengths of the segemnts AC and BC. */
  LAC_2 = (Ax_Cx * Ax_Cx) + (Ay_Cy * Ay_Cy);
  LBC_2 = (Bx_Cx * Bx_Cx) + (By_Cy * By_Cy);

  if (((im->AAL_LAB_2 + LAC_2) >= LBC_2) &&
      ((im->AAL_LAB_2 + LBC_2) >= LAC_2))
    {
      /* The two angles are acute.  The point lies inside the portion of the 
       * plane spanned by the line segment. */
      p_dist = fabs ((float) ((Ay_Cy * im->AAL_Bx_Ax) -
                           (Ax_Cx * im->AAL_By_Ay)) / im->AAL_LAB);
    }
  else
    {
      /* The point is past an end of the line segment.  It's length from the 
       * segment is the shorter of the lengths from the endpoints, but call
       * the distance -1, so as not to compute the alpha nor draw the pixel.
       */
      p_dist = -1;
    }

  if ((p_dist >= 0) && (p_dist <= (float) (im->thick)))
    {
      p_alpha = pow (1.0 - (p_dist / 1.5), 2);

      if (p_alpha > 0)
       {
         if (p_alpha >= 1)
           opacity = 255;
         else
           opacity = (unsigned char) (p_alpha * 255.0);
         if (!(im->AA_polygon) || (im->AA_opacity[py][px] < opacity))
           im->AA_opacity[py][px] = opacity;
       }
    }
}

Here is the caller graph for this function:

void gdImageArc ( gdImagePtr  im,
int  cx,
int  cy,
int  w,
int  h,
int  s,
int  e,
int  color 
)

Definition at line 1650 of file gd.c.

{
  gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill);
}

Here is the call graph for this function:

int gdImageBoundsSafe ( gdImagePtr  im,
int  x,
int  y 
)

Definition at line 1493 of file gd.c.

{
  return gdImageBoundsSafeMacro (im, x, y);
}
static void gdImageBrushApply ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 791 of file gd.c.

{
  int lx, ly;
  int hy;
  int hx;
  int x1, y1, x2, y2;
  int srcx, srcy;
  if (!im->brush)
    {
      return;
    }
  hy = gdImageSY (im->brush) / 2;
  y1 = y - hy;
  y2 = y1 + gdImageSY (im->brush);
  hx = gdImageSX (im->brush) / 2;
  x1 = x - hx;
  x2 = x1 + gdImageSX (im->brush);
  srcy = 0;
  if (im->trueColor)
    {
      if (im->brush->trueColor)
       {
         for (ly = y1; (ly < y2); ly++)
           {
             srcx = 0;
             for (lx = x1; (lx < x2); lx++)
              {
                int p;
                p = gdImageGetTrueColorPixel (im->brush, srcx, srcy);
                /* 2.0.9, Thomas Winzig: apply simple full transparency */
                if (p != gdImageGetTransparent (im->brush))
                  {
                    gdImageSetPixel (im, lx, ly, p);
                  }
                srcx++;
              }
             srcy++;
           }
       }
      else
       {
         /* 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger
            for pointing out the issue) */
         for (ly = y1; (ly < y2); ly++)
           {
             srcx = 0;
             for (lx = x1; (lx < x2); lx++)
              {
                int p, tc;
                p = gdImageGetPixel (im->brush, srcx, srcy);
                tc = gdImageGetTrueColorPixel (im->brush, srcx, srcy);
                /* 2.0.9, Thomas Winzig: apply simple full transparency */
                if (p != gdImageGetTransparent (im->brush))
                  {
                    gdImageSetPixel (im, lx, ly, tc);
                  }
                srcx++;
              }
             srcy++;
           }
       }
    }
  else
    {
      for (ly = y1; (ly < y2); ly++)
       {
         srcx = 0;
         for (lx = x1; (lx < x2); lx++)
           {
             int p;
             p = gdImageGetPixel (im->brush, srcx, srcy);
             /* Allow for non-square brushes! */
             if (p != gdImageGetTransparent (im->brush))
              {
                /* Truecolor brush. Very slow
                   on a palette destination. */
                if (im->brush->trueColor)
                  {
                    gdImageSetPixel (im, lx, ly,
                                   gdImageColorResolveAlpha (im,
                                                         gdTrueColorGetRed
                                                         (p),
                                                         gdTrueColorGetGreen
                                                         (p),
                                                         gdTrueColorGetBlue
                                                         (p),
                                                         gdTrueColorGetAlpha
                                                         (p)));
                  }
                else
                  {
                    gdImageSetPixel (im, lx, ly, im->brushColorMap[p]);
                  }
              }
             srcx++;
           }
         srcy++;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageChar ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
int  c,
int  color 
)

Definition at line 1499 of file gd.c.

{
  int cx, cy;
  int px, py;
  int fline;
  cx = 0;
  cy = 0;
#ifdef CHARSET_EBCDIC
  c = ASC (c);
#endif /*CHARSET_EBCDIC */
  if ((c < f->offset) || (c >= (f->offset + f->nchars)))
    {
      return;
    }
  fline = (c - f->offset) * f->h * f->w;
  for (py = y; (py < (y + f->h)); py++)
    {
      for (px = x; (px < (x + f->w)); px++)
       {
         if (f->data[fline + cy * f->w + cx])
           {
             gdImageSetPixel (im, px, py, color);
           }
         cx++;
       }
      cx = 0;
      cy++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageCharUp ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
int  c,
int  color 
)

Definition at line 1530 of file gd.c.

{
  int cx, cy;
  int px, py;
  int fline;
  cx = 0;
  cy = 0;
#ifdef CHARSET_EBCDIC
  c = ASC (c);
#endif /*CHARSET_EBCDIC */
  if ((c < f->offset) || (c >= (f->offset + f->nchars)))
    {
      return;
    }
  fline = (c - f->offset) * f->h * f->w;
  for (py = y; (py > (y - f->w)); py--)
    {
      for (px = x; (px < (x + f->h)); px++)
       {
         if (f->data[fline + cy * f->w + cx])
           {
             gdImageSetPixel (im, px, py, color);
           }
         cy++;
       }
      cy = 0;
      cx++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorAllocate ( gdImagePtr  im,
int  r,
int  g,
int  b 
)

Definition at line 444 of file gd.c.

{
  return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorAllocateAlpha ( gdImagePtr  im,
int  r,
int  g,
int  b,
int  a 
)

Definition at line 450 of file gd.c.

{
  int i;
  int ct = (-1);
  if (im->trueColor)
    {
      return gdTrueColorAlpha (r, g, b, a);
    }
  for (i = 0; (i < (im->colorsTotal)); i++)
    {
      if (im->open[i])
       {
         ct = i;
         break;
       }
    }
  if (ct == (-1))
    {
      ct = im->colorsTotal;
      if (ct == gdMaxColors)
       {
         return -1;
       }
      im->colorsTotal++;
    }
  im->red[ct] = r;
  im->green[ct] = g;
  im->blue[ct] = b;
  im->alpha[ct] = a;
  im->open[ct] = 0;
  return ct;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorClosest ( gdImagePtr  im,
int  r,
int  g,
int  b 
)

Definition at line 202 of file gd.c.

{
  return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorClosestAlpha ( gdImagePtr  im,
int  r,
int  g,
int  b,
int  a 
)

Definition at line 208 of file gd.c.

{
  int i;
  long rd, gd, bd, ad;
  int ct = (-1);
  int first = 1;
  long mindist = 0;
  if (im->trueColor)
    {
      return gdTrueColorAlpha (r, g, b, a);
    }
  for (i = 0; (i < (im->colorsTotal)); i++)
    {
      long dist;
      if (im->open[i])
       {
         continue;
       }
      rd = (im->red[i] - r);
      gd = (im->green[i] - g);
      bd = (im->blue[i] - b);
      /* gd 2.02: whoops, was - b (thanks to David Marwood) */
      ad = (im->blue[i] - a);
      dist = rd * rd + gd * gd + bd * bd + ad * ad;
      if (first || (dist < mindist))
       {
         mindist = dist;
         ct = i;
         first = 0;
       }
    }
  return ct;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorClosestHWB ( gdImagePtr  im,
int  r,
int  g,
int  b 
)

Definition at line 385 of file gd.c.

{
  int i;
  /* long rd, gd, bd; */
  int ct = (-1);
  int first = 1;
  float mindist = 0;
  if (im->trueColor)
    {
      return gdTrueColor (r, g, b);
    }
  for (i = 0; (i < (im->colorsTotal)); i++)
    {
      float dist;
      if (im->open[i])
       {
         continue;
       }
      dist = HWB_Diff (im->red[i], im->green[i], im->blue[i], r, g, b);
      if (first || (dist < mindist))
       {
         mindist = dist;
         ct = i;
         first = 0;
       }
    }
  return ct;
}

Here is the call graph for this function:

Definition at line 560 of file gd.c.

{
  if (im->trueColor)
    {
      return;
    }
  /* Mark it open. */
  im->open[color] = 1;
}
int gdImageColorExact ( gdImagePtr  im,
int  r,
int  g,
int  b 
)

Definition at line 415 of file gd.c.

{
  return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorExactAlpha ( gdImagePtr  im,
int  r,
int  g,
int  b,
int  a 
)

Definition at line 421 of file gd.c.

{
  int i;
  if (im->trueColor)
    {
      return gdTrueColorAlpha (r, g, b, a);
    }
  for (i = 0; (i < (im->colorsTotal)); i++)
    {
      if (im->open[i])
       {
         continue;
       }
      if ((im->red[i] == r) &&
         (im->green[i] == g) && (im->blue[i] == b) && (im->alpha[i] == a))
       {
         return i;
       }
    }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorResolve ( gdImagePtr  im,
int  r,
int  g,
int  b 
)

Definition at line 495 of file gd.c.

{
  return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gdImageColorResolveAlpha ( gdImagePtr  im,
int  r,
int  g,
int  b,
int  a 
)

Definition at line 501 of file gd.c.

{
  int c;
  int ct = -1;
  int op = -1;
  long rd, gd, bd, ad, dist;
  long mindist = 4 * 255 * 255;    /* init to max poss dist */
  if (im->trueColor)
    {
      return gdTrueColorAlpha (r, g, b, a);
    }

  for (c = 0; c < im->colorsTotal; c++)
    {
      if (im->open[c])
       {
         op = c;            /* Save open slot */
         continue;          /* Color not in use */
       }
      if (c == im->transparent)
       {
         /* don't ever resolve to the color that has
          * been designated as the transparent color */
         continue;
       }
      rd = (long) (im->red[c] - r);
      gd = (long) (im->green[c] - g);
      bd = (long) (im->blue[c] - b);
      ad = (long) (im->alpha[c] - a);
      dist = rd * rd + gd * gd + bd * bd + ad * ad;
      if (dist < mindist)
       {
         if (dist == 0)
           {
             return c;             /* Return exact match color */
           }
         mindist = dist;
         ct = c;
       }
    }
  /* no exact match.  We now know closest, but first try to allocate exact */
  if (op == -1)
    {
      op = im->colorsTotal;
      if (op == gdMaxColors)
       {                    /* No room for more colors */
         return ct;         /* Return closest available color */
       }
      im->colorsTotal++;
    }
  im->red[op] = r;
  im->green[op] = g;
  im->blue[op] = b;
  im->alpha[op] = a;
  im->open[op] = 0;
  return op;                /* Return newly allocated color */
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 571 of file gd.c.

{
  if (!im->trueColor)
    {
      if (im->transparent != -1)
       {
         im->alpha[im->transparent] = gdAlphaOpaque;
       }
      if (color != -1)
       {
         im->alpha[color] = gdAlphaTransparent;
       }
    }
  im->transparent = color;
}

Definition at line 2947 of file gd.c.

{
  int x, y;
  int p1, p2;
  int cmpStatus = 0;
  int sx, sy;

  if (im1->interlace != im2->interlace)
    {
      cmpStatus |= GD_CMP_INTERLACE;
    }

  if (im1->transparent != im2->transparent)
    {
      cmpStatus |= GD_CMP_TRANSPARENT;
    }

  if (im1->trueColor != im2->trueColor)
    {
      cmpStatus |= GD_CMP_TRUECOLOR;
    }

  sx = im1->sx;
  if (im1->sx != im2->sx)
    {
      cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE;
      if (im2->sx < im1->sx)
       {
         sx = im2->sx;
       }
    }

  sy = im1->sy;
  if (im1->sy != im2->sy)
    {
      cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE;
      if (im2->sy < im1->sy)
       {
         sy = im2->sy;
       }
    }

  if (im1->colorsTotal != im2->colorsTotal)
    {
      cmpStatus |= GD_CMP_NUM_COLORS;
    }

  for (y = 0; (y < sy); y++)
    {
      for (x = 0; (x < sx); x++)
       {
         p1 =
           im1->trueColor ? gdImageTrueColorPixel (im1, x,
                                              y) :
           gdImagePalettePixel (im1, x, y);
         p2 =
           im2->trueColor ? gdImageTrueColorPixel (im2, x,
                                              y) :
           gdImagePalettePixel (im2, x, y);
         if (gdImageRed (im1, p1) != gdImageRed (im2, p2))
           {
             cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
             break;
           }
         if (gdImageGreen (im1, p1) != gdImageGreen (im2, p2))
           {
             cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
             break;
           }
         if (gdImageBlue (im1, p1) != gdImageBlue (im2, p2))
           {
             cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
             break;
           }
#if 0
         /* Soon we'll add alpha channel to palettes */
         if (gdImageAlpha (im1, p1) != gdImageAlpha (im2, p2))
           {
             cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
             break;
           }
#endif
       }
      if (cmpStatus & GD_CMP_COLOR)
       {
         break;
       };
    }

  return cmpStatus;
}
void gdImageCopy ( gdImagePtr  dst,
gdImagePtr  src,
int  dstX,
int  dstY,
int  srcX,
int  srcY,
int  w,
int  h 
)

Definition at line 2015 of file gd.c.

{
  int c;
  int x, y;
  int tox, toy;
  int i;
  int colorMap[gdMaxColors];
  if (dst->trueColor)
    {
      /* 2.0: much easier when the destination is truecolor. */
      /* 2.0.10: needs a transparent-index check that is still valid if
         the source is not truecolor. Thanks to Frank Warmerdam. */
      for (y = 0; (y < h); y++)
       {
         for (x = 0; (x < w); x++)
           {
             int p = gdImageGetPixel (src, srcX + x, srcY + y);
             if (p != src->transparent)
              {
                int c = gdImageGetTrueColorPixel (src, srcX + x,
                                              srcY + y);
                gdImageSetPixel (dst, dstX + x, dstY + y, c);
              }
           }
       }
      return;
    }
  for (i = 0; (i < gdMaxColors); i++)
    {
      colorMap[i] = (-1);
    }
  toy = dstY;
  for (y = srcY; (y < (srcY + h)); y++)
    {
      tox = dstX;
      for (x = srcX; (x < (srcX + w)); x++)
       {
         int nc;
         int mapTo;
         c = gdImageGetPixel (src, x, y);
         /* Added 7/24/95: support transparent copies */
         if (gdImageGetTransparent (src) == c)
           {
             tox++;
             continue;
           }
         /* Have we established a mapping for this color? */
         if (src->trueColor)
           {
             /* 2.05: remap to the palette available in the
                destination image. This is slow and
                works badly, but it beats crashing! Thanks 
                to Padhrig McCarthy. */
             mapTo = gdImageColorResolveAlpha (dst,
                                          gdTrueColorGetRed (c),
                                          gdTrueColorGetGreen (c),
                                          gdTrueColorGetBlue (c),
                                          gdTrueColorGetAlpha (c));
           }
         else if (colorMap[c] == (-1))
           {
             /* If it's the same image, mapping is trivial */
             if (dst == src)
              {
                nc = c;
              }
             else
              {
                /* Get best match possible. This
                   function never returns error. */
                nc = gdImageColorResolveAlpha (dst,
                                           src->red[c], src->green[c],
                                           src->blue[c], src->alpha[c]);
              }
             colorMap[c] = nc;
             mapTo = colorMap[c];
           }
         else
           {
             mapTo = colorMap[c];
           }
         gdImageSetPixel (dst, tox, toy, mapTo);
         tox++;
       }
      toy++;
    }
}

Here is the call graph for this function:

void gdImageCopyMerge ( gdImagePtr  dst,
gdImagePtr  src,
int  dstX,
int  dstY,
int  srcX,
int  srcY,
int  w,
int  h,
int  pct 
)

Definition at line 2107 of file gd.c.

{

  int c, dc;
  int x, y;
  int tox, toy;
  int ncR, ncG, ncB;
  toy = dstY;
  for (y = srcY; (y < (srcY + h)); y++)
    {
      tox = dstX;
      for (x = srcX; (x < (srcX + w)); x++)
       {
         int nc;
         c = gdImageGetPixel (src, x, y);
         /* Added 7/24/95: support transparent copies */
         if (gdImageGetTransparent (src) == c)
           {
             tox++;
             continue;
           }
         /* If it's the same image, mapping is trivial */
         if (dst == src)
           {
             nc = c;
           }
         else
           {
             dc = gdImageGetPixel (dst, tox, toy);

             ncR = gdImageRed (src, c) * (pct / 100.0)
              + gdImageRed (dst, dc) * ((100 - pct) / 100.0);
             ncG = gdImageGreen (src, c) * (pct / 100.0)
              + gdImageGreen (dst, dc) * ((100 - pct) / 100.0);
             ncB = gdImageBlue (src, c) * (pct / 100.0)
              + gdImageBlue (dst, dc) * ((100 - pct) / 100.0);

             /* Find a reasonable color */
             nc = gdImageColorResolve (dst, ncR, ncG, ncB);
           }
         gdImageSetPixel (dst, tox, toy, nc);
         tox++;
       }
      toy++;
    }
}

Here is the call graph for this function:

void gdImageCopyMergeGray ( gdImagePtr  dst,
gdImagePtr  src,
int  dstX,
int  dstY,
int  srcX,
int  srcY,
int  w,
int  h,
int  pct 
)

Definition at line 2158 of file gd.c.

{

  int c, dc;
  int x, y;
  int tox, toy;
  int ncR, ncG, ncB;
  float g;
  toy = dstY;
  for (y = srcY; (y < (srcY + h)); y++)
    {
      tox = dstX;
      for (x = srcX; (x < (srcX + w)); x++)
       {
         int nc;
         c = gdImageGetPixel (src, x, y);
         /* Added 7/24/95: support transparent copies */
         if (gdImageGetTransparent (src) == c)
           {
             tox++;
             continue;
           }
         /* 
          * If it's the same image, mapping is NOT trivial since we 
          * merge with greyscale target, but if pct is 100, the grey 
          * value is not used, so it becomes trivial. pjw 2.0.12. 
          */
         if (dst == src && pct == 100)
           {
             nc = c;
           }
         else
           {
             dc = gdImageGetPixel (dst, tox, toy);
             g = 0.29900 * dst->red[dc]
              + 0.58700 * dst->green[dc] + 0.11400 * dst->blue[dc];

             ncR = gdImageRed (src, c) * (pct / 100.0)
              + g * ((100 - pct) / 100.0);
             ncG = gdImageGreen (src, c) * (pct / 100.0)
              + g * ((100 - pct) / 100.0);
             ncB = gdImageBlue (src, c) * (pct / 100.0)
              + g * ((100 - pct) / 100.0);

             /* First look for an exact match */
             nc = gdImageColorExact (dst, ncR, ncG, ncB);
             if (nc == (-1))
              {
                /* No, so try to allocate it */
                nc = gdImageColorAllocate (dst, ncR, ncG, ncB);
                /* If we're out of colors, go for the
                   closest color */
                if (nc == (-1))
                  {
                    nc = gdImageColorClosest (dst, ncR, ncG, ncB);
                  }
              }
           }
         gdImageSetPixel (dst, tox, toy, nc);
         tox++;
       }
      toy++;
    }
}

Here is the call graph for this function:

void gdImageCopyResampled ( gdImagePtr  dst,
gdImagePtr  src,
int  dstX,
int  dstY,
int  srcX,
int  srcY,
int  dstW,
int  dstH,
int  srcW,
int  srcH 
)

Definition at line 2457 of file gd.c.

{
  int x, y;
  if (!dst->trueColor)
    {
      gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH,
                       srcW, srcH);
      return;
    }
  for (y = dstY; (y < dstY + dstH); y++)
    {
      for (x = dstX; (x < dstX + dstW); x++)
       {
         float sy1, sy2, sx1, sx2;
         float sx, sy;
         float spixels = 0;
         float red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
         sy1 = ((float) y - (float) dstY) * (float) srcH / (float) dstH;
         sy2 = ((float) (y + 1) - (float) dstY) * (float) srcH /
           (float) dstH;
         sy = sy1;
         do
           {
             float yportion;
             if (floor2 (sy) == floor2 (sy1))
              {
                yportion = 1.0 - (sy - floor2 (sy));
                if (yportion > sy2 - sy1)
                  {
                    yportion = sy2 - sy1;
                  }
                sy = floor2 (sy);
              }
             else if (sy == floor2 (sy2))
              {
                yportion = sy2 - floor2 (sy2);
              }
             else
              {
                yportion = 1.0;
              }
             sx1 = ((float) x - (float) dstX) * (float) srcW / dstW;
             sx2 = ((float) (x + 1) - (float) dstX) * (float) srcW / dstW;
             sx = sx1;
             do
              {
                float xportion;
                float pcontribution;
                int p;
                if (floor2 (sx) == floor2 (sx1))
                  {
                    xportion = 1.0 - (sx - floor2 (sx));
                    if (xportion > sx2 - sx1)
                     {
                       xportion = sx2 - sx1;
                     }
                    sx = floor2 (sx);
                  }
                else if (sx == floor2 (sx2))
                  {
                    xportion = sx2 - floor2 (sx2);
                  }
                else
                  {
                    xportion = 1.0;
                  }
                pcontribution = xportion * yportion;
                /* 2.08: previously srcX and srcY were ignored. 
                   Andrew Pattison */
                p = gdImageGetTrueColorPixel (src,
                                          (int) sx + srcX,
                                          (int) sy + srcY);
                red += gdTrueColorGetRed (p) * pcontribution;
                green += gdTrueColorGetGreen (p) * pcontribution;
                blue += gdTrueColorGetBlue (p) * pcontribution;
                alpha += gdTrueColorGetAlpha (p) * pcontribution;
                spixels += xportion * yportion;
                sx += 1.0;
              }
             while (sx < sx2);
             sy += 1.0;
           }
         while (sy < sy2);
         if (spixels != 0.0)
           {
             red /= spixels;
             green /= spixels;
             blue /= spixels;
             alpha /= spixels;
           }
         /* Clamping to allow for rounding errors above */
         if (red > 255.0)
           {
             red = 255.0;
           }
         if (green > 255.0)
           {
             green = 255.0;
           }
         if (blue > 255.0)
           {
             blue = 255.0;
           }
         if (alpha > gdAlphaMax)
           {
             alpha = gdAlphaMax;
           }
         gdImageSetPixel (dst,
                        x, y,
                        gdTrueColorAlpha ((int) red,
                                        (int) green,
                                        (int) blue, (int) alpha));
       }
    }
}

Here is the call graph for this function:

void gdImageCopyResized ( gdImagePtr  dst,
gdImagePtr  src,
int  dstX,
int  dstY,
int  srcX,
int  srcY,
int  dstW,
int  dstH,
int  srcW,
int  srcH 
)

Definition at line 2225 of file gd.c.

{
  int c;
  int x, y;
  int tox, toy;
  int ydest;
  int i;
  int colorMap[gdMaxColors];
  /* Stretch vectors */
  int *stx;
  int *sty;
  /* We only need to use floating point to determine the correct
     stretch vector for one line's worth. */
  double accum;
  stx = (int *) gdMalloc (sizeof (int) * srcW);
  sty = (int *) gdMalloc (sizeof (int) * srcH);
  accum = 0;
  for (i = 0; (i < srcW); i++)
    {
      int got;
      accum += (double) dstW / (double) srcW;
      got = (int) floor (accum);
      stx[i] = got;
      accum -= got;
    }
  accum = 0;
  for (i = 0; (i < srcH); i++)
    {
      int got;
      accum += (double) dstH / (double) srcH;
      got = (int) floor (accum);
      sty[i] = got;
      accum -= got;
    }
  for (i = 0; (i < gdMaxColors); i++)
    {
      colorMap[i] = (-1);
    }
  toy = dstY;
  for (y = srcY; (y < (srcY + srcH)); y++)
    {
      for (ydest = 0; (ydest < sty[y - srcY]); ydest++)
       {
         tox = dstX;
         for (x = srcX; (x < (srcX + srcW)); x++)
           {
             int nc = 0;
             int mapTo;
             if (!stx[x - srcX])
              {
                continue;
              }
             if (dst->trueColor)
              {
                /* 2.0.9: Thorben Kundinger: Maybe the source image is not 
                   a truecolor image */
                if (!src->trueColor)
                  {
                    int tmp = gdImageGetPixel (src, x, y);
                    mapTo = gdImageGetTrueColorPixel (src, x, y);
                    if (gdImageGetTransparent (src) == tmp)
                     {
                       tox++;
                       continue;
                     }
                  }
                else
                  {
                    /* TK: old code follows */
                    mapTo = gdImageGetTrueColorPixel (src, x, y);
                    /* Added 7/24/95: support transparent copies */
                    if (gdImageGetTransparent (src) == mapTo)
                     {
                       tox++;
                       continue;
                     }
                  }
              }
             else
              {
                c = gdImageGetPixel (src, x, y);
                /* Added 7/24/95: support transparent copies */
                if (gdImageGetTransparent (src) == c)
                  {
                    tox += stx[x - srcX];
                    continue;
                  }
                if (src->trueColor)
                  {
                    /* Remap to the palette available in the
                       destination image. This is slow and
                       works badly. */
                    mapTo = gdImageColorResolveAlpha (dst,
                                                 gdTrueColorGetRed (c),
                                                 gdTrueColorGetGreen
                                                 (c),
                                                 gdTrueColorGetBlue
                                                 (c),
                                                 gdTrueColorGetAlpha
                                                 (c));
                  }
                else
                  {
                    /* Have we established a mapping for this color? */
                    if (colorMap[c] == (-1))
                     {
                       /* If it's the same image, mapping is trivial */
                       if (dst == src)
                         {
                           nc = c;
                         }
                       else
                         {
                           /* Find or create the best match */
                           /* 2.0.5: can't use gdTrueColorGetRed, etc with palette */
                           nc = gdImageColorResolveAlpha (dst,
                                                      gdImageRed (src,
                                                                c),
                                                      gdImageGreen
                                                      (src, c),
                                                      gdImageBlue (src,
                                                                 c),
                                                      gdImageAlpha
                                                      (src, c));
                         }
                       colorMap[c] = nc;
                     }
                    mapTo = colorMap[c];
                  }
              }
             for (i = 0; (i < stx[x - srcX]); i++)
              {
                gdImageSetPixel (dst, tox, toy, mapTo);
                tox++;
              }
           }
         toy++;
       }
    }
  gdFree (stx);
  gdFree (sty);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageCopyRotated ( gdImagePtr  dst,
gdImagePtr  src,
double  dstX,
double  dstY,
int  srcX,
int  srcY,
int  srcWidth,
int  srcHeight,
int  angle 
)

Definition at line 2379 of file gd.c.

{
  double dx, dy;
  double radius = sqrt (srcWidth * srcWidth + srcHeight * srcHeight);
  double aCos = cos (angle * .0174532925);
  double aSin = sin (angle * .0174532925);
  double scX = srcX + ((double) srcWidth) / 2;
  double scY = srcY + ((double) srcHeight) / 2;
  int cmap[gdMaxColors];
  int i;
  for (i = 0; (i < gdMaxColors); i++)
    {
      cmap[i] = (-1);
    }
  for (dy = dstY - radius; (dy <= dstY + radius); dy++)
    {
      for (dx = dstX - radius; (dx <= dstX + radius); dx++)
       {
         double sxd = (dx - dstX) * aCos - (dy - dstY) * aSin;
         double syd = (dy - dstY) * aCos + (dx - dstX) * aSin;
         int sx = sxd + scX;
         int sy = syd + scY;
         if ((sx >= srcX) && (sx < srcX + srcWidth) &&
             (sy >= srcY) && (sy < srcY + srcHeight))
           {
             int c = gdImageGetPixel (src, sx, sy);
             if (!src->trueColor)
              {
                /* Use a table to avoid an expensive
                   lookup on every single pixel */
                if (cmap[c] == -1)
                  {
                    cmap[c] = gdImageColorResolveAlpha (dst,
                                                   gdImageRed (src, c),
                                                   gdImageGreen (src,
                                                               c),
                                                   gdImageBlue (src,
                                                               c),
                                                   gdImageAlpha (src,
                                                               c));
                  }
                gdImageSetPixel (dst, dx, dy, cmap[c]);
              }
             else
              {
                gdImageSetPixel (dst,
                               dx, dy,
                               gdImageColorResolveAlpha (dst,
                                                      gdImageRed (src,
                                                                c),
                                                      gdImageGreen
                                                      (src, c),
                                                      gdImageBlue (src,
                                                                 c),
                                                      gdImageAlpha
                                                      (src, c)));
              }
           }
       }
    }
}

Here is the call graph for this function:

gdImagePtr gdImageCreate ( int  sx,
int  sy 
)

Definition at line 73 of file gd.c.

{
  int i;
  gdImagePtr im;
  im = (gdImage *) gdMalloc (sizeof (gdImage));
  memset (im, 0, sizeof (gdImage));
  /* Row-major ever since gd 1.3 */
  im->pixels = (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy);
  im->AA_opacity =
    (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy);
  im->polyInts = 0;
  im->polyAllocated = 0;
  im->brush = 0;
  im->tile = 0;
  im->style = 0;
  for (i = 0; (i < sy); i++)
    {
      /* Row-major ever since gd 1.3 */
      im->pixels[i] = (unsigned char *) gdCalloc (sx, sizeof (unsigned char));
      im->AA_opacity[i] =
       (unsigned char *) gdCalloc (sx, sizeof (unsigned char));
    }
  im->sx = sx;
  im->sy = sy;
  im->colorsTotal = 0;
  im->transparent = (-1);
  im->interlace = 0;
  im->thick = 1;
  im->AA = 0;
  im->AA_polygon = 0;
  for (i = 0; (i < gdMaxColors); i++)
    {
      im->open[i] = 1;
      im->red[i] = 0;
      im->green[i] = 0;
      im->blue[i] = 0;
    };
  im->trueColor = 0;
  im->tpixels = 0;
  im->cx1 = 0;
  im->cy1 = 0;
  im->cx2 = im->sx - 1;
  im->cy2 = im->sy - 1;
  return im;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2578 of file gd.c.

{
  gdImagePtr im;
  int bit;
  int w, h;
  int bytes;
  int ch;
  int i, x, y;
  char *sp;
  char s[161];
  if (!fgets (s, 160, fd))
    {
      return 0;
    }
  sp = &s[0];
  /* Skip #define */
  sp = strchr (sp, ' ');
  if (!sp)
    {
      return 0;
    }
  /* Skip width label */
  sp++;
  sp = strchr (sp, ' ');
  if (!sp)
    {
      return 0;
    }
  /* Get width */
  w = atoi (sp + 1);
  if (!w)
    {
      return 0;
    }
  if (!fgets (s, 160, fd))
    {
      return 0;
    }
  sp = s;
  /* Skip #define */
  sp = strchr (sp, ' ');
  if (!sp)
    {
      return 0;
    }
  /* Skip height label */
  sp++;
  sp = strchr (sp, ' ');
  if (!sp)
    {
      return 0;
    }
  /* Get height */
  h = atoi (sp + 1);
  if (!h)
    {
      return 0;
    }
  /* Skip declaration line */
  if (!fgets (s, 160, fd))
    {
      return 0;
    }
  bytes = (w * h / 8) + 1;
  im = gdImageCreate (w, h);
  gdImageColorAllocate (im, 255, 255, 255);
  gdImageColorAllocate (im, 0, 0, 0);
  x = 0;
  y = 0;
  for (i = 0; (i < bytes); i++)
    {
      char h[3];
      unsigned int b;
      /* Skip spaces, commas, CRs, 0x */
      while (1)
       {
         ch = getc (fd);
         if (ch == EOF)
           {
             goto fail;
           }
         if (ch == 'x')
           {
             break;
           }
       }
      /* Get hex value */
      ch = getc (fd);
      if (ch == EOF)
       {
         goto fail;
       }
      h[0] = ch;
      ch = getc (fd);
      if (ch == EOF)
       {
         goto fail;
       }
      h[1] = ch;
      h[2] = '\0';
      sscanf (h, "%x", &b);
      for (bit = 1; (bit <= 128); (bit = bit << 1))
       {
         gdImageSetPixel (im, x++, y, (b & bit) ? 1 : 0);
         if (x == im->sx)
           {
             x = 0;
             y++;
             if (y == im->sy)
              {
                return im;
              }
             /* Fix 8/8/95 */
             break;
           }
       }
    }
  /* Shouldn't happen */
  fprintf (stderr, "Error: bug in gdImageCreateFromXbm!\n");
  return 0;
fail:
  gdImageDestroy (im);
  return 0;
}

Here is the call graph for this function:

Definition at line 120 of file gd.c.

{
  int i;
  gdImagePtr im;
  im = (gdImage *) gdMalloc (sizeof (gdImage));
  memset (im, 0, sizeof (gdImage));
  im->tpixels = (int **) gdMalloc (sizeof (int *) * sy);
  im->AA_opacity =
    (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy);
  im->polyInts = 0;
  im->polyAllocated = 0;
  im->brush = 0;
  im->tile = 0;
  im->style = 0;
  for (i = 0; (i < sy); i++)
    {
      im->tpixels[i] = (int *) gdCalloc (sx, sizeof (int));
      im->AA_opacity[i] =
       (unsigned char *) gdCalloc (sx, sizeof (unsigned char));
    }
  im->sx = sx;
  im->sy = sy;
  im->transparent = (-1);
  im->interlace = 0;
  im->trueColor = 1;
  /* 2.0.2: alpha blending is now on by default, and saving of alpha is
     off by default. This allows font antialiasing to work as expected
     on the first try in JPEGs -- quite important -- and also allows 
     for smaller PNGs when saving of alpha channel is not really 
     desired, which it usually isn't! */
  im->saveAlphaFlag = 0;
  im->alphaBlendingFlag = 1;
  im->thick = 1;
  im->AA = 0;
  im->AA_polygon = 0;
  im->cx1 = 0;
  im->cy1 = 0;
  im->cx2 = im->sx - 1;
  im->cy2 = im->sy - 1;
  return im;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageDashedLine ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2,
int  color 
)

Definition at line 1309 of file gd.c.

{
  int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
  int dashStep = 0;
  int on = 1;
  int wid;
  int vert;
  int thick = im->thick;

  dx = abs (x2 - x1);
  dy = abs (y2 - y1);
  if (dy <= dx)
    {
      /* More-or-less horizontal. use wid for vertical stroke */
      /* 2.0.12: Michael Schwartz: divide rather than multiply;
         TBB: but watch out for /0! */
      double as = sin (atan2 (dy, dx));
      if (as != 0)
       {
         wid = thick / as;
       }
      else
       {
         wid = 1;
       }
      vert = 1;

      d = 2 * dy - dx;
      incr1 = 2 * dy;
      incr2 = 2 * (dy - dx);
      if (x1 > x2)
       {
         x = x2;
         y = y2;
         ydirflag = (-1);
         xend = x1;
       }
      else
       {
         x = x1;
         y = y1;
         ydirflag = 1;
         xend = x2;
       }
      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
      if (((y2 - y1) * ydirflag) > 0)
       {
         while (x < xend)
           {
             x++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                y++;
                d += incr2;
              }
             dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
           }
       }
      else
       {
         while (x < xend)
           {
             x++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                y--;
                d += incr2;
              }
             dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
           }
       }
    }
  else
    {
      /* 2.0.12: Michael Schwartz: divide rather than multiply;
         TBB: but watch out for /0! */
      double as = sin (atan2 (dy, dx));
      if (as != 0)
       {
         wid = thick / as;
       }
      else
       {
         wid = 1;
       }
      vert = 0;

      d = 2 * dx - dy;
      incr1 = 2 * dx;
      incr2 = 2 * (dx - dy);
      if (y1 > y2)
       {
         y = y2;
         x = x2;
         yend = y1;
         xdirflag = (-1);
       }
      else
       {
         y = y1;
         x = x1;
         yend = y2;
         xdirflag = 1;
       }
      dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
      if (((x2 - x1) * xdirflag) > 0)
       {
         while (y < yend)
           {
             y++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                x++;
                d += incr2;
              }
             dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
           }
       }
      else
       {
         while (y < yend)
           {
             y++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                x--;
                d += incr2;
              }
             dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
           }
       }
    }
}

Here is the call graph for this function:

Definition at line 163 of file gd.c.

{
  int i;
  if (im->pixels)
    {
      for (i = 0; (i < im->sy); i++)
       {
         gdFree (im->pixels[i]);
       }
      gdFree (im->pixels);
    }
  if (im->tpixels)
    {
      for (i = 0; (i < im->sy); i++)
       {
         gdFree (im->tpixels[i]);
       }
      gdFree (im->tpixels);
    }
  if (im->AA_opacity)
    {
      for (i = 0; (i < im->sy); i++)
       {
         gdFree (im->AA_opacity[i]);
       }
      gdFree (im->AA_opacity);
    }
  if (im->polyInts)
    {
      gdFree (im->polyInts);
    }
  if (im->style)
    {
      gdFree (im->style);
    }
  gdFree (im);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageFill ( gdImagePtr  im,
int  x,
int  y,
int  color 
)

Definition at line 1828 of file gd.c.

{
  int lastBorder;
  int old;
  int leftLimit, rightLimit;
  int i;
  old = gdImageGetPixel (im, x, y);
  if (color == gdTiled)
    {
      /* Tile fill -- got to watch out! */
      int p, tileColor;
      int srcx, srcy;
      if (!im->tile)
       {
         return;
       }
      /* Refuse to flood-fill with a transparent pattern --
         I can't do it without allocating another image */
      if (gdImageGetTransparent (im->tile) != (-1))
       {
         return;
       }
      srcx = x % gdImageSX (im->tile);
      srcy = y % gdImageSY (im->tile);
      p = gdImageGetPixel (im->tile, srcx, srcy);
      if (im->trueColor)
       {
         tileColor = p;
       }
      else
       {
         if (im->tile->trueColor)
           {
             tileColor = gdImageColorResolveAlpha (im,
                                              gdTrueColorGetRed (p),
                                              gdTrueColorGetGreen (p),
                                              gdTrueColorGetBlue (p),
                                              gdTrueColorGetAlpha (p));
           }
         else
           {
             tileColor = im->tileColorMap[p];
           }
       }
      if (old == tileColor)
       {
         /* Nothing to be done */
         return;
       }
    }
  else
    {
      if (old == color)
       {
         /* Nothing to be done */
         return;
       }
    }
  /* Seek left */
  leftLimit = (-1);
  for (i = x; (i >= 0); i--)
    {
      if (gdImageGetPixel (im, i, y) != old)
       {
         break;
       }
      gdImageSetPixel (im, i, y, color);
      leftLimit = i;
    }
  if (leftLimit == (-1))
    {
      return;
    }
  /* Seek right */
  rightLimit = x;
  for (i = (x + 1); (i < im->sx); i++)
    {
      if (gdImageGetPixel (im, i, y) != old)
       {
         break;
       }
      gdImageSetPixel (im, i, y, color);
      rightLimit = i;
    }
  /* Look at lines above and below and start paints */
  /* Above */
  if (y > 0)
    {
      lastBorder = 1;
      for (i = leftLimit; (i <= rightLimit); i++)
       {
         int c;
         c = gdImageGetPixel (im, i, y - 1);
         if (lastBorder)
           {
             if (c == old)
              {
                gdImageFill (im, i, y - 1, color);
                lastBorder = 0;
              }
           }
         else if (c != old)
           {
             lastBorder = 1;
           }
       }
    }
  /* Below */
  if (y < ((im->sy) - 1))
    {
      lastBorder = 1;
      for (i = leftLimit; (i <= rightLimit); i++)
       {
         int c;
         c = gdImageGetPixel (im, i, y + 1);
         if (lastBorder)
           {
             if (c == old)
              {
                gdImageFill (im, i, y + 1, color);
                lastBorder = 0;
              }
           }
         else if (c != old)
           {
             lastBorder = 1;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageFilledArc ( gdImagePtr  im,
int  cx,
int  cy,
int  w,
int  h,
int  s,
int  e,
int  color,
int  style 
)

Definition at line 1657 of file gd.c.

{
  gdPoint pts[3];
  int i;
  int lx = 0, ly = 0;
  int fx = 0, fy = 0;
  while (e < s)
    {
      e += 360;
    }
  for (i = s; (i <= e); i++)
    {
      int x, y;
      x = ((long) gdCosT[i % 360] * (long) w / (2 * 1024)) + cx;
      y = ((long) gdSinT[i % 360] * (long) h / (2 * 1024)) + cy;
      if (i != s)
       {
         if (!(style & gdChord))
           {
             if (style & gdNoFill)
              {
                gdImageLine (im, lx, ly, x, y, color);
              }
             else
              {
                /* This is expensive! */
                pts[0].x = lx;
                pts[0].y = ly;
                pts[1].x = x;
                pts[1].y = y;
                pts[2].x = cx;
                pts[2].y = cy;
                gdImageFilledPolygon (im, pts, 3, color);
              }
           }
       }
      else
       {
         fx = x;
         fy = y;
       }
      lx = x;
      ly = y;
    }
  if (style & gdChord)
    {
      if (style & gdNoFill)
       {
         if (style & gdEdged)
           {
             gdImageLine (im, cx, cy, lx, ly, color);
             gdImageLine (im, cx, cy, fx, fy, color);
           }
         gdImageLine (im, fx, fy, lx, ly, color);
       }
      else
       {
         pts[0].x = fx;
         pts[0].y = fy;
         pts[1].x = lx;
         pts[1].y = ly;
         pts[2].x = cx;
         pts[2].y = cy;
         gdImageFilledPolygon (im, pts, 3, color);
       }
    }
  else
    {
      if (style & gdNoFill)
       {
         if (style & gdEdged)
           {
             gdImageLine (im, cx, cy, lx, ly, color);
             gdImageLine (im, cx, cy, fx, fy, color);
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageFilledEllipse ( gdImagePtr  im,
int  cx,
int  cy,
int  w,
int  h,
int  color 
)

Definition at line 1738 of file gd.c.

{
  gdImageFilledArc (im, cx, cy, w, h, 0, 360, color, gdPie);
}

Here is the call graph for this function:

Definition at line 2746 of file gd.c.

{
  int i;
  int y;
  int miny, maxy;
  int x1, y1;
  int x2, y2;
  int ind1, ind2;
  int ints;
  int fill_color;
  if (!n)
    {
      return;
    }

  if (c == gdAntiAliased)
    fill_color = im->AA_color;
  else
    fill_color = c;

  if (!im->polyAllocated)
    {
      im->polyInts = (int *) gdMalloc (sizeof (int) * n);
      im->polyAllocated = n;
    }
  if (im->polyAllocated < n)
    {
      while (im->polyAllocated < n)
       {
         im->polyAllocated *= 2;
       }
      im->polyInts = (int *) gdRealloc (im->polyInts,
                                   sizeof (int) * im->polyAllocated);
    }
  miny = p[0].y;
  maxy = p[0].y;
  for (i = 1; (i < n); i++)
    {
      if (p[i].y < miny)
       {
         miny = p[i].y;
       }
      if (p[i].y > maxy)
       {
         maxy = p[i].y;
       }
    }
  /* Fix in 1.3: count a vertex only once */
  for (y = miny; (y <= maxy); y++)
    {
/*1.4           int interLast = 0; */
/*              int dirLast = 0; */
/*              int interFirst = 1; */
      ints = 0;
      for (i = 0; (i < n); i++)
       {
         if (!i)
           {
             ind1 = n - 1;
             ind2 = 0;
           }
         else
           {
             ind1 = i - 1;
             ind2 = i;
           }
         y1 = p[ind1].y;
         y2 = p[ind2].y;
         if (y1 < y2)
           {
             x1 = p[ind1].x;
             x2 = p[ind2].x;
           }
         else if (y1 > y2)
           {
             y2 = p[ind1].y;
             y1 = p[ind2].y;
             x2 = p[ind1].x;
             x1 = p[ind2].x;
           }
         else
           {
             continue;
           }

         /* Do the following math as float intermediately, and round to ensure
          * that Polygon and FilledPolygon for the same set of points have the
          * same footprint. */
         if ((y >= y1) && (y < y2))
           {
             im->polyInts[ints++] = (float) ((y - y1) * (x2 - x1)) /
              (float) (y2 - y1) + 0.5 + x1;
           }
         else if ((y == maxy) && (y > y1) && (y <= y2))
           {
             im->polyInts[ints++] = (float) ((y - y1) * (x2 - x1)) /
              (float) (y2 - y1) + 0.5 + x1;
           }
       }
      qsort (im->polyInts, ints, sizeof (int), gdCompareInt);

      for (i = 0; (i < (ints)); i += 2)
       {
         gdImageLine (im, im->polyInts[i], y, im->polyInts[i + 1], y,
                     fill_color);
       }
    }

  /* If we are drawing this AA, then redraw the border with AA lines. */
  if (c == gdAntiAliased)
    gdImagePolygon (im, p, n, c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageFilledRectangle ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2,
int  color 
)

Definition at line 1989 of file gd.c.

{
  int x, y;
  /* Nick Atty: limit the points at the edge.  Note that this also
     nicely kills any plotting for rectangles completely outside the
     window as it makes the tests in the for loops fail */
  if (x1 < 0)
    x1 = 0;
  if (x1 > gdImageSX (im))
    x1 = gdImageSX (im);
  if (y1 < 0)
    y1 = 0;
  if (y1 > gdImageSY (im))
    y1 = gdImageSY (im);

  for (y = y1; (y <= y2); y++)
    {
      for (x = x1; (x <= x2); x++)
       {
         gdImageSetPixel (im, x, y, color);
       }
    }
}

Here is the call graph for this function:

void gdImageFillToBorder ( gdImagePtr  im,
int  x,
int  y,
int  border,
int  color 
)

Definition at line 1744 of file gd.c.

{
  int lastBorder;
  /* Seek left */
  int leftLimit, rightLimit;
  int i;
  leftLimit = (-1);
  if (border < 0)
    {
      /* Refuse to fill to a non-solid border */
      return;
    }
  for (i = x; (i >= 0); i--)
    {
      if (gdImageGetPixel (im, i, y) == border)
       {
         break;
       }
      gdImageSetPixel (im, i, y, color);
      leftLimit = i;
    }
  if (leftLimit == (-1))
    {
      return;
    }
  /* Seek right */
  rightLimit = x;
  for (i = (x + 1); (i < im->sx); i++)
    {
      if (gdImageGetPixel (im, i, y) == border)
       {
         break;
       }
      gdImageSetPixel (im, i, y, color);
      rightLimit = i;
    }
  /* Look at lines above and below and start paints */
  /* Above */
  if (y > 0)
    {
      lastBorder = 1;
      for (i = leftLimit; (i <= rightLimit); i++)
       {
         int c;
         c = gdImageGetPixel (im, i, y - 1);
         if (lastBorder)
           {
             if ((c != border) && (c != color))
              {
                gdImageFillToBorder (im, i, y - 1, border, color);
                lastBorder = 0;
              }
           }
         else if ((c == border) || (c == color))
           {
             lastBorder = 1;
           }
       }
    }
  /* Below */
  if (y < ((im->sy) - 1))
    {
      lastBorder = 1;
      for (i = leftLimit; (i <= rightLimit); i++)
       {
         int c;
         c = gdImageGetPixel (im, i, y + 1);
         if (lastBorder)
           {
             if ((c != border) && (c != color))
              {
                gdImageFillToBorder (im, i, y + 1, border, color);
                lastBorder = 0;
              }
           }
         else if ((c == border) || (c == color))
           {
             lastBorder = 1;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageGetClip ( gdImagePtr  im,
int x1P,
int y1P,
int x2P,
int y2P 
)

Definition at line 3107 of file gd.c.

{
  *x1P = im->cx1;
  *y1P = im->cy1;
  *x2P = im->cx2;
  *y2P = im->cy2;
}
int gdImageGetPixel ( gdImagePtr  im,
int  x,
int  y 
)

Definition at line 1002 of file gd.c.

{
  if (gdImageBoundsSafeMacro (im, x, y))
    {
      if (im->trueColor)
       {
         return im->tpixels[y][x];
       }
      else
       {
         return im->pixels[y][x];
       }
    }
  else
    {
      return 0;
    }
}

Here is the caller graph for this function:

static int gdImageGetTrueColorPixel ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 1022 of file gd.c.

{
  int p = gdImageGetPixel (im, x, y);
  if (!im->trueColor)
    {
      return gdTrueColorAlpha (im->red[p], im->green[p], im->blue[p],
                            (im->transparent == p) ? gdAlphaTransparent :
                            gdAlphaOpaque);
    }
  else
    {
      return p;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageInterlace ( gdImagePtr  im,
int  interlaceArg 
)

Definition at line 2941 of file gd.c.

{
  im->interlace = interlaceArg;
}
void gdImageLine ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2,
int  color 
)

Definition at line 1096 of file gd.c.

{
  int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
  int wid;
  int w, wstart;
  int thick = im->thick;

  /* 2.0.10: Nick Atty: clip to edges of drawing rectangle, return if no
     points need to be drawn */

  if (clip_1d (&x1, &y1, &x2, &y2, gdImageSX (im)) == 0)
    return;
  if (clip_1d (&y1, &x1, &y2, &x2, gdImageSY (im)) == 0)
    return;

  /* gdAntiAliased passed as color: set anti-aliased line (AAL) global vars. */
  if (color == gdAntiAliased)
    {
      im->AAL_x1 = x1;
      im->AAL_y1 = y1;
      im->AAL_x2 = x2;
      im->AAL_y2 = y2;

      /* Compute what we can for point-to-line distance calculation later. */
      im->AAL_Bx_Ax = x2 - x1;
      im->AAL_By_Ay = y2 - y1;
      im->AAL_LAB_2 =
       (im->AAL_Bx_Ax * im->AAL_Bx_Ax) + (im->AAL_By_Ay * im->AAL_By_Ay);
      im->AAL_LAB = sqrt (im->AAL_LAB_2);

      /* For AA, we must draw pixels outside the width of the line.  Keep in
       * mind that this will be curtailed by cos/sin of theta later. */
      thick += 4;
    }

  dx = abs (x2 - x1);
  dy = abs (y2 - y1);
  if (dy <= dx)
    {
      /* More-or-less horizontal. use wid for vertical stroke */
      /* Doug Claar: watch out for NaN in atan2 (2.0.5) */
      if ((dx == 0) && (dy == 0))
       {
         wid = 1;
       }
      else
       {
         /* 2.0.12: Michael Schwartz: divide rather than multiply;
            TBB: but watch out for /0! */
         double ac = cos (atan2 (dy, dx));
         if (ac != 0)
           {
             wid = thick / ac;
           }
         else
           {
             wid = 1;
           }
         if (wid == 0)
           {
             wid = 1;
           }
       }
      d = 2 * dy - dx;
      incr1 = 2 * dy;
      incr2 = 2 * (dy - dx);
      if (x1 > x2)
       {
         x = x2;
         y = y2;
         ydirflag = (-1);
         xend = x1;
       }
      else
       {
         x = x1;
         y = y1;
         ydirflag = 1;
         xend = x2;
       }

      /* Set up line thickness */
      wstart = y - wid / 2;
      for (w = wstart; w < wstart + wid; w++)
       gdImageSetPixel (im, x, w, color);

      if (((y2 - y1) * ydirflag) > 0)
       {
         while (x < xend)
           {
             x++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                y++;
                d += incr2;
              }
             wstart = y - wid / 2;
             for (w = wstart; w < wstart + wid; w++)
              gdImageSetPixel (im, x, w, color);
           }
       }
      else
       {
         while (x < xend)
           {
             x++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                y--;
                d += incr2;
              }
             wstart = y - wid / 2;
             for (w = wstart; w < wstart + wid; w++)
              gdImageSetPixel (im, x, w, color);
           }
       }
    }
  else
    {
      /* More-or-less vertical. use wid for horizontal stroke */
      /* 2.0.12: Michael Schwartz: divide rather than multiply;
         TBB: but watch out for /0! */
      double as = sin (atan2 (dy, dx));
      if (as != 0)
       {
         wid = thick / as;
       }
      else
       {
         wid = 1;
       }
      if (wid == 0)
       wid = 1;

      d = 2 * dx - dy;
      incr1 = 2 * dx;
      incr2 = 2 * (dx - dy);
      if (y1 > y2)
       {
         y = y2;
         x = x2;
         yend = y1;
         xdirflag = (-1);
       }
      else
       {
         y = y1;
         x = x1;
         yend = y2;
         xdirflag = 1;
       }

      /* Set up line thickness */
      wstart = x - wid / 2;
      for (w = wstart; w < wstart + wid; w++)
       gdImageSetPixel (im, w, y, color);

      if (((x2 - x1) * xdirflag) > 0)
       {
         while (y < yend)
           {
             y++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                x++;
                d += incr2;
              }
             wstart = x - wid / 2;
             for (w = wstart; w < wstart + wid; w++)
              gdImageSetPixel (im, w, y, color);
           }
       }
      else
       {
         while (y < yend)
           {
             y++;
             if (d < 0)
              {
                d += incr1;
              }
             else
              {
                x--;
                d += incr2;
              }
             wstart = x - wid / 2;
             for (w = wstart; w < wstart + wid; w++)
              gdImageSetPixel (im, w, y, color);
           }
       }
    }

  /* If this is the only line we are drawing, go ahead and blend. */
  if ((color == gdAntiAliased) && !(im->AA_polygon))
    gdImageAABlend (im);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 588 of file gd.c.

{
  int i;
  int x, y, p;
  int xlate[256];
  if (to->trueColor)
    {
      return;
    }
  if (from->trueColor)
    {
      return;
    }

  for (i = 0; i < 256; i++)
    {
      xlate[i] = -1;
    };

  for (x = 0; x < (to->sx); x++)
    {
      for (y = 0; y < (to->sy); y++)
       {
         p = gdImageGetPixel (to, x, y);
         if (xlate[p] == -1)
           {
             /* This ought to use HWB, but we don't have an alpha-aware
                version of that yet. */
             xlate[p] =
              gdImageColorClosestAlpha (from, to->red[p], to->green[p],
                                     to->blue[p], to->alpha[p]);
             /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */
             /*      p,  to->red[p], to->green[p], to->blue[p], to->alpha[p], */
             /*      xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */
           };
         gdImageSetPixel (to, x, y, xlate[p]);
       };
    };

  for (i = 0; (i < (from->colorsTotal)); i++)
    {
      /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */
      to->red[i] = from->red[i];
      to->blue[i] = from->blue[i];
      to->green[i] = from->green[i];
      to->alpha[i] = from->alpha[i];
      to->open[i] = 0;
    };

  for (i = from->colorsTotal; (i < to->colorsTotal); i++)
    {
      to->open[i] = 1;
    };

  to->colorsTotal = from->colorsTotal;

}

Here is the call graph for this function:

void gdImagePolygon ( gdImagePtr  im,
gdPointPtr  p,
int  n,
int  c 
)

Definition at line 2704 of file gd.c.

{
  int i;
  int lx, ly;
  if (!n)
    {
      return;
    }

  /* Let it be known that we are drawing a polygon so that the opacity
   * mask doesn't get cleared after each line. */
  if (c == gdAntiAliased)
    im->AA_polygon = 1;

  lx = p->x;
  ly = p->y;
  gdImageLine (im, lx, ly, p[n - 1].x, p[n - 1].y, c);
  for (i = 1; (i < n); i++)
    {
      p++;
      gdImageLine (im, lx, ly, p->x, p->y, c);
      lx = p->x;
      ly = p->y;
    }

  if (c == gdAntiAliased)
    {
      im->AA_polygon = 0;
      gdImageAABlend (im);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageRectangle ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2,
int  color 
)

Definition at line 1960 of file gd.c.

{
  int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2,
    y2v = y2;
  int thick = im->thick;
  if (thick > 1)
    {
      int half = thick / 2;
      int half1 = thick - half;

      if (y1 < y2)
       {
         y1v = y1h - half;
         y2v = y2h + half1 - 1;
       }
      else
       {
         y1v = y1h + half1 - 1;
         y2v = y2h - half;
       }
    }

  gdImageLine (im, x1h, y1h, x2h, y1h, color);
  gdImageLine (im, x1h, y2h, x2h, y2h, color);
  gdImageLine (im, x1v, y1v, x1v, y2v, color);
  gdImageLine (im, x2v, y1v, x2v, y2v, color);
}

Here is the call graph for this function:

void gdImageSaveAlpha ( gdImagePtr  im,
int  saveAlphaArg 
)

Definition at line 3068 of file gd.c.

{
  im->saveAlphaFlag = saveAlphaArg;
}

Definition at line 2925 of file gd.c.

{
  im->AA = 1;
  im->AA_color = c;
  im->AA_dont_blend = -1;
}
void gdImageSetAntiAliasedDontBlend ( gdImagePtr  im,
int  c,
int  dont_blend 
)

Definition at line 2933 of file gd.c.

{
  im->AA = 1;
  im->AA_color = c;
  im->AA_dont_blend = dont_blend;
}

Definition at line 2885 of file gd.c.

{
  int i;
  im->brush = brush;
  if ((!im->trueColor) && (!im->brush->trueColor))
    {
      for (i = 0; (i < gdImageColorsTotal (brush)); i++)
       {
         int index;
         index = gdImageColorResolveAlpha (im,
                                       gdImageRed (brush, i),
                                       gdImageGreen (brush, i),
                                       gdImageBlue (brush, i),
                                       gdImageAlpha (brush, i));
         im->brushColorMap[i] = index;
       }
    }
}

Here is the call graph for this function:

void gdImageSetClip ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2 
)

Definition at line 3074 of file gd.c.

{
  if (x1 < 0) {
    x1 = 0;
  }
  if (x1 >= im->sx) {
    x1 = im->sx - 1;
  }
  if (x2 < 0) {
    x2 = 0;
  }
  if (x2 >= im->sx) {
    x2 = im->sx - 1;
  }
  if (y1 < 0) {
    y1 = 0;
  }
  if (y1 >= im->sy) {
    y1 = im->sy - 1;
  }
  if (y2 < 0) {
    y2 = 0;
  }
  if (y2 >= im->sy) {
    y2 = im->sy - 1;
  }
  im->cx1 = x1;
  im->cy1 = y1;
  im->cx2 = x2;
  im->cy2 = y2;
}
void gdImageSetPixel ( gdImagePtr  im,
int  x,
int  y,
int  color 
)

Definition at line 724 of file gd.c.

{
  int p;
  switch (color)
    {
    case gdStyled:
      if (!im->style)
       {
         /* Refuse to draw if no style is set. */
         return;
       }
      else
       {
         p = im->style[im->stylePos++];
       }
      if (p != (gdTransparent))
       {
         gdImageSetPixel (im, x, y, p);
       }
      im->stylePos = im->stylePos % im->styleLength;
      break;
    case gdStyledBrushed:
      if (!im->style)
       {
         /* Refuse to draw if no style is set. */
         return;
       }
      p = im->style[im->stylePos++];
      if ((p != gdTransparent) && (p != 0))
       {
         gdImageSetPixel (im, x, y, gdBrushed);
       }
      im->stylePos = im->stylePos % im->styleLength;
      break;
    case gdBrushed:
      gdImageBrushApply (im, x, y);
      break;
    case gdTiled:
      gdImageTileApply (im, x, y);
      break;
    case gdAntiAliased:
      gdImageAntiAliasedApply (im, x, y);
      break;
    default:
      if (gdImageBoundsSafeMacro (im, x, y))
       {
         if (im->trueColor)
           {
             if (im->alphaBlendingFlag)
              {
                im->tpixels[y][x] = gdAlphaBlend (im->tpixels[y][x], color);
              }
             else
              {
                im->tpixels[y][x] = color;
              }
           }
         else
           {
             im->pixels[y][x] = color;
           }
       }
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageSetStyle ( gdImagePtr  im,
int style,
int  noOfPixels 
)

Definition at line 2866 of file gd.c.

{
  if (im->style)
    {
      gdFree (im->style);
    }
  im->style = (int *) gdMalloc (sizeof (int) * noOfPixels);
  memcpy (im->style, style, sizeof (int) * noOfPixels);
  im->styleLength = noOfPixels;
  im->stylePos = 0;
}

Here is the call graph for this function:

void gdImageSetThickness ( gdImagePtr  im,
int  thickness 
)

Definition at line 2879 of file gd.c.

{
  im->thick = thickness;
}

Definition at line 2905 of file gd.c.

{
  int i;
  im->tile = tile;
  if ((!im->trueColor) && (!im->tile->trueColor))
    {
      for (i = 0; (i < gdImageColorsTotal (tile)); i++)
       {
         int index;
         index = gdImageColorResolveAlpha (im,
                                       gdImageRed (tile, i),
                                       gdImageGreen (tile, i),
                                       gdImageBlue (tile, i),
                                       gdImageAlpha (tile, i));
         im->tileColorMap[i] = index;
       }
    }
}

Here is the call graph for this function:

void gdImageString ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
unsigned char *  s,
int  color 
)

Definition at line 1561 of file gd.c.

{
  int i;
  int l;
  l = strlen ((char *) s);
  for (i = 0; (i < l); i++)
    {
      gdImageChar (im, f, x, y, s[i], color);
      x += f->w;
    }
}

Here is the call graph for this function:

void gdImageString16 ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
unsigned short *  s,
int  color 
)

Definition at line 1591 of file gd.c.

{
  int i;
  int l;
  l = strlen16 (s);
  for (i = 0; (i < l); i++)
    {
      gdImageChar (im, f, x, y, s[i], color);
      x += f->w;
    }
}

Here is the call graph for this function:

void gdImageStringUp ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
unsigned char *  s,
int  color 
)

Definition at line 1575 of file gd.c.

{
  int i;
  int l;
  l = strlen ((char *) s);
  for (i = 0; (i < l); i++)
    {
      gdImageCharUp (im, f, x, y, s[i], color);
      y -= f->w;
    }
}

Here is the call graph for this function:

void gdImageStringUp16 ( gdImagePtr  im,
gdFontPtr  f,
int  x,
int  y,
unsigned short *  s,
int  color 
)

Definition at line 1605 of file gd.c.

{
  int i;
  int l;
  l = strlen16 (s);
  for (i = 0; (i < l); i++)
    {
      gdImageCharUp (im, f, x, y, s[i], color);
      y -= f->w;
    }
}

Here is the call graph for this function:

static void gdImageTileApply ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 893 of file gd.c.

{
  int srcx, srcy;
  int p;
  if (!im->tile)
    {
      return;
    }
  srcx = x % gdImageSX (im->tile);
  srcy = y % gdImageSY (im->tile);
  if (im->trueColor)
    {
      p = gdImageGetTrueColorPixel (im->tile, srcx, srcy);
      gdImageSetPixel (im, x, y, p);
    }
  else
    {
      p = gdImageGetPixel (im->tile, srcx, srcy);
      /* Allow for transparency */
      if (p != gdImageGetTransparent (im->tile))
       {
         if (im->tile->trueColor)
           {
             /* Truecolor tile. Very slow
                on a palette destination. */
             gdImageSetPixel (im, x, y,
                            gdImageColorResolveAlpha (im,
                                                  gdTrueColorGetRed
                                                  (p),
                                                  gdTrueColorGetGreen
                                                  (p),
                                                  gdTrueColorGetBlue
                                                  (p),
                                                  gdTrueColorGetAlpha
                                                  (p)));
           }
         else
           {
             gdImageSetPixel (im, x, y, im->tileColorMap[p]);
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static float HWB_Diff ( int  r1,
int  g1,
int  b1,
int  r2,
int  g2,
int  b2 
) [static]

Definition at line 298 of file gd.c.

{
  RGBType RGB1, RGB2;
  HWBType HWB1, HWB2;
  float diff;

  SETUP_RGB (RGB1, r1, g1, b1);
  SETUP_RGB (RGB2, r2, g2, b2);

  RGB_to_HWB (RGB1, &HWB1);
  RGB_to_HWB (RGB2, &HWB2);

  /*
   * I made this bit up; it seems to produce OK results, and it is certainly
   * more visually correct than the current RGB metric. (PJW)
   */

  if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED))
    {
      diff = 0;                    /* Undefined hues always match... */
    }
  else
    {
      diff = abs (HWB1.H - HWB2.H);
      if (diff > 3)
       {
         diff = 6 - diff;   /* Remember, it's a colour circle */
       }
    }

  diff =
    diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B -
                                                    HWB2.B) * (HWB1.B -
                                                              HWB2.B);

  return diff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

long lsqrt ( long  n)

Definition at line 1635 of file gd.c.

{
  long result = (long) sqrt ((double) n);
  return result;
}
static HWBType* RGB_to_HWB ( RGBType  RGB,
HWBType HWB 
) [static]

Definition at line 275 of file gd.c.

{

  /*
   * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is  
   * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.  
   */

  float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
  int i;

  w = MIN3 (R, G, B);
  v = MAX3 (R, G, B);
  b = 1 - v;
  if (v == w)
    RETURN_HWB (HWB_UNDEFINED, w, b);
  f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
  i = (R == w) ? 3 : ((G == w) ? 5 : 1);
  RETURN_HWB (i - f / (v - w), w, b);

}

Here is the caller graph for this function:

static int strlen16 ( unsigned short *  s) [static]

Definition at line 1619 of file gd.c.

{
  int len = 0;
  while (*s)
    {
      s++;
      len++;
    }
  return len;
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 2 of file gdtables.c.

Definition at line 365 of file gdtables.c.