Back to index

php5  5.3.10
Classes | Defines | Functions | Variables
gd.c File Reference
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"
#include "gdhelpers.h"
#include "php.h"

Go to the source code of this file.

Classes

struct  RGBType
struct  HWBType
struct  seg

Defines

#define HAVE_FABSF   0
#define HAVE_FLOORF   0
#define fabsf(x)   ((float)(fabs(x)))
#define floorf(x)   ((float)(floor(x)))
#define ASC(ch)   ch
#define floor_cast(exp)   ((long) exp)
#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.0f; s.G = g/255.0f; s.B = b/255.0f;}
#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 BLEND_COLOR(a, nc, c, cc)   nc = (cc) + (((((c) - (cc)) * (a)) + ((((c) - (cc)) * (a)) >> 8) + 0x80) >> 8);
#define FILL_MAX   ((int)(im->sy*im->sx)/4)
#define FILL_PUSH(Y, XL, XR, DY)
#define FILL_POP(Y, XL, XR, DY)   {sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;}

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 gdLayerOverlay (int dst, int src)
static int gdAlphaOverlayColor (int src, int dst, int max)
int gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
void php_gd_error_ex (int type, const char *format,...)
void php_gd_error (const char *format,...)
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)
static int gdImageTileGet (gdImagePtr im, int x, int y)
int gdImageGetPixel (gdImagePtr im, int x, int y)
void gdImageAABlend (gdImagePtr im)
static void gdImageHLine (gdImagePtr im, int y, int x1, int x2, int col)
static void gdImageVLine (gdImagePtr im, int x, int y1, int y2, int col)
void gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
static void gdImageSetAAPixelColor (gdImagePtr im, int x, int y, int color, int t)
void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int col)
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)
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 gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
static void _gdImageFillTiled (gdImagePtr im, int x, int y, int nc)
void gdImageFill (gdImagePtr im, int x, int y, int nc)
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 gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
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 gdAlphaBlendOld (int dst, int src)
int gdAlphaBlend (int dst, int src)
void gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
void gdImageAntialias (gdImagePtr im, int antialias)
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 318 of file gd.c.

Class Members
float B
float G
float R
struct HWBType

Definition at line 323 of file gd.c.

Class Members
float B
float H
float W
struct seg

Definition at line 1845 of file gd.c.

Class Members
int dy
int xl
int xr
int y

Define Documentation

#define ASC (   ch)    ch

Definition at line 47 of file gd.c.

#define BLEND_COLOR (   a,
  nc,
  c,
  cc 
)    nc = (cc) + (((((c) - (cc)) * (a)) + ((((c) - (cc)) * (a)) >> 8) + 0x80) >> 8);

Definition at line 1261 of file gd.c.

#define fabsf (   x)    ((float)(fabs(x)))

Definition at line 30 of file gd.c.

#define FILL_MAX   ((int)(im->sy*im->sx)/4)

Definition at line 1848 of file gd.c.

#define FILL_POP (   Y,
  XL,
  XR,
  DY 
)    {sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;}

Definition at line 1853 of file gd.c.

#define FILL_PUSH (   Y,
  XL,
  XR,
  DY 
)
Value:
if (sp<stack+FILL_MAX && Y+(DY)>=0 && Y+(DY)<wy2) \
    {sp->y = Y; sp->xl = XL; sp->xr = XR; sp->dy = DY; sp++;}

Definition at line 1849 of file gd.c.

#define floor_cast (   exp)    ((long) exp)

Definition at line 89 of file gd.c.

#define floorf (   x)    ((float)(floor(x)))

Definition at line 36 of file gd.c.

#define HAVE_FABSF   0

Definition at line 22 of file gd.c.

#define HAVE_FLOORF   0

Definition at line 25 of file gd.c.

#define HWB_UNDEFINED   -1

Definition at line 300 of file gd.c.

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

Definition at line 308 of file gd.c.

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

Definition at line 310 of file gd.c.

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

Definition at line 304 of file gd.c.

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

Definition at line 306 of file gd.c.

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

Definition at line 298 of file gd.c.

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

Definition at line 299 of file gd.c.

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

Definition at line 301 of file gd.c.


Function Documentation

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

Definition at line 1953 of file gd.c.

{
       int i, l, x1, x2, dy;
       int oc;   /* old pixel value */
       int tiled;
       int wx2,wy2;
       /* stack of filled segments */
       struct seg *stack;
       struct seg *sp;
       char **pts;

       if (!im->tile) {
              return;
       }

       wx2=im->sx;wy2=im->sy;
       tiled = nc==gdTiled;

       nc =  gdImageTileGet(im,x,y);

       pts = (char **) ecalloc(im->sy + 1, sizeof(char *));
       for (i = 0; i < im->sy + 1; i++) {
              pts[i] = (char *) ecalloc(im->sx + 1, sizeof(char));
       }

       stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
       sp = stack;

       oc = gdImageGetPixel(im, x, y);

       /* required! */
       FILL_PUSH(y,x,x,1);
       /* seed segment (popped 1st) */
       FILL_PUSH(y+1, x, x, -1);
       while (sp>stack) {
              FILL_POP(y, x1, x2, dy);
              for (x=x1; x>=0 && (!pts[y][x] && gdImageGetPixel(im,x,y)==oc); x--) {
                     nc = gdImageTileGet(im,x,y);
                     pts[y][x] = 1;
                     gdImageSetPixel(im,x, y, nc);
              }
              if (x>=x1) {
                     goto skip;
              }
              l = x+1;

              /* leak on left? */
              if (l<x1) {
                     FILL_PUSH(y, l, x1-1, -dy);
              }
              x = x1+1;
              do {
                     for(; x<wx2 && (!pts[y][x] && gdImageGetPixel(im,x, y)==oc); x++) {
                            nc = gdImageTileGet(im,x,y);
                            pts[y][x] = 1;
                            gdImageSetPixel(im, x, y, nc);
                     }
                     FILL_PUSH(y, l, x-1, dy);
                     /* leak on right? */
                     if (x>x2+1) {
                            FILL_PUSH(y, x2+1, x-1, -dy);
                     }
skip:         for(x++; x<=x2 && (pts[y][x] || gdImageGetPixel(im,x, y)!=oc); x++);
                     l = x;
              } while (x<=x2);
       }

       for(i = 0; i < im->sy + 1; i++) {
              efree(pts[i]);
       }

       efree(pts);
       efree(stack);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 667 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 -= (int)(m * *x0);
              *x0 = 0;
              /* now, perhaps, adjust the far end of the line as well */
              if (*x1 > maxdim) {
                     *y1 += (int)(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 += (int)(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 -= (int)(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 += (int)(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 -= (int)(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 1510 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 2877 of file gd.c.

                                    {
    int src_alpha = gdTrueColorGetAlpha(src);
    int dst_alpha, alpha, red, green, blue;
    int src_weight, dst_weight, tot_weight;

/* -------------------------------------------------------------------- */
/*      Simple cases we want to handle fast.                            */
/* -------------------------------------------------------------------- */
    if( src_alpha == gdAlphaOpaque )
        return src;

    dst_alpha = gdTrueColorGetAlpha(dst);
    if( src_alpha == gdAlphaTransparent )
        return dst;
    if( dst_alpha == gdAlphaTransparent )
        return src;

/* -------------------------------------------------------------------- */
/*      What will the source and destination alphas be?  Note that      */
/*      the destination weighting is substantially reduced as the       */
/*      overlay becomes quite opaque.                                   */
/* -------------------------------------------------------------------- */
    src_weight = gdAlphaTransparent - src_alpha;
    dst_weight = (gdAlphaTransparent - dst_alpha) * src_alpha / gdAlphaMax;
    tot_weight = src_weight + dst_weight;
    
/* -------------------------------------------------------------------- */
/*      What red, green and blue result values will we use?             */
/* -------------------------------------------------------------------- */
    alpha = src_alpha * dst_alpha / gdAlphaMax;

    red = (gdTrueColorGetRed(src) * src_weight
           + gdTrueColorGetRed(dst) * dst_weight) / tot_weight;
    green = (gdTrueColorGetGreen(src) * src_weight
           + gdTrueColorGetGreen(dst) * dst_weight) / tot_weight;
    blue = (gdTrueColorGetBlue(src) * src_weight
           + gdTrueColorGetBlue(dst) * dst_weight) / tot_weight;

/* -------------------------------------------------------------------- */
/*      Return merged result.                                           */
/* -------------------------------------------------------------------- */
    return ((alpha << 24) + (red << 16) + (green << 8) + blue);

}

Here is the caller graph for this function:

int gdAlphaBlendOld ( int  dst,
int  src 
)

Definition at line 2855 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));
}
static int gdAlphaOverlayColor ( int  src,
int  dst,
int  max 
) [static]

Definition at line 2951 of file gd.c.

{
       /* this function implements the algorithm
        *
        * for dst[rgb] < 0.5,
        *   c[rgb] = 2.src[rgb].dst[rgb]
        * and for dst[rgb] > 0.5,
        *   c[rgb] = -2.src[rgb].dst[rgb] + 2.dst[rgb] + 2.src[rgb] - 1
        *
        */

       dst = dst << 1;
       if( dst > max ) {
              /* in the "light" zone */
              return dst + (src << 1) - (dst * src / max) - max;
       } else {
              /* in the "dark" zone */
              return dst * src / max;
       }
}

Here is the caller graph for this function:

int gdCompareInt ( const void *  a,
const void *  b 
)

Definition at line 2715 of file gd.c.

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

Here is the caller graph for this function:

void gdImageAABlend ( gdImagePtr  im)

Definition at line 1006 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 gdImageAALine ( gdImagePtr  im,
int  x1,
int  y1,
int  x2,
int  y2,
int  col 
)

Definition at line 1285 of file gd.c.

{
       /* keep them as 32bits */
       long x, y, inc;
       long dx, dy,tmp;

       if (y1 < 0 && y2 < 0) {
              return;
       }
       if (y1 < 0) {
              x1 += (y1 * (x1 - x2)) / (y2 - y1);
              y1 = 0;
       }
       if (y2 < 0) {
              x2 += (y2 * (x1 - x2)) / (y2 - y1);
              y2 = 0;
       }

       /* bottom edge */
       if (y1 >= im->sy && y2 >= im->sy) {
              return;
       }
       if (y1 >= im->sy) {
              x1 -= ((im->sy - y1) * (x1 - x2)) / (y2 - y1);
              y1 = im->sy - 1;
       }
       if (y2 >= im->sy) {
              x2 -= ((im->sy - y2) * (x1 - x2)) / (y2 - y1);
              y2 = im->sy - 1;
       }

       /* left edge */
       if (x1 < 0 && x2 < 0) {
              return;
       }
       if (x1 < 0) {
              y1 += (x1 * (y1 - y2)) / (x2 - x1);
              x1 = 0;
       }
       if (x2 < 0) {
              y2 += (x2 * (y1 - y2)) / (x2 - x1);
              x2 = 0;
       }
       /* right edge */
       if (x1 >= im->sx && x2 >= im->sx) {
              return;
       }
       if (x1 >= im->sx) {
              y1 -= ((im->sx - x1) * (y1 - y2)) / (x2 - x1);
              x1 = im->sx - 1;
       }
       if (x2 >= im->sx) {
              y2 -= ((im->sx - x2) * (y1 - y2)) / (x2 - x1);
              x2 = im->sx - 1;
       }

       dx = x2 - x1;
       dy = y2 - y1;

       if (dx == 0 && dy == 0) {
              return;
       }
       if (abs(dx) > abs(dy)) {
              if (dx < 0) {
                     tmp = x1;
                     x1 = x2;
                     x2 = tmp;
                     tmp = y1;
                     y1 = y2;
                     y2 = tmp;
                     dx = x2 - x1;
                     dy = y2 - y1;
              }
              x = x1 << 16;
              y = y1 << 16;
              inc = (dy * 65536) / dx;
              while ((x >> 16) <= x2) {
                     gdImageSetAAPixelColor(im, x >> 16, y >> 16, col, (y >> 8) & 0xFF);
                     if ((y >> 16) + 1 < im->sy) {
                            gdImageSetAAPixelColor(im, x >> 16, (y >> 16) + 1,col, (~y >> 8) & 0xFF);
                     }
                     x += (1 << 16);
                     y += inc;
              }
       } else {
              if (dy < 0) {
                     tmp = x1;
                     x1 = x2;
                     x2 = tmp;
                     tmp = y1;
                     y1 = y2;
                     y2 = tmp;
                     dx = x2 - x1;
                     dy = y2 - y1;
              }
              x = x1 << 16;
              y = y1 << 16;
              inc = (dx * 65536) / dy;
              while ((y>>16) <= y2) {
                     gdImageSetAAPixelColor(im, x >> 16, y >> 16, col, (x >> 8) & 0xFF);
                     if ((x >> 16) + 1 < im->sx) {
                            gdImageSetAAPixelColor(im, (x >> 16) + 1, (y >> 16),col, (~x >> 8) & 0xFF);
                     }
                     x += inc;
                     y += (1<<16);
              }
       }
}

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 2922 of file gd.c.

{
       im->alphaBlendingFlag = alphaBlendingArg;
}

Here is the caller graph for this function:

void gdImageAntialias ( gdImagePtr  im,
int  antialias 
)

Definition at line 2927 of file gd.c.

{
       if (im->trueColor){
              im->antialias = antialias;
       }
}
static void gdImageAntiAliasedApply ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 931 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 (!gdImageBoundsSafe(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 1664 of file gd.c.

{
       if ((s % 360) == (e % 360)) {
              gdImageEllipse(im, cx, cy, w, h, color);
       } else {
              gdImageFilledArc(im, cx, cy, w, h, s, e, color, gdNoFill);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 789 of file gd.c.

{
       int lx, ly;
       int hy, 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 1538 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 1564 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 475 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 480 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 257 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 262 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->alpha[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 428 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:

void gdImageColorDeallocate ( gdImagePtr  im,
int  color 
)

Definition at line 583 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 453 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 458 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 caller graph for this function:

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

Definition at line 520 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 525 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:

void gdImageColorTransparent ( gdImagePtr  im,
int  color 
)

Definition at line 592 of file gd.c.

{
       if (!im->trueColor) {
              if (im->transparent != -1) {
                     im->alpha[im->transparent] = gdAlphaOpaque;
              }
              if (color > -1 && color < im->colorsTotal && color < gdMaxColors) {
                     im->alpha[color] = gdAlphaTransparent;
              } else {
                     return;
              }
       }
       im->transparent = color;
}

Here is the caller graph for this function:

Definition at line 2782 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;
}

Here is the caller graph for this function:

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

Definition at line 2151 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.
               */

              if (src->trueColor) {
                     for (y = 0; (y < h); y++) {
                            for (x = 0; (x < w); x++) {
                                   int c = gdImageGetTrueColorPixel (src, srcX + x, srcY + y);
                                   gdImageSetPixel (dst, dstX + x, dstY + y, c);
                            }
                     }
              } else {
                     /* source is palette based */
                     for (y = 0; (y < h); y++) {
                            for (x = 0; (x < w); x++) {
                                   int c = gdImageGetPixel (src, srcX + x, srcY + y);
                                   if (c != src->transparent) {
                                          gdImageSetPixel(dst, dstX + x, dstY + y, gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]));
                                   }
                            }
                     }
              }
              return;
       }

       /* Destination is palette based */
       if (src->trueColor) { /* But source is truecolor (Ouch!) */
              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);

                            /* Get best match possible. */
                            nc = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c), gdTrueColorGetGreen(c), gdTrueColorGetBlue(c), gdTrueColorGetAlpha(c));

                            gdImageSetPixel(dst, tox, toy, nc);
                            tox++;
                     }
                     toy++;
              }
              return;
       }

       /* Palette based to palette based */
       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:

Here is the caller 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 2250 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 = (int)(gdImageRed (src, c) * (pct / 100.0) + gdImageRed (dst, dc) * ((100 - pct) / 100.0));
                            ncG = (int)(gdImageGreen (src, c) * (pct / 100.0) + gdImageGreen (dst, dc) * ((100 - pct) / 100.0));
                            ncB = (int)(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:

Here is the caller 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 2290 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.29900f * gdImageRed(dst, dc)) + (0.58700f * gdImageGreen(dst, dc)) + (0.11400f * gdImageBlue(dst, dc));

                            ncR = (int)(gdImageRed (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
                            ncG = (int)(gdImageGreen (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
                            ncB = (int)(gdImageBlue (src, c) * (pct / 100.0f) + 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:

Here is the caller 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;
       double sy1, sy2, sx1, sx2;

       if (!dst->trueColor) {
              gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
              return;
       }
       for (y = dstY; (y < dstY + dstH); y++) {
              sy1 = ((double) y - (double) dstY) * (double) srcH / (double) dstH;
              sy2 = ((double) (y + 1) - (double) dstY) * (double) srcH / (double) dstH;
              for (x = dstX; (x < dstX + dstW); x++) {
                     double sx, sy;
                     double spixels = 0;
                     double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
                     double alpha_factor, alpha_sum = 0.0, contrib_sum = 0.0;
                     sx1 = ((double) x - (double) dstX) * (double) srcW / dstW;
                     sx2 = ((double) (x + 1) - (double) dstX) * (double) srcW / dstW;
                     sy = sy1;
                     do {
                            double yportion;
                            if (floor_cast(sy) == floor_cast(sy1)) {
                                   yportion = 1.0f - (sy - floor_cast(sy));
                                   if (yportion > sy2 - sy1) {
                                          yportion = sy2 - sy1;
                                   }
                                   sy = floor_cast(sy);
                            } else if (sy == floorf(sy2)) {
                                   yportion = sy2 - floor_cast(sy2);
                            } else {
                                   yportion = 1.0f;
                            }
                            sx = sx1;
                            do {
                                   double xportion;
                                   double pcontribution;
                                   int p;
                                   if (floorf(sx) == floor_cast(sx1)) {
                                          xportion = 1.0f - (sx - floor_cast(sx));
                                          if (xportion > sx2 - sx1) {
                                                 xportion = sx2 - sx1;
                                          }
                                          sx = floor_cast(sx);
                                   } else if (sx == floorf(sx2)) {
                                          xportion = sx2 - floor_cast(sx2);
                                   } else {
                                          xportion = 1.0f;
                                   }
                                   pcontribution = xportion * yportion;
                                   p = gdImageGetTrueColorPixel(src, (int) sx + srcX, (int) sy + srcY);

                                   alpha_factor = ((gdAlphaMax - gdTrueColorGetAlpha(p))) * pcontribution;
                                   red += gdTrueColorGetRed (p) * alpha_factor;
                                   green += gdTrueColorGetGreen (p) * alpha_factor;
                                   blue += gdTrueColorGetBlue (p) * alpha_factor;
                                   alpha += gdTrueColorGetAlpha (p) * pcontribution;
                                   alpha_sum += alpha_factor;
                                   contrib_sum += pcontribution;
                                   spixels += xportion * yportion;
                                   sx += 1.0f;
                            }
                            while (sx < sx2);

                            sy += 1.0f;
                     }

                     while (sy < sy2);

                     if (spixels != 0.0f) {
                            red /= spixels;
                            green /= spixels;
                            blue /= spixels;
                            alpha /= spixels;
                            alpha += 0.5;
                     }
                     if ( alpha_sum != 0.0f) {
                            if( contrib_sum != 0.0f) {
                                   alpha_sum /= contrib_sum;
                            }
                            red /= alpha_sum;
                            green /= alpha_sum;
                            blue /= alpha_sum;
                     }
                     /* Clamping to allow for rounding errors above */
                     if (red > 255.0f) {
                            red = 255.0f;
                     }
                     if (green > 255.0f) {
                            green = 255.0f;
                     }
                     if (blue > 255.0f) {
                            blue = 255.0f;
                     }
                     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:

Here is the caller 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 2344 of file gd.c.

{
       int c;
       int x, y;
       int tox, toy;
       int ydest;
       int i;
       int colorMap[gdMaxColors];
       /* Stretch vectors */
       int *stx, *sty;
       /* We only need to use floating point to determine the correct stretch vector for one line's worth. */
       double accum;
       
       if (overflow2(sizeof(int), srcW)) {
              return;
       }
       if (overflow2(sizeof(int), srcH)) {
              return;
       }

       stx = (int *) gdMalloc (sizeof (int) * srcW);
       sty = (int *) gdMalloc (sizeof (int) * srcH);
       accum = 0;

       /* Fixed by Mao Morimoto 2.0.16 */
       for (i = 0; (i < srcW); i++) {
              stx[i] = dstW * (i+1) / srcW - dstW * i / srcW ;
       }
       for (i = 0; (i < srcH); i++) {
              sty[i] = dstH * (i+1) / srcH - dstH * i / srcH ;
       }
       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) {
                                                 /* 2.0.21, TK: not tox++ */
                                                 tox += stx[x - srcX];
                                                 continue;
                                          }
                                   } else {
                                          /* TK: old code follows */
                                          mapTo = gdImageGetTrueColorPixel (src, x, y);
                                          /* Added 7/24/95: support transparent copies */
                                          if (gdImageGetTransparent (src) == mapTo) {
                                                 /* 2.0.21, TK: not tox++ */
                                                 tox += stx[x - srcX];
                                                 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:

gdImagePtr gdImageCreate ( int  sx,
int  sy 
)

Definition at line 123 of file gd.c.

{
       int i;
       gdImagePtr im;

       if (overflow2(sx, sy)) {
              return NULL;
       }

       if (overflow2(sizeof(unsigned char *), sy)) {
              return NULL;
       }

       im = (gdImage *) gdCalloc(1, 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 174 of file gd.c.

{
       int i;
       gdImagePtr im;

       if (overflow2(sx, sy)) {
              return NULL;
       }

       if (overflow2(sizeof(unsigned char *), sy)) {
              return NULL;
       }
       
       if (overflow2(sizeof(int), sx)) {
              return NULL;
       }

       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 1396 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;
              }
              wid = (int)(thick * sin(atan2(dy, dx)));
              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:

void gdImageDestroy ( gdImagePtr  im)

Definition at line 227 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  nc 
)

Definition at line 1858 of file gd.c.

{
       int l, x1, x2, dy;
       int oc;   /* old pixel value */
       int wx2,wy2;

       int alphablending_bak;

       /* stack of filled segments */
       /* struct seg stack[FILL_MAX],*sp = stack;; */
       struct seg *stack = NULL;
       struct seg *sp;

       if (!im->trueColor && nc > (im->colorsTotal -1)) {
              return;
       }

       alphablending_bak = im->alphaBlendingFlag;       
       im->alphaBlendingFlag = 0;

       if (nc==gdTiled){
              _gdImageFillTiled(im,x,y,nc);
              im->alphaBlendingFlag = alphablending_bak;
              return;
       }

       wx2=im->sx;wy2=im->sy;
       oc = gdImageGetPixel(im, x, y);
       if (oc==nc || x<0 || x>wx2 || y<0 || y>wy2) {
              im->alphaBlendingFlag = alphablending_bak;       
              return;
       }

       /* Do not use the 4 neighbors implementation with
        * small images
        */
       if (im->sx < 4) {
              int ix = x, iy = y, c;
              do {
                     do {
                            c = gdImageGetPixel(im, ix, iy);
                            if (c != oc) {
                                   goto done;
                            }
                            gdImageSetPixel(im, ix, iy, nc);
                     } while(ix++ < (im->sx -1));
                     ix = x;
              } while(iy++ < (im->sy -1));
              goto done;
       }

       stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
       sp = stack;

       /* required! */
       FILL_PUSH(y,x,x,1);
       /* seed segment (popped 1st) */
       FILL_PUSH(y+1, x, x, -1);
       while (sp>stack) {
              FILL_POP(y, x1, x2, dy);

              for (x=x1; x>=0 && gdImageGetPixel(im,x, y)==oc; x--) {
                     gdImageSetPixel(im,x, y, nc);
              }
              if (x>=x1) {
                     goto skip;
              }
              l = x+1;

                /* leak on left? */
              if (l<x1) {
                     FILL_PUSH(y, l, x1-1, -dy);
              }
              x = x1+1;
              do {
                     for (; x<=wx2 && gdImageGetPixel(im,x, y)==oc; x++) {
                            gdImageSetPixel(im, x, y, nc);
                     }
                     FILL_PUSH(y, l, x-1, dy);
                     /* leak on right? */
                     if (x>x2+1) {
                            FILL_PUSH(y, x2+1, x-1, -dy);
                     }
skip:                for (x++; x<=x2 && (gdImageGetPixel(im, x, y)!=oc); x++);

                     l = x;
              } while (x<=x2);
       }

       efree(stack);

done:
       im->alphaBlendingFlag = alphablending_bak;       
}

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 1673 of file gd.c.

{
       gdPoint pts[3];
       int i;
       int lx = 0, ly = 0;
       int fx = 0, fy = 0;


    if ((s % 360)  == (e % 360)) {
              s = 0; e = 360;
       } else {
              if (s > 360) {
                     s = s % 360;
              }

              if (e > 360) {
                     e = e % 360;
              }

              while (s < 0) {
                     s += 360;
              }

              while (e < s) {
                     e += 360;
              }
              if (s == e) {
                     s = 0; 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 gdImageFilledPolygon ( gdImagePtr  im,
gdPointPtr  p,
int  n,
int  c 
)

Definition at line 2608 of file gd.c.

{
       int i;
       int y;
       int miny, maxy, pmaxy;
       int x1, y1;
       int x2, y2;
       int ind1, ind2;
       int ints;
       int fill_color;

       if (n <= 0) {
              return;
       }

       if (overflow2(sizeof(int), 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;
              }
              if (overflow2(sizeof(int), im->polyAllocated)) {
                     return;
              }
              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;
              }
       }
       pmaxy = maxy;
       /* 2.0.16: Optimization by Ilia Chipitsine -- don't waste time offscreen */
       if (miny < 0) {
              miny = 0;
       }
       if (maxy >= gdImageSY(im)) {
              maxy = gdImageSY(im) - 1;
       }

       /* 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 == pmaxy && y == y2) {
                            im->polyInts[ints++] = x2;
                     }
              }
              qsort(im->polyInts, ints, sizeof(int), gdCompareInt);

              for (i = 0; i < ints - 1; 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 2106 of file gd.c.

{
       int x, y;


       if (x1 == x2 && y1 == y2) {
              gdImageSetPixel(im, x1, y1, color);
              return;
       }

       if (x1 > x2) {
              x = x1;
              x1 = x2;
              x2 = x;
       }

       if (y1 > y2) {
              y = y1;
              y1 = y2;
              y2 = y;
       }

       if (x1 < 0) {
              x1 = 0;
       }

       if (x2 >= gdImageSX(im)) {
              x2 = gdImageSX(im) - 1;
       }

       if (y1 < 0) {
              y1 = 0;
       }

       if (y2 >= gdImageSY(im)) {
              y2 = gdImageSY(im) - 1;
       }

       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:

Here is the caller graph for this function:

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

Definition at line 1756 of file gd.c.

{
       int lastBorder;
       /* Seek left */
       int leftLimit = -1, rightLimit;
       int i, restoreAlphaBlending = 0;

       if (border < 0) {
              /* Refuse to fill to a non-solid border */
              return;
       }

       restoreAlphaBlending = im->alphaBlendingFlag;
       im->alphaBlendingFlag = 0;

       if (x >= im->sx) {
              x = im->sx - 1;
       }
       if (y >= im->sy) {
              y = im->sy - 1;
       }

       for (i = x; i >= 0; i--) {
              if (gdImageGetPixel(im, i, y) == border) {
                     break;
              }
              gdImageSetPixel(im, i, y, color);
              leftLimit = i;
       }
       if (leftLimit == -1) {
              im->alphaBlendingFlag = restoreAlphaBlending;
              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 = 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 = 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;
                     }
              }
       }
       im->alphaBlendingFlag = restoreAlphaBlending;
}

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 3004 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 993 of file gd.c.

{
       if (gdImageBoundsSafe(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:

Definition at line 778 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 : im->alpha[p]);
       } else {
              return p;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gdImageHLine ( gdImagePtr  im,
int  y,
int  x1,
int  x2,
int  col 
) [static]

Definition at line 1050 of file gd.c.

{
       if (im->thick > 1) {
              int thickhalf = im->thick >> 1;
              gdImageFilledRectangle(im, x1, y - thickhalf, x2, y + im->thick - thickhalf - 1, col);
       } else {
              if (x2 < x1) {
                     int t = x2;
                     x2 = x1;
                     x1 = t;
              }

              for (;x1 <= x2; x1++) {
                     gdImageSetPixel(im, x1, y, col);
              }
       }
       return;
}

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 2777 of file gd.c.

{
       im->interlace = interlaceArg;
}

Here is the caller graph for this function:

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

Definition at line 1089 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;

       if (color == gdAntiAliased) {
              /* 
                 gdAntiAliased passed as color: use the much faster, much cheaper
                 and equally attractive gdImageAALine implementation. That
                 clips too, so don't clip twice.
                 */
              gdImageAALine(im, x1, y1, x2, y2, im->AA_color); 
              return;
       }

       /* 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)) || !clip_1d(&y1,&x1,&y2,&x2,gdImageSY(im))) {
              return;
       }

       dx = abs (x2 - x1);
       dy = abs (y2 - y1);

       if (dx == 0) {
              gdImageVLine(im, x1, y1, y2, color);
              return;
       } else if (dy == 0) {
              gdImageHLine(im, y1, x1, x2, color);
              return;
       }

       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);
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImagePaletteCopy ( gdImagePtr  to,
gdImagePtr  from 
)

Definition at line 607 of file gd.c.

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

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

       for (y = 0; y < to->sy; y++) {
              for (x = 0; x < to->sx; x++) {
                     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]);
                     }
                     gdImageSetPixel(to, x, y, xlate[p]);
              }
       }

       for (i = 0; i < from->colorsTotal; 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:

Here is the caller graph for this function:

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

Definition at line 2559 of file gd.c.

{
       int i;
       int lx, ly;
       typedef void (*image_line)(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
       image_line draw_line;

       if (n <= 0) {
              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;
       }

       if ( im->antialias) {
              draw_line = gdImageAALine;
       } else {
              draw_line = gdImageLine;
       }
       lx = p->x;
       ly = p->y;
       draw_line(im, lx, ly, p[n - 1].x, p[n - 1].y, c);
       for (i = 1; i < n; i++) {
              p++;
              draw_line(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 2030 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;
       int half1 = 1;
       int t;

       if (x1 == x2 && y1 == y2 && thick == 1) {
              gdImageSetPixel(im, x1, y1, color);
              return;
       }

       if (y2 < y1) {
              t=y1;
              y1 = y2;
              y2 = t;

              t = x1;
              x1 = x2;
              x2 = t;
       }

       x1h = x1; x1v = x1; y1h = y1; y1v = y1; x2h = x2; x2v = x2; y2h = y2; y2v = y2;
       if (thick > 1) {
              int cx, cy, x1ul, y1ul, x2lr, y2lr;
              int half = thick >> 1;
              half1 = thick - half;
              x1ul = x1 - half;
              y1ul = y1 - half;
              
              x2lr = x2 + half;
              y2lr = y2 + half;

              cy = y1ul + thick;
              while (cy-- > y1ul) {
                     cx = x1ul - 1;
                     while (cx++ < x2lr) {
                            gdImageSetPixel(im, cx, cy, color);
                     }
              }

              cy = y2lr - thick;
              while (cy++ < y2lr) {
                     cx = x1ul - 1;
                     while (cx++ < x2lr) {
                            gdImageSetPixel(im, cx, cy, color);
                     }
              }

              cy = y1ul + thick - 1;
              while (cy++ < y2lr -thick) {
                     cx = x1ul - 1;
                     while (cx++ < x1ul + thick) {
                            gdImageSetPixel(im, cx, cy, color);
                     }
              }

              cy = y1ul + thick - 1;
              while (cy++ < y2lr -thick) {
                     cx = x2lr - thick - 1;
                     while (cx++ < x2lr) {
                            gdImageSetPixel(im, cx, cy, color);
                     }
              }

              return;
       } else {
              y1v = y1h + 1;
              y2v = y2h - 1;
              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 2934 of file gd.c.

{
       im->saveAlphaFlag = saveAlphaArg;
}

Here is the caller graph for this function:

static void gdImageSetAAPixelColor ( gdImagePtr  im,
int  x,
int  y,
int  color,
int  t 
) [inline, static]

Definition at line 1264 of file gd.c.

{
       int dr,dg,db,p,r,g,b;
       dr = gdTrueColorGetRed(color);
       dg = gdTrueColorGetGreen(color);
       db = gdTrueColorGetBlue(color);

       p = gdImageGetPixel(im,x,y);
       r = gdTrueColorGetRed(p);
       g = gdTrueColorGetGreen(p);
       b = gdTrueColorGetBlue(p);

       BLEND_COLOR(t, dr, r, dr);
       BLEND_COLOR(t, dg, g, dg);
       BLEND_COLOR(t, db, b, db);
       im->tpixels[y][x]=gdTrueColorAlpha(dr, dg, db,  gdAlphaOpaque);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gdImageSetAntiAliased ( gdImagePtr  im,
int  c 
)

Definition at line 2762 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 2769 of file gd.c.

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

Definition at line 2736 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:

Here is the caller graph for this function:

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

Definition at line 2972 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 716 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 (gdImageBoundsSafe(im, x, y)) {
                            if (im->trueColor) {
                                   switch (im->alphaBlendingFlag) {
                                          default:
                                          case gdEffectReplace:
                                                 im->tpixels[y][x] = color;
                                                 break;
                                          case gdEffectAlphaBlend:
                                                 im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
                                                 break;
                                          case gdEffectNormal:
                                                 im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
                                                 break;
                                          case gdEffectOverlay :
                                                 im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color);
                                                 break;
                                   }
                            } 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 2720 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:

Here is the caller graph for this function:

void gdImageSetThickness ( gdImagePtr  im,
int  thickness 
)

Definition at line 2731 of file gd.c.

{
       im->thick = thickness;
}
void gdImageSetTile ( gdImagePtr  im,
gdImagePtr  tile 
)

Definition at line 2749 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 1590 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:

Here is the caller graph for this function:

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

Definition at line 1614 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 1601 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:

Here is the caller graph for this function:

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

Definition at line 1625 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 865 of file gd.c.

{
       gdImagePtr tile = im->tile;
       int srcx, srcy;
       int p;
       if (!tile) {
              return;
       }
       srcx = x % gdImageSX(tile);
       srcy = y % gdImageSY(tile);
       if (im->trueColor) {
              p = gdImageGetPixel(tile, srcx, srcy);
              if (p != gdImageGetTransparent (tile)) {
                     if (!tile->trueColor) {
                            p = gdTrueColorAlpha(tile->red[p], tile->green[p], tile->blue[p], tile->alpha[p]);
                     }
                     gdImageSetPixel(im, x, y, p);
              }
       } else {
              p = gdImageGetPixel(tile, srcx, srcy);
              /* Allow for transparency */
              if (p != gdImageGetTransparent(tile)) {
                     if (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 int gdImageTileGet ( gdImagePtr  im,
int  x,
int  y 
) [static]

Definition at line 902 of file gd.c.

{
       int srcx, srcy;
       int tileColor,p;
       if (!im->tile) {
              return -1;
       }
       srcx = x % gdImageSX(im->tile);
       srcy = y % gdImageSY(im->tile);
       p = gdImageGetPixel(im->tile, srcx, srcy);

       if (im->trueColor) {
              if (im->tile->trueColor) {
                     tileColor = p;
              } else {
                     tileColor = gdTrueColorAlpha( gdImageRed(im->tile,p), gdImageGreen(im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
              }
       } else {
              if (im->tile->trueColor) {
                     tileColor = gdImageColorResolveAlpha(im, gdTrueColorGetRed (p), gdTrueColorGetGreen (p), gdTrueColorGetBlue (p), gdTrueColorGetAlpha (p));
              } else {
                     tileColor = p;
                     tileColor = gdImageColorResolveAlpha(im, gdImageRed (im->tile,p), gdImageGreen (im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
              }
       }
       return tileColor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gdImageVLine ( gdImagePtr  im,
int  x,
int  y1,
int  y2,
int  col 
) [static]

Definition at line 1069 of file gd.c.

{
       if (im->thick > 1) {
              int thickhalf = im->thick >> 1;
              gdImageFilledRectangle(im, x - thickhalf, y1, x + im->thick - thickhalf - 1, y2, col);
       } else {
              if (y2 < y1) {
                     int t = y1;
                     y1 = y2;
                     y2 = t;
              }

              for (;y1 <= y2; y1++) {
                     gdImageSetPixel(im, x, y1, col);
              }
       }
       return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int gdLayerOverlay ( int  dst,
int  src 
) [static]

Definition at line 2939 of file gd.c.

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 351 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.0f;  /* Undefined hues always match... */
       } else {
              diff = fabsf(HWB1.H - HWB2.H);
              if (diff > 3.0f) {
                     diff = 6.0f - 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 1650 of file gd.c.

{
       long result = (long) sqrt ((double) n);
       return result;
}
void php_gd_error ( const char *  format,
  ... 
)

Definition at line 112 of file gd.c.

{
       va_list args;

       TSRMLS_FETCH();

       va_start(args, format);
       php_verror(NULL, "", E_WARNING, format, args TSRMLS_CC);
       va_end(args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void php_gd_error_ex ( int  type,
const char *  format,
  ... 
)

Definition at line 101 of file gd.c.

{
       va_list args;

       TSRMLS_FETCH();

       va_start(args, format);
       php_verror(NULL, "", type, format, args TSRMLS_CC);
       va_end(args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HWBType* RGB_to_HWB ( RGBType  RGB,
HWBType HWB 
) [static]

Definition at line 329 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 1636 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 8 of file gdtables.c.

Definition at line 372 of file gdtables.c.