From 565f3797dc313254f52ca4b971ab28a3fb72c540 Mon Sep 17 00:00:00 2001 From: Markus Fischer Date: Thu, 6 Jun 2002 12:58:25 +0000 Subject: [PATCH] - Revert Ws thingy. # Lazy bastard :-) --- ext/gd/libgd/gd.c | 4017 +++++++++++++++++++++++++-------------------- 1 file changed, 2226 insertions(+), 1791 deletions(-) diff --git a/ext/gd/libgd/gd.c b/ext/gd/libgd/gd.c index ea230e11da..4293c521c1 100644 --- a/ext/gd/libgd/gd.c +++ b/ext/gd/libgd/gd.c @@ -6,182 +6,196 @@ #include "gd.h" #include "gdhelpers.h" -#ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */ +#ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */ #define CHARSET_EBCDIC -#define __attribute__(any) /*nothing */ +#define __attribute__(any) /*nothing */ #endif /*_OSD_POSIX*/ #ifndef CHARSET_EBCDIC #define ASC(ch) ch -#else /*CHARSET_EBCDIC */ +#else /*CHARSET_EBCDIC */ #define ASC(ch) gd_toascii[(unsigned char)ch] -static const unsigned char gd_toascii[256] = { +static const unsigned char gd_toascii[256] = +{ /*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f, - 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */ + 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */ /*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97, - 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */ + 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */ /*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b, - 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */ + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */ /*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, - 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */ + 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */ /*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5, - 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */ + 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */ /*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef, - 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */ + 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */ /*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5, - 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f, + 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f, /*-/........^,%_>?*/ /*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf, - 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */ + 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */ /*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, - 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */ + 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */ /*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, - 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */ + 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */ /*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, - 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */ + 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */ /*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc, - 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */ + 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */ /*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, - 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */ + 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */ /*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, - 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */ + 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */ /*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, - 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */ + 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */ /*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, - 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */ + 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */ }; -#endif /*CHARSET_EBCDIC */ +#endif /*CHARSET_EBCDIC */ extern int gdCosT[]; extern int gdSinT[]; -static void gdImageBrushApply(gdImagePtr im, int x, int y); -static void gdImageTileApply(gdImagePtr im, int x, int y); +static void gdImageBrushApply (gdImagePtr im, int x, int y); +static void gdImageTileApply (gdImagePtr im, int x, int y); -gdImagePtr gdImageCreate(int sx, int sy) +gdImagePtr +gdImageCreate (int sx, int sy) { - int i; - gdImagePtr im; - - im = (gdImage *) gdMalloc(sizeof(gdImage)); - memset(im, 0, sizeof(gdImage)); - /* Row-major ever since gd 1.3 */ - im->pixels = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy); - - im->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->sx = sx; - im->sy = sy; - im->colorsTotal = 0; - im->transparent = (-1); - im->interlace = 0; - im->thick = 1; - 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; - return im; + int i; + gdImagePtr im; + im = (gdImage *) gdMalloc (sizeof (gdImage)); + memset (im, 0, sizeof (gdImage)); + /* Row-major ever since gd 1.3 */ + im->pixels = (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy); + im->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->sx = sx; + im->sy = sy; + im->colorsTotal = 0; + im->transparent = (-1); + im->interlace = 0; + im->thick = 1; + 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; + return im; } -gdImagePtr gdImageCreateTrueColor(int sx, int sy) +gdImagePtr +gdImageCreateTrueColor (int sx, int sy) { - int i; - gdImagePtr im; - - im = (gdImage *) gdMalloc(sizeof(gdImage)); - memset(im, 0, sizeof(gdImage)); - im->tpixels = (int **) gdMalloc(sizeof(int *) * 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->sx = sx; - im->sy = sy; - im->transparent = (-1); - im->interlace = 0; - im->trueColor = 1; - im->saveAlphaFlag = 1; - im->alphaBlendingFlag = 0; - im->thick = 1; - return im; + int i; + gdImagePtr im; + im = (gdImage *) gdMalloc (sizeof (gdImage)); + memset (im, 0, sizeof (gdImage)); + im->tpixels = (int **) gdMalloc (sizeof (int *) * 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->sx = sx; + im->sy = sy; + im->transparent = (-1); + im->interlace = 0; + im->trueColor = 1; + im->saveAlphaFlag = 1; + im->alphaBlendingFlag = 0; + im->thick = 1; + return im; } -void gdImageDestroy(gdImagePtr im) +void +gdImageDestroy (gdImagePtr im) { - 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->polyInts) { - gdFree(im->polyInts); - } - if (im->style) { - gdFree(im->style); - } - gdFree(im); + 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->polyInts) + { + gdFree (im->polyInts); + } + if (im->style) + { + gdFree (im->style); + } + gdFree (im); } -int gdImageColorClosest(gdImagePtr im, int r, int g, int b) +int +gdImageColorClosest (gdImagePtr im, int r, int g, int b) { - return gdImageColorClosestAlpha(im, r, g, b, gdAlphaOpaque); + return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque); } -int gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a) +int +gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a) { - 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); - ad = (im->blue[i] - b); - dist = rd * rd + gd * gd + bd * bd + ad * ad; - if (first || (dist < mindist)) { - mindist = dist; - ct = i; - first = 0; - } - } - return ct; + 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); + ad = (im->blue[i] - b); + dist = rd * rd + gd * gd + bd * bd + ad * ad; + if (first || (dist < mindist)) + { + mindist = dist; + ct = i; + first = 0; + } + } + return ct; } /* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article @@ -205,64 +219,74 @@ int gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a) * red always maps to 6 in this implementation. Therefore UNDEFINED can be * defined as 0 in situations where only unsigned numbers are desired. */ -typedef struct { - float R, G, B; -} RGBType; -typedef struct { - float H, W, B; -} HWBType; - -static HWBType *RGB_to_HWB(RGBType RGB, HWBType * HWB) +typedef struct +{ + float R, G, B; +} +RGBType; +typedef struct + { + float H, W, B; + } +HWBType; + +static HWBType * +RGB_to_HWB (RGBType RGB, HWBType * HWB) { - /* - * 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. - */ + /* + * 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; + 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); + 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); } -static float HWB_Diff(int r1, int g1, int b1, int r2, int g2, int b2) +static float +HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2) { - RGBType RGB1, RGB2; - HWBType HWB1, HWB2; - float diff; - - SETUP_RGB(RGB1, r1, g1, b1); - SETUP_RGB(RGB2, r2, g2, b2); - - RGB_to_HWB(RGB1, &HWB1); - RGB_to_HWB(RGB2, &HWB2); - - /* - * I made this bit up; it seems to produce OK results, and it is certainly - * more visually correct than the current RGB metric. (PJW) - */ - - if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED)) { - diff = 0; /* Undefined hues always match... */ - } else { - diff = abs(HWB1.H - HWB2.H); - if (diff > 3) { - diff = 6 - diff; /* Remember, it's a colour circle */ - } + RGBType RGB1, RGB2; + HWBType HWB1, HWB2; + float diff; + + SETUP_RGB (RGB1, r1, g1, b1); + SETUP_RGB (RGB2, r2, g2, b2); + + RGB_to_HWB (RGB1, &HWB1); + RGB_to_HWB (RGB2, &HWB2); + + /* + * I made this bit up; it seems to produce OK results, and it is certainly + * more visually correct than the current RGB metric. (PJW) + */ + + if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED)) + { + diff = 0; /* Undefined hues always match... */ + } + else + { + diff = abs (HWB1.H - HWB2.H); + if (diff > 3) + { + diff = 6 - diff; /* Remember, it's a colour circle */ } + } - diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B); + diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B); - return diff; + return diff; } @@ -270,128 +294,146 @@ static float HWB_Diff(int r1, int g1, int b1, int r2, int g2, int b2) * This is not actually used, but is here for completeness, in case someone wants to * use the HWB stuff for anything else... */ -static RGBType *HWB_to_RGB(HWBType HWB, RGBType * RGB) +static RGBType * +HWB_to_RGB (HWBType HWB, RGBType * RGB) { - /* - * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1]. - * RGB are each returned on [0, 1]. - */ - - float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f; - int i; - - v = 1 - b; - if (h == HWB_UNDEFINED) - RETURN_RGB(v, v, v); - i = floor(h); - f = h - i; - if (i & 1) - f = 1 - f; /* if i is odd */ - n = w + f * (v - w); /* linear interpolation between w and v */ - switch (i) { - case 6: - case 0: - RETURN_RGB(v, n, w); - case 1: - RETURN_RGB(n, v, w); - case 2: - RETURN_RGB(w, v, n); - case 3: - RETURN_RGB(w, n, v); - case 4: - RETURN_RGB(n, w, v); - case 5: - RETURN_RGB(v, w, n); - } - - return RGB; + /* + * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1]. + * RGB are each returned on [0, 1]. + */ + + float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f; + int i; + + v = 1 - b; + if (h == HWB_UNDEFINED) + RETURN_RGB (v, v, v); + i = floor (h); + f = h - i; + if (i & 1) + f = 1 - f; /* if i is odd */ + n = w + f * (v - w); /* linear interpolation between w and v */ + switch (i) + { + case 6: + case 0: + RETURN_RGB (v, n, w); + case 1: + RETURN_RGB (n, v, w); + case 2: + RETURN_RGB (w, v, n); + case 3: + RETURN_RGB (w, n, v); + case 4: + RETURN_RGB (n, w, v); + case 5: + RETURN_RGB (v, w, n); + } + + return RGB; } -int gdImageColorClosestHWB(gdImagePtr im, int r, int g, int b) +int +gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b) { - 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; + 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; } -int gdImageColorExact(gdImagePtr im, int r, int g, int b) +int +gdImageColorExact (gdImagePtr im, int r, int g, int b) { - return gdImageColorExactAlpha(im, r, g, b, gdAlphaOpaque); + return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque); } -int gdImageColorExactAlpha(gdImagePtr im, int r, int g, int b, int a) +int +gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a) { - 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; + 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; } -int gdImageColorAllocate(gdImagePtr im, int r, int g, int b) +int +gdImageColorAllocate (gdImagePtr im, int r, int g, int b) { - return gdImageColorAllocateAlpha(im, r, g, b, gdAlphaOpaque); + return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque); } -int gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a) +int +gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a) { - 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; + 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; } /* @@ -405,666 +447,835 @@ int gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a) * return a color index in one search over the color table. */ -int gdImageColorResolve(gdImagePtr im, int r, int g, int b) +int +gdImageColorResolve (gdImagePtr im, int r, int g, int b) { - return gdImageColorResolveAlpha(im, r, g, b, gdAlphaOpaque); + return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque); } -int gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a) +int +gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a) { - 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 */ - } - 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 */ + 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 */ + } + 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 */ } -void gdImageColorDeallocate(gdImagePtr im, int color) +void +gdImageColorDeallocate (gdImagePtr im, int color) { - if (im->trueColor) { - return; - } - /* Mark it open. */ - im->open[color] = 1; + if (im->trueColor) + { + return; + } + /* Mark it open. */ + im->open[color] = 1; } -void gdImageColorTransparent(gdImagePtr im, int color) +void +gdImageColorTransparent (gdImagePtr im, int color) { - if (!im->trueColor) { - if (im->transparent != -1) { - im->alpha[im->transparent] = gdAlphaOpaque; - } - if (color != -1) { - im->alpha[color] = gdAlphaTransparent; - } - } - im->transparent = color; + if (!im->trueColor) + { + if (im->transparent != -1) + { + im->alpha[im->transparent] = gdAlphaOpaque; + } + if (color != -1) + { + im->alpha[color] = gdAlphaTransparent; + } + } + im->transparent = color; } -void gdImagePaletteCopy(gdImagePtr to, gdImagePtr from) +void +gdImagePaletteCopy (gdImagePtr to, gdImagePtr from) { - int i; - int x, y, p; - int xlate[256]; - - if (to->trueColor) { - return; - } - if (from->trueColor) { - return; - } - - for (i = 0; i < 256; i++) { - xlate[i] = -1; + int i; + int x, y, p; + int xlate[256]; + if (to->trueColor) + { + return; + } + if (from->trueColor) + { + return; + } + + for (i = 0; i < 256; i++) + { + xlate[i] = -1; + }; + + for (x = 0; x < (to->sx); x++) + { + for (y = 0; y < (to->sy); y++) + { + p = gdImageGetPixel (to, x, y); + if (xlate[p] == -1) + { + /* This ought to use HWB, but we don't have an alpha-aware + version of that yet. */ + xlate[p] = gdImageColorClosestAlpha (from, to->red[p], to->green[p], to->blue[p], to->alpha[p]); + /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */ + /* p, to->red[p], to->green[p], to->blue[p], to->alpha[p], */ + /* xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */ + }; + gdImageSetPixel (to, x, y, xlate[p]); }; + }; - for (x = 0; x < (to->sx); x++) { - for (y = 0; y < (to->sy); y++) { - p = gdImageGetPixel(to, x, y); - if (xlate[p] == -1) { - /* This ought to use HWB, but we don't have an alpha-aware - version of that yet. */ - xlate[p] = gdImageColorClosestAlpha(from, to->red[p], to->green[p], to->blue[p], to->alpha[p]); - /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */ - /* p, to->red[p], to->green[p], to->blue[p], to->alpha[p], */ - /* xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */ - }; - gdImageSetPixel(to, x, y, xlate[p]); - }; - }; + for (i = 0; (i < (from->colorsTotal)); i++) + { + /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */ + to->red[i] = from->red[i]; + to->blue[i] = from->blue[i]; + to->green[i] = from->green[i]; + to->alpha[i] = from->alpha[i]; + to->open[i] = 0; + }; - for (i = 0; (i < (from->colorsTotal)); i++) { - /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */ - to->red[i] = from->red[i]; - to->blue[i] = from->blue[i]; - to->green[i] = from->green[i]; - to->alpha[i] = from->alpha[i]; - to->open[i] = 0; - }; - - for (i = from->colorsTotal; (i < to->colorsTotal); i++) { - to->open[i] = 1; - }; + for (i = from->colorsTotal; (i < to->colorsTotal); i++) + { + to->open[i] = 1; + }; - to->colorsTotal = from->colorsTotal; + to->colorsTotal = from->colorsTotal; } -void gdImageSetPixel(gdImagePtr im, int x, int y, int color) +void +gdImageSetPixel (gdImagePtr im, int x, int y, int color) { - 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; - default: - if (gdImageBoundsSafe(im, x, y)) { - if (im->trueColor) { - if (im->alphaBlendingFlag) { - im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color); - } else { - im->tpixels[y][x] = color; - } - } else { - im->pixels[y][x] = color; - } - } - break; - } + 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; + default: + if (gdImageBoundsSafe (im, x, y)) + { + if (im->trueColor) + { + if (im->alphaBlendingFlag) + { + im->tpixels[y][x] = + gdAlphaBlend (im->tpixels[y][x], + color); + } + else + { + im->tpixels[y][x] = color; + } + } + else + { + im->pixels[y][x] = color; + } + } + break; + } } -static void gdImageBrushApply(gdImagePtr im, int x, int y) +static void +gdImageBrushApply (gdImagePtr im, int x, int y) { - int lx, ly; - int hy; - int hx; - int x1, y1, x2, y2; - int srcx, srcy; - - if (!im->brush) { - return; - } - hy = gdImageSY(im->brush) / 2; - y1 = y - hy; - y2 = y1 + gdImageSY(im->brush); - hx = gdImageSX(im->brush) / 2; - x1 = x - hx; - x2 = x1 + gdImageSX(im->brush); - srcy = 0; - if (im->trueColor) { - for (ly = y1; (ly < y2); ly++) { - srcx = 0; - for (lx = x1; (lx < x2); lx++) { - int p; - - p = gdImageGetTrueColorPixel(im->brush, srcx, srcy); - gdImageSetPixel(im, lx, ly, p); - 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++; - } - } + int lx, ly; + int hy; + int hx; + int x1, y1, x2, y2; + int srcx, srcy; + if (!im->brush) + { + return; + } + hy = gdImageSY (im->brush) / 2; + y1 = y - hy; + y2 = y1 + gdImageSY (im->brush); + hx = gdImageSX (im->brush) / 2; + x1 = x - hx; + x2 = x1 + gdImageSX (im->brush); + srcy = 0; + if (im->trueColor) + { + for (ly = y1; (ly < y2); ly++) + { + srcx = 0; + for (lx = x1; (lx < x2); lx++) + { + int p; + p = gdImageGetTrueColorPixel ( + im->brush, srcx, srcy); + gdImageSetPixel (im, lx, ly, + p); + 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++; + } + } } -static void gdImageTileApply(gdImagePtr im, int x, int y) +static void +gdImageTileApply (gdImagePtr im, int x, int y) { - int srcx, srcy; - int p; - - if (!im->tile) { - return; - } - srcx = x % gdImageSX(im->tile); - srcy = y % gdImageSY(im->tile); - if (im->trueColor) { - p = gdImageGetTrueColorPixel(im->tile, srcx, srcy); - gdImageSetPixel(im, x, y, p); - } else { - p = gdImageGetPixel(im->tile, srcx, srcy); - /* Allow for transparency */ - if (p != gdImageGetTransparent(im->tile)) { - if (im->tile->trueColor) { - /* Truecolor tile. Very slow - on a palette destination. */ - gdImageSetPixel(im, x, y, gdImageColorResolveAlpha(im, gdTrueColorGetRed(p), - gdTrueColorGetGreen(p), - gdTrueColorGetBlue(p), - gdTrueColorGetAlpha(p))); - } else { - gdImageSetPixel(im, x, y, im->tileColorMap[p]); - } - } - } + int srcx, srcy; + int p; + if (!im->tile) + { + return; + } + srcx = x % gdImageSX (im->tile); + srcy = y % gdImageSY (im->tile); + if (im->trueColor) + { + p = gdImageGetTrueColorPixel (im->tile, srcx, srcy); + gdImageSetPixel (im, x, y, p); + } + else + { + p = gdImageGetPixel(im->tile, srcx, srcy); + /* Allow for transparency */ + if (p != gdImageGetTransparent (im->tile)) + { + if (im->tile->trueColor) + { + /* Truecolor tile. Very slow + on a palette destination. */ + gdImageSetPixel (im, x, y, + gdImageColorResolveAlpha ( + im, + gdTrueColorGetRed (p), + gdTrueColorGetGreen (p), + gdTrueColorGetBlue (p), + gdTrueColorGetAlpha (p))); + } + else + { + gdImageSetPixel (im, x, y, + im->tileColorMap[p]); + } + } + } } -int gdImageGetPixel(gdImagePtr im, int x, int y) +int +gdImageGetPixel (gdImagePtr im, int x, int y) { - if (gdImageBoundsSafe(im, x, y)) { - if (im->trueColor) { - return im->tpixels[y][x]; - } else { - return im->pixels[y][x]; - } - } else { - return 0; - } + if (gdImageBoundsSafe (im, x, y)) + { + if (im->trueColor) + { + return im->tpixels[y][x]; + } + else + { + return im->pixels[y][x]; + } + } + else + { + return 0; + } } -int gdImageGetTrueColorPixel(gdImagePtr im, int x, int y) +int +gdImageGetTrueColorPixel (gdImagePtr im, int x, int y) { - int p = gdImageGetPixel(im, x, y); - - if (!im->trueColor) { - return gdTrueColorAlpha(im->red[p], im->green[p], im->blue[p], (im->transparent == p) ? - gdAlphaTransparent : gdAlphaOpaque); - } else { - return p; - } + int p = gdImageGetPixel (im, x, y); + if (!im->trueColor) + { + return gdTrueColorAlpha (im->red[p], im->green[p], im->blue[p], + (im->transparent == p) ? gdAlphaTransparent : + gdAlphaOpaque); + } + else + { + return p; + } } /* Bresenham as presented in Foley & Van Dam */ -void gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color) +void +gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color) { - int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; - int wid; - int w, wstart; - int thick = im->thick; - - dx = abs(x2 - x1); - dy = abs(y2 - y1); - if (dy <= dx) { - /* More-or-less horizontal. use wid for vertical stroke */ - wid = thick * cos(atan2(dy, dx)); - 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 */ - wid = thick * sin(atan2(dy, dx)); - 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); - } - } - } + int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; + int wid; + int w, wstart; + int thick = im->thick; + dx = abs (x2 - x1); + dy = abs (y2 - y1); + if (dy <= dx) + { + /* More-or-less horizontal. use wid for vertical stroke */ + wid = thick * cos (atan2 (dy, dx)); + 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 */ + wid = thick * sin (atan2 (dy, dx)); + 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); + } + } + } } -static void dashedSet(gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert); +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 +gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color) { - int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; - int dashStep = 0; - int on = 1; - int wid; - int w, wstart, 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 */ - wid = 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 { - /* More-or-less vertical. use wid for horizontal stroke */ - wid = thick * sin(atan2(dy, dx)); - 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); - } - } - } + int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; + int dashStep = 0; + int on = 1; + int wid; + int w, wstart, 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 */ + wid = 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 + { + /* More-or-less vertical. use wid for horizontal stroke */ + wid = thick * sin (atan2 (dy, dx)); + 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); + } + } + } } -static void dashedSet(gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert) +static void +dashedSet (gdImagePtr im, int x, int y, int color, + int *onP, int *dashStepP, int wid, int vert) { - 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; + 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; } -int gdImageBoundsSafe(gdImagePtr im, int x, int y) +int +gdImageBoundsSafe (gdImagePtr im, int x, int y) { - return (!(((y < 0) || (y >= im->sy)) || ((x < 0) || (x >= im->sx)))); + return (!(((y < 0) || (y >= im->sy)) || + ((x < 0) || (x >= im->sx)))); } -void gdImageChar(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color) +void +gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, + int c, int color) { - int cx, cy; - int px, py; - int fline; - - cx = 0; - cy = 0; + 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++; - } + 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++; + } } -void gdImageCharUp(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) { - int cx, cy; - int px, py; - int fline; - - cx = 0; - cy = 0; + 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++; - } + 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++; + } } -void gdImageString(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color) +void +gdImageString (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned char *s, int color) { - 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; - } + 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; + } } -void gdImageStringUp(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) { - 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; - } + 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; + } } -static int strlen16(unsigned short *s); +static int strlen16 (unsigned short *s); -void gdImageString16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color) +void +gdImageString16 (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned short *s, int color) { - int i; - int l; - - l = strlen16(s); - for (i = 0; (i < l); i++) { - gdImageChar(im, f, x, y, s[i], color); - x += f->w; - } + int i; + int l; + l = strlen16 (s); + for (i = 0; (i < l); i++) + { + gdImageChar (im, f, x, y, s[i], color); + x += f->w; + } } -void gdImageStringUp16(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) { - int i; - int l; - - l = strlen16(s); - for (i = 0; (i < l); i++) { - gdImageCharUp(im, f, x, y, s[i], color); - y -= f->w; - } + int i; + int l; + l = strlen16 (s); + for (i = 0; (i < l); i++) + { + gdImageCharUp (im, f, x, y, s[i], color); + y -= f->w; + } } -static int strlen16(unsigned short *s) +static int +strlen16 (unsigned short *s) { - int len = 0; - - while (*s) { - s++; - len++; - } - return len; + int len = 0; + while (*s) + { + s++; + len++; + } + return len; } #ifndef HAVE_LSQRT /* If you don't have a nice square root function for longs, you can use ** this hack */ -long lsqrt(long n) +long +lsqrt (long n) { - long result = (long) sqrt((double) n); - - return result; + long result = (long) sqrt ((double) n); + return result; } #endif @@ -1075,571 +1286,689 @@ long lsqrt(long n) See gd_arc_f_buggy.c for a better version that doesn't seem to be bug-free yet. */ -void gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color) +void +gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color) { - gdImageFilledArc(im, cx, cy, w, h, s, e, color, gdNoFill); + gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill); } -void gdImageFilledArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style) +void +gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style) { - gdPoint pts[3]; - int i; - int lx = 0, ly = 0; - int fx, fy; - int w2, h2; - - w2 = w / 2; - h2 = h / 2; - while (e < s) { - e += 360; - } - for (i = s; (i <= e); i++) { - int x, y; - - x = ((long) gdCosT[i % 360] * (long) w2 / 1024) + cx; - y = ((long) gdSinT[i % 360] * (long) h2 / 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); - } - } - } + gdPoint pts[3]; + int i; + int lx = 0, ly = 0; + int fx, fy; + int w2, h2; + w2 = w / 2; + h2 = h / 2; + while (e < s) + { + e += 360; + } + for (i = s; (i <= e); i++) + { + int x, y; + x = ((long) gdCosT[i % 360] * (long) w2 / 1024) + cx; + y = ((long) gdSinT[i % 360] * (long) h2 / 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); + } + } + } } -void gdImageFilledEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color) +void +gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, int color) { - gdImageFilledArc(im, cx, cy, w, h, 0, 360, color, gdPie); + gdImageFilledArc (im, cx, cy, w, h, 0, 360, color, gdPie); } -void gdImageFillToBorder(gdImagePtr im, int x, int y, int border, int color) +void +gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color) { - int lastBorder; - - /* Seek left */ - int leftLimit, rightLimit; - int i; - - leftLimit = (-1); - if (border < 0) { - /* Refuse to fill to a non-solid border */ - return; - } - for (i = x; (i >= 0); i--) { - if (gdImageGetPixel(im, i, y) == border) { - break; - } - gdImageSetPixel(im, i, y, color); - leftLimit = i; - } - if (leftLimit == (-1)) { - return; - } - /* Seek right */ - rightLimit = x; - for (i = (x + 1); (i < im->sx); i++) { - if (gdImageGetPixel(im, i, y) == border) { - break; - } - gdImageSetPixel(im, i, y, color); - rightLimit = i; - } - /* Look at lines above and below and start paints */ - /* Above */ - if (y > 0) { - lastBorder = 1; - for (i = leftLimit; (i <= rightLimit); i++) { - int c; - - c = gdImageGetPixel(im, i, y - 1); - if (lastBorder) { - if ((c != border) && (c != color)) { - gdImageFillToBorder(im, i, y - 1, border, color); - lastBorder = 0; - } - } else if ((c == border) || (c == color)) { - lastBorder = 1; - } - } - } - /* Below */ - if (y < ((im->sy) - 1)) { - lastBorder = 1; - for (i = leftLimit; (i <= rightLimit); i++) { - int c; - - c = gdImageGetPixel(im, i, y + 1); - if (lastBorder) { - if ((c != border) && (c != color)) { - gdImageFillToBorder(im, i, y + 1, border, color); - lastBorder = 0; - } - } else if ((c == border) || (c == color)) { - lastBorder = 1; - } - } - } + int lastBorder; + /* Seek left */ + int leftLimit, rightLimit; + int i; + leftLimit = (-1); + if (border < 0) + { + /* Refuse to fill to a non-solid border */ + return; + } + for (i = x; (i >= 0); i--) + { + if (gdImageGetPixel (im, i, y) == border) + { + break; + } + gdImageSetPixel (im, i, y, color); + leftLimit = i; + } + if (leftLimit == (-1)) + { + return; + } + /* Seek right */ + rightLimit = x; + for (i = (x + 1); (i < im->sx); i++) + { + if (gdImageGetPixel (im, i, y) == border) + { + break; + } + gdImageSetPixel (im, i, y, color); + rightLimit = i; + } + /* Look at lines above and below and start paints */ + /* Above */ + if (y > 0) + { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) + { + int c; + c = gdImageGetPixel (im, i, y - 1); + if (lastBorder) + { + if ((c != border) && (c != color)) + { + gdImageFillToBorder (im, i, y - 1, + border, color); + lastBorder = 0; + } + } + else if ((c == border) || (c == color)) + { + lastBorder = 1; + } + } + } + /* Below */ + if (y < ((im->sy) - 1)) + { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) + { + int c; + c = gdImageGetPixel (im, i, y + 1); + if (lastBorder) + { + if ((c != border) && (c != color)) + { + gdImageFillToBorder (im, i, y + 1, + border, color); + lastBorder = 0; + } + } + else if ((c == border) || (c == color)) + { + lastBorder = 1; + } + } + } } -void gdImageFill(gdImagePtr im, int x, int y, int color) +void +gdImageFill (gdImagePtr im, int x, int y, int color) { - int lastBorder; - int old; - int leftLimit, rightLimit; - int i; - - old = gdImageGetPixel(im, x, y); - if (color == gdTiled) { - /* Tile fill -- got to watch out! */ - int p, tileColor; - int srcx, srcy; - - if (!im->tile) { - return; - } - /* Refuse to flood-fill with a transparent pattern -- - I can't do it without allocating another image */ - if (gdImageGetTransparent(im->tile) != (-1)) { - return; - } - srcx = x % gdImageSX(im->tile); - srcy = y % gdImageSY(im->tile); - p = gdImageGetPixel(im->tile, srcx, srcy); - if (im->trueColor) { - tileColor = p; - } else { - if (im->tile->trueColor) { - tileColor = gdImageColorResolveAlpha(im, gdTrueColorGetRed(p), - gdTrueColorGetGreen(p), - gdTrueColorGetBlue(p), - gdTrueColorGetAlpha(p)); - } else { - tileColor = im->tileColorMap[p]; - } - } - if (old == tileColor) { - /* Nothing to be done */ - return; - } - } else { - if (old == color) { - /* Nothing to be done */ - return; - } - } - /* Seek left */ - leftLimit = (-1); - for (i = x; (i >= 0); i--) { - if (gdImageGetPixel(im, i, y) != old) { - break; - } - gdImageSetPixel(im, i, y, color); - leftLimit = i; - } - if (leftLimit == (-1)) { - return; - } - /* Seek right */ - rightLimit = x; - for (i = (x + 1); (i < im->sx); i++) { - if (gdImageGetPixel(im, i, y) != old) { - break; - } - gdImageSetPixel(im, i, y, color); - rightLimit = i; - } - /* Look at lines above and below and start paints */ - /* Above */ - if (y > 0) { - lastBorder = 1; - for (i = leftLimit; (i <= rightLimit); i++) { - int c; - - c = gdImageGetPixel(im, i, y - 1); - if (lastBorder) { - if (c == old) { - gdImageFill(im, i, y - 1, color); - lastBorder = 0; - } - } else if (c != old) { - lastBorder = 1; - } - } - } - /* Below */ - if (y < ((im->sy) - 1)) { - lastBorder = 1; - for (i = leftLimit; (i <= rightLimit); i++) { - int c; - - c = gdImageGetPixel(im, i, y + 1); - if (lastBorder) { - if (c == old) { - gdImageFill(im, i, y + 1, color); - lastBorder = 0; - } - } else if (c != old) { - lastBorder = 1; - } - } - } + int lastBorder; + int old; + int leftLimit, rightLimit; + int i; + old = gdImageGetPixel (im, x, y); + if (color == gdTiled) + { + /* Tile fill -- got to watch out! */ + int p, tileColor; + int srcx, srcy; + if (!im->tile) + { + return; + } + /* Refuse to flood-fill with a transparent pattern -- + I can't do it without allocating another image */ + if (gdImageGetTransparent (im->tile) != (-1)) + { + return; + } + srcx = x % gdImageSX (im->tile); + srcy = y % gdImageSY (im->tile); + p = gdImageGetPixel (im->tile, srcx, srcy); + if (im->trueColor) + { + tileColor = p; + } + else + { + if (im->tile->trueColor) + { + tileColor = gdImageColorResolveAlpha (im, + gdTrueColorGetRed (p), + gdTrueColorGetGreen (p), + gdTrueColorGetBlue (p), + gdTrueColorGetAlpha (p)); + } + else + { + tileColor = im->tileColorMap[p]; + } + } + if (old == tileColor) + { + /* Nothing to be done */ + return; + } + } + else + { + if (old == color) + { + /* Nothing to be done */ + return; + } + } + /* Seek left */ + leftLimit = (-1); + for (i = x; (i >= 0); i--) + { + if (gdImageGetPixel (im, i, y) != old) + { + break; + } + gdImageSetPixel (im, i, y, color); + leftLimit = i; + } + if (leftLimit == (-1)) + { + return; + } + /* Seek right */ + rightLimit = x; + for (i = (x + 1); (i < im->sx); i++) + { + if (gdImageGetPixel (im, i, y) != old) + { + break; + } + gdImageSetPixel (im, i, y, color); + rightLimit = i; + } + /* Look at lines above and below and start paints */ + /* Above */ + if (y > 0) + { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) + { + int c; + c = gdImageGetPixel (im, i, y - 1); + if (lastBorder) + { + if (c == old) + { + gdImageFill (im, i, y - 1, color); + lastBorder = 0; + } + } + else if (c != old) + { + lastBorder = 1; + } + } + } + /* Below */ + if (y < ((im->sy) - 1)) + { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) + { + int c; + c = gdImageGetPixel (im, i, y + 1); + if (lastBorder) + { + if (c == old) + { + gdImageFill (im, i, y + 1, color); + lastBorder = 0; + } + } + else if (c != old) + { + lastBorder = 1; + } + } + } } -void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color) +void +gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color) { - int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2, y2v = y2; - int thick = im->thick; - - if (thick > 1) { - int half = thick / 2; - int half1 = thick - half; - - if (y1 < y2) { - y1v = y1h - half; - y2v = y2h + half1 - 1; - } else { - y1v = y1h + half1 - 1; - y2v = y2h - half; - } - } - - gdImageLine(im, x1h, y1h, x2h, y1h, color); - gdImageLine(im, x1h, y2h, x2h, y2h, color); - gdImageLine(im, x1v, y1v, x1v, y2v, color); - gdImageLine(im, x2v, y1v, x2v, y2v, color); + int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2, + y2v = y2; + int thick = im->thick; + if (thick > 1) + { + int half = thick / 2; + int half1 = thick - half; + + if (y1 < y2) + { + y1v = y1h - half; + y2v = y2h + half1 - 1; + } + else + { + y1v = y1h + half1 - 1; + y2v = y2h - half; + } + } + + gdImageLine (im, x1h, y1h, x2h, y1h, color); + gdImageLine (im, x1h, y2h, x2h, y2h, color); + gdImageLine (im, x1v, y1v, x1v, y2v, color); + gdImageLine (im, x2v, y1v, x2v, y2v, color); } -void gdImageFilledRectangle(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) { - int x, y; - - for (y = y1; (y <= y2); y++) { - for (x = x1; (x <= x2); x++) { - gdImageSetPixel(im, x, y, color); - } - } + int x, y; + for (y = y1; (y <= y2); y++) + { + for (x = x1; (x <= x2); x++) + { + gdImageSetPixel (im, x, y, color); + } + } } -void gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h) +void +gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h) { - 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. */ - - 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); + 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. */ + + 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 { + } + 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, gdTrueColor(src->red[c], - src->green[c], - src->blue[c])); + 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, + gdTrueColor(src->red[c], src->green[c], src->blue[c])); } - } - } - } - return; - } - for (i = 0; (i < gdMaxColors); i++) { - colorMap[i] = (-1); - } - toy = dstY; - for (y = srcY; (y < (srcY + h)); y++) { - tox = dstX; - for (x = srcX; (x < (srcX + w)); x++) { - int nc; - - 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 (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; - } - gdImageSetPixel(dst, tox, toy, colorMap[c]); - tox++; } - toy++; - } + } + } + return; + } + for (i = 0; (i < gdMaxColors); i++) + { + colorMap[i] = (-1); + } + toy = dstY; + for (y = srcY; (y < (srcY + h)); y++) + { + tox = dstX; + for (x = srcX; (x < (srcX + w)); x++) + { + int nc; + 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 (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; + } + gdImageSetPixel (dst, tox, toy, colorMap[c]); + tox++; + } + toy++; + } } /* This function is a substitute for real alpha channel operations, so it doesn't pay attention to the alpha channel. */ -void gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) +void +gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) { - int c, dc; - int x, y; - int tox, toy; - int ncR, ncG, ncB; - - toy = dstY; - for (y = srcY; (y < (srcY + h)); y++) { - tox = dstX; - for (x = srcX; (x < (srcX + w)); x++) { - int nc; - - c = gdImageGetPixel(src, x, y); - /* Added 7/24/95: support transparent copies */ - if (gdImageGetTransparent(src) == c) { - tox++; - continue; - } - /* If it's the same image, mapping is trivial */ - if (dst == src) { - nc = c; - } else { - dc = gdImageGetPixel(dst, tox, toy); - - ncR = gdImageRed(src, c) * (pct / 100.0) - + gdImageRed(dst, dc) * ((100 - pct) / 100.0); - ncG = gdImageGreen(src, c) * (pct / 100.0) - + gdImageGreen(dst, dc) * ((100 - pct) / 100.0); - ncB = gdImageBlue(src, c) * (pct / 100.0) - + gdImageBlue(dst, dc) * ((100 - pct) / 100.0); - - /* Find a reasonable color */ - nc = gdImageColorResolve(dst, ncR, ncG, ncB); - } - gdImageSetPixel(dst, tox, toy, nc); - tox++; - } - toy++; - } + int c, dc; + int x, y; + int tox, toy; + int ncR, ncG, ncB; + toy = dstY; + for (y = srcY; (y < (srcY + h)); y++) + { + tox = dstX; + for (x = srcX; (x < (srcX + w)); x++) + { + int nc; + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) + { + tox++; + continue; + } + /* If it's the same image, mapping is trivial */ + if (dst == src) + { + nc = c; + } + else + { + dc = gdImageGetPixel (dst, tox, toy); + + ncR = gdImageRed (src, c) * (pct / 100.0) + + gdImageRed (dst, dc) * ((100 - pct) / 100.0); + ncG = gdImageGreen (src, c) * (pct / 100.0) + + gdImageGreen (dst, dc) * ((100 - pct) / 100.0); + ncB = gdImageBlue (src, c) * (pct / 100.0) + + gdImageBlue (dst, dc) * ((100 - pct) / 100.0); + + /* Find a reasonable color */ + nc = gdImageColorResolve (dst, ncR, ncG, ncB); + } + gdImageSetPixel (dst, tox, toy, nc); + tox++; + } + toy++; + } } /* This function is a substitute for real alpha channel operations, so it doesn't pay attention to the alpha channel. */ -void gdImageCopyMergeGray(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) { - 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 trivial */ - if (dst == src) { - nc = c; - } else { - dc = gdImageGetPixel(dst, tox, toy); - g = 0.29900 * dst->red[dc] - + 0.58700 * dst->green[dc] - + 0.11400 * dst->blue[dc]; - - ncR = gdImageRed(src, c) * (pct / 100.0) - + gdImageRed(dst, dc) * g * ((100 - pct) / 100.0); - ncG = gdImageGreen(src, c) * (pct / 100.0) - + gdImageGreen(dst, dc) * g * ((100 - pct) / 100.0); - ncB = gdImageBlue(src, c) * (pct / 100.0) - + gdImageBlue(dst, dc) * 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++; - } + 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 trivial */ + if (dst == src) + { + nc = c; + } + else + { + dc = gdImageGetPixel (dst, tox, toy); + g = 0.29900 * dst->red[dc] + + 0.58700 * dst->green[dc] + + 0.11400 * dst->blue[dc]; + + ncR = gdImageRed (src, c) * (pct / 100.0) + + gdImageRed (dst, dc) * g * + ((100 - pct) / 100.0); + ncG = gdImageGreen (src, c) * (pct / 100.0) + + gdImageGreen (dst, dc) * g * + ((100 - pct) / 100.0); + ncB = gdImageBlue (src, c) * (pct / 100.0) + + gdImageBlue (dst, dc) * 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++; + } } -void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) +void +gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) { - int c; - int x, y; - int tox, toy; - int ydest; - int i; - int colorMap[gdMaxColors]; - - /* Stretch vectors */ - int *stx; - int *sty; - - /* We only need to use floating point to determine the correct - stretch vector for one line's worth. */ - double accum; - stx = (int *) gdMalloc(sizeof(int) * srcW); - sty = (int *) gdMalloc(sizeof(int) * srcH); - - accum = 0; - for (i = 0; (i < srcW); i++) { - int got; - - accum += (double) dstW / (double) srcW; - got = (int) floor(accum); - stx[i] = got; - accum -= got; - } - accum = 0; - for (i = 0; (i < srcH); i++) { - int got; - - accum += (double) dstH / (double) srcH; - got = (int) floor(accum); - sty[i] = got; - accum -= got; - } - for (i = 0; (i < gdMaxColors); i++) { - colorMap[i] = (-1); - } - toy = dstY; - for (y = srcY; (y < (srcY + srcH)); y++) { - for (ydest = 0; (ydest < sty[y - srcY]); ydest++) { - tox = dstX; - for (x = srcX; (x < (srcX + srcW)); x++) { - int nc; - int mapTo; - - if (!stx[x - srcX]) { - continue; - } - if (dst->trueColor) { - int d; - - mapTo = gdImageGetTrueColorPixel(src, x, y); - /* Added 7/24/95: support transparent copies */ - if (gdImageGetTransparent(src) == mapTo) { - tox++; - continue; - } - } else { - c = gdImageGetPixel(src, x, y); - /* Added 7/24/95: support transparent copies */ - if (gdImageGetTransparent(src) == c) { - tox += stx[x - srcX]; - continue; - } - if (src->trueColor) { - /* Remap to the palette available in the - destination image. This is slow and - works badly. */ - mapTo = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c), - gdTrueColorGetGreen(c), - gdTrueColorGetBlue(c), - gdTrueColorGetAlpha(c)); - } else { - /* Have we established a mapping for this color? */ - if (colorMap[c] == (-1)) { - /* If it's the same image, mapping is trivial */ - if (dst == src) { - nc = c; - } else { - /* Find or create the best match */ - mapTo = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c), - gdTrueColorGetGreen(c), - gdTrueColorGetBlue(c), - gdTrueColorGetAlpha(c)); - } - colorMap[c] = nc; - } - mapTo = colorMap[c]; - } - } - for (i = 0; (i < stx[x - srcX]); i++) { - gdImageSetPixel(dst, tox, toy, mapTo); - tox++; - } + int c; + int x, y; + int tox, toy; + int ydest; + int i; + int colorMap[gdMaxColors]; + /* Stretch vectors */ + int *stx; + int *sty; + /* We only need to use floating point to determine the correct + stretch vector for one line's worth. */ + double accum; + stx = (int *) gdMalloc (sizeof (int) * srcW); + sty = (int *) gdMalloc (sizeof (int) * srcH); + accum = 0; + for (i = 0; (i < srcW); i++) + { + int got; + accum += (double) dstW / (double) srcW; + got = (int) floor (accum); + stx[i] = got; + accum -= got; + } + accum = 0; + for (i = 0; (i < srcH); i++) + { + int got; + accum += (double) dstH / (double) srcH; + got = (int) floor (accum); + sty[i] = got; + accum -= got; + } + for (i = 0; (i < gdMaxColors); i++) + { + colorMap[i] = (-1); + } + toy = dstY; + for (y = srcY; (y < (srcY + srcH)); y++) + { + for (ydest = 0; (ydest < sty[y - srcY]); ydest++) + { + tox = dstX; + for (x = srcX; (x < (srcX + srcW)); x++) + { + int nc; + int mapTo; + if (!stx[x - srcX]) + { + continue; + } + if (dst->trueColor) + { + int d; + mapTo = gdImageGetTrueColorPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == mapTo) + { + tox++; + continue; + } + } + else + { + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) + { + tox += stx[x - srcX]; + continue; + } + if (src->trueColor) + { + /* Remap to the palette available in the + destination image. This is slow and + works badly. */ + mapTo = gdImageColorResolveAlpha (dst, + gdTrueColorGetRed (c), + gdTrueColorGetGreen (c), + gdTrueColorGetBlue (c), + gdTrueColorGetAlpha (c)); + } + else + { + /* Have we established a mapping for this color? */ + if (colorMap[c] == (-1)) + { + /* If it's the same image, mapping is trivial */ + if (dst == src) + { + nc = c; + } + else + { + /* Find or create the best match */ + mapTo = gdImageColorResolveAlpha (dst, + gdTrueColorGetRed (c), + gdTrueColorGetGreen (c), + gdTrueColorGetBlue (c), + gdTrueColorGetAlpha (c)); + } + colorMap[c] = nc; } - toy++; + mapTo = colorMap[c]; + } } + for (i = 0; (i < stx[x - srcX]); i++) + { + gdImageSetPixel (dst, tox, toy, mapTo); + tox++; + } + } + toy++; } - gdFree(stx); - gdFree(sty); + } + gdFree (stx); + gdFree (sty); } /* When gd 1.x was first created, floating point was to be avoided. @@ -1647,225 +1976,282 @@ void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int arithmetic. The routine below is shamelessly, gloriously floating point. TBB */ -void gdImageCopyResampled(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) { - int x, y; - float sx, sy; - - if (!dst->trueColor) { - gdImageCopyResized(dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH); - return; - } - for (y = dstY; (y < dstY + dstH); y++) { - for (x = dstX; (x < dstX + dstW); x++) { - int pd = gdImageGetPixel(dst, x, y); - float sy1, sy2, sx1, sx2; - float sx, sy; - float spixels = 0; - float red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0; - - sy1 = ((float) y - (float) dstY) * (float) srcH / (float) dstH; - sy2 = ((float) (y + 1) - (float) dstY) * (float) srcH / (float) dstH; - sy = sy1; - do { - float yportion; - - if (floor(sy) == floor(sy1)) { - yportion = 1.0 - (sy - floor(sy)); - if (yportion > sy2 - sy1) { - yportion = sy2 - sy1; - } - sy = floor(sy); - } else if (sy == floor(sy2)) { - yportion = sy2 - floor(sy2); - } else { - yportion = 1.0; - } - sx1 = ((float) x - (float) dstX) * (float) srcW / dstW; - sx2 = ((float) (x + 1) - (float) dstX) * (float) srcW / dstW; - sx = sx1; - do { - float xportion; - float pcontribution; - int p; - - if (floor(sx) == floor(sx1)) { - xportion = 1.0 - (sx - floor(sx)); - if (xportion > sx2 - sx1) { - xportion = sx2 - sx1; - } - sx = floor(sx); - } else if (sx == floor(sx2)) { - xportion = sx2 - floor(sx2); - } else { - xportion = 1.0; - } - pcontribution = xportion * yportion; - p = gdImageGetTrueColorPixel(src, (int) sx + srcX, (int) sy + srcY); - red += gdTrueColorGetRed(p) * pcontribution; - green += gdTrueColorGetGreen(p) * pcontribution; - blue += gdTrueColorGetBlue(p) * pcontribution; - alpha += gdTrueColorGetAlpha(p) * pcontribution; - spixels += xportion * yportion; - sx += 1.0; - } - while (sx < sx2); - sy += 1.0; - } - while (sy < sy2); - if (spixels != 0.0) { - red /= spixels; - green /= spixels; - blue /= spixels; - alpha /= spixels; - } - /* Clamping to allow for rounding errors above */ - if (red > 255.0) { - red = 255.0; - } - if (green > 255.0) { - green = 255.0; - } - if (blue > 255.0) { - blue = 255.0; + int x, y; + float sx, sy; + if (!dst->trueColor) + { + gdImageCopyResized ( + dst, src, dstX, dstY, srcX, srcY, dstW, dstH, + srcW, srcH); + return; + } + for (y = dstY; (y < dstY + dstH); y++) + { + for (x = dstX; (x < dstX + dstW); x++) + { + int pd = gdImageGetPixel (dst, x, y); + float sy1, sy2, sx1, sx2; + float sx, sy; + float spixels = 0; + float red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0; + sy1 = ((float) y - (float) dstY) * (float) srcH / + (float) dstH; + sy2 = ((float) (y + 1) - (float) dstY) * (float) srcH / + (float) dstH; + sy = sy1; + do + { + float yportion; + if (floor (sy) == floor (sy1)) + { + yportion = 1.0 - (sy - floor (sy)); + if (yportion > sy2 - sy1) + { + yportion = sy2 - sy1; + } + sy = floor (sy); + } + else if (sy == floor (sy2)) + { + yportion = sy2 - floor (sy2); + } + else + { + yportion = 1.0; + } + sx1 = ((float) x - (float) dstX) * (float) srcW / + dstW; + sx2 = ((float) (x + 1) - (float) dstX) * (float) srcW / + dstW; + sx = sx1; + do + { + float xportion; + float pcontribution; + int p; + if (floor (sx) == floor (sx1)) + { + xportion = 1.0 - (sx - floor (sx)); + if (xportion > sx2 - sx1) + { + xportion = sx2 - sx1; } - if (alpha > gdAlphaMax) { - alpha = gdAlphaMax; - } - gdImageSetPixel(dst, x, y, gdTrueColorAlpha((int) red, (int) green, (int) blue, (int) alpha)); - } - } + sx = floor (sx); + } + else if (sx == floor (sx2)) + { + xportion = sx2 - floor (sx2); + } + else + { + xportion = 1.0; + } + pcontribution = xportion * yportion; + p = gdImageGetTrueColorPixel ( + src, + (int) sx + srcX, + (int) sy + srcY); + red += gdTrueColorGetRed (p) * pcontribution; + green += gdTrueColorGetGreen (p) * pcontribution; + blue += gdTrueColorGetBlue (p) * pcontribution; + alpha += gdTrueColorGetAlpha (p) * pcontribution; + spixels += xportion * yportion; + sx += 1.0; + } + while (sx < sx2); + sy += 1.0; + } + while (sy < sy2); + if (spixels != 0.0) + { + red /= spixels; + green /= spixels; + blue /= spixels; + alpha /= spixels; + } + /* Clamping to allow for rounding errors above */ + if (red > 255.0) + { + red = 255.0; + } + if (green > 255.0) + { + green = 255.0; + } + if (blue > 255.0) + { + blue = 255.0; + } + if (alpha > gdAlphaMax) + { + alpha = gdAlphaMax; + } + gdImageSetPixel (dst, + x, y, + gdTrueColorAlpha ((int) red, + (int) green, + (int) blue, + (int) alpha)); + } + } } -gdImagePtr gdImageCreateFromXbm(FILE * fd) +gdImagePtr +gdImageCreateFromXbm (FILE * fd) { - gdImagePtr im; - int bit; - int w, h; - int bytes; - int ch; - int i, x, y; - char *sp; - char s[161]; - - if (!fgets(s, 160, fd)) { - return 0; - } - sp = &s[0]; - /* Skip #define */ - sp = strchr(sp, ' '); - if (!sp) { - return 0; - } - /* Skip width label */ - sp++; - sp = strchr(sp, ' '); - if (!sp) { - return 0; - } - /* Get width */ - w = atoi(sp + 1); - if (!w) { - return 0; - } - if (!fgets(s, 160, fd)) { - return 0; - } - sp = s; - /* Skip #define */ - sp = strchr(sp, ' '); - if (!sp) { - return 0; - } - /* Skip height label */ - sp++; - sp = strchr(sp, ' '); - if (!sp) { - return 0; - } - /* Get height */ - h = atoi(sp + 1); - if (!h) { - return 0; - } - /* Skip declaration line */ - if (!fgets(s, 160, fd)) { - return 0; - } - bytes = (w * h / 8) + 1; - im = gdImageCreate(w, h); - gdImageColorAllocate(im, 255, 255, 255); - gdImageColorAllocate(im, 0, 0, 0); - x = 0; - y = 0; - for (i = 0; (i < bytes); i++) { - char h[3]; - int b; - - /* Skip spaces, commas, CRs, 0x */ - while (1) { - ch = getc(fd); - if (ch == EOF) { - goto fail; - } - if (ch == 'x') { - break; - } - } - /* Get hex value */ - ch = getc(fd); - if (ch == EOF) { - goto fail; - } - h[0] = ch; - ch = getc(fd); - if (ch == EOF) { - goto fail; - } - h[1] = ch; - h[2] = '\0'; - sscanf(h, "%x", &b); - for (bit = 1; (bit <= 128); (bit = bit << 1)) { - gdImageSetPixel(im, x++, y, (b & bit) ? 1 : 0); - if (x == im->sx) { - x = 0; - y++; - if (y == im->sy) { - return im; - } - /* Fix 8/8/95 */ - break; - } - } - } - /* Shouldn't happen */ - fprintf(stderr, "Error: bug in gdImageCreateFromXbm!\n"); - return 0; - fail: - gdImageDestroy(im); - return 0; + gdImagePtr im; + int bit; + int w, h; + int bytes; + int ch; + int i, x, y; + char *sp; + char s[161]; + if (!fgets (s, 160, fd)) + { + return 0; + } + sp = &s[0]; + /* Skip #define */ + sp = strchr (sp, ' '); + if (!sp) + { + return 0; + } + /* Skip width label */ + sp++; + sp = strchr (sp, ' '); + if (!sp) + { + return 0; + } + /* Get width */ + w = atoi (sp + 1); + if (!w) + { + return 0; + } + if (!fgets (s, 160, fd)) + { + return 0; + } + sp = s; + /* Skip #define */ + sp = strchr (sp, ' '); + if (!sp) + { + return 0; + } + /* Skip height label */ + sp++; + sp = strchr (sp, ' '); + if (!sp) + { + return 0; + } + /* Get height */ + h = atoi (sp + 1); + if (!h) + { + return 0; + } + /* Skip declaration line */ + if (!fgets (s, 160, fd)) + { + return 0; + } + bytes = (w * h / 8) + 1; + im = gdImageCreate (w, h); + gdImageColorAllocate (im, 255, 255, 255); + gdImageColorAllocate (im, 0, 0, 0); + x = 0; + y = 0; + for (i = 0; (i < bytes); i++) + { + char h[3]; + int b; + /* Skip spaces, commas, CRs, 0x */ + while (1) + { + ch = getc (fd); + if (ch == EOF) + { + goto fail; + } + if (ch == 'x') + { + break; + } + } + /* Get hex value */ + ch = getc (fd); + if (ch == EOF) + { + goto fail; + } + h[0] = ch; + ch = getc (fd); + if (ch == EOF) + { + goto fail; + } + h[1] = ch; + h[2] = '\0'; + sscanf (h, "%x", &b); + for (bit = 1; (bit <= 128); (bit = bit << 1)) + { + gdImageSetPixel (im, x++, y, (b & bit) ? 1 : 0); + if (x == im->sx) + { + x = 0; + y++; + if (y == im->sy) + { + return im; + } + /* Fix 8/8/95 */ + break; + } + } + } + /* Shouldn't happen */ + fprintf (stderr, "Error: bug in gdImageCreateFromXbm!\n"); + return 0; +fail: + gdImageDestroy (im); + return 0; } -void gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c) +void +gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c) { - int i; - int lx, ly; - - if (!n) { - return; - } - lx = p->x; - ly = p->y; - gdImageLine(im, lx, ly, p[n - 1].x, p[n - 1].y, c); - for (i = 1; (i < n); i++) { - p++; - gdImageLine(im, lx, ly, p->x, p->y, c); - lx = p->x; - ly = p->y; - } + int i; + int lx, ly; + if (!n) + { + return; + } + lx = p->x; + ly = p->y; + gdImageLine (im, lx, ly, p[n - 1].x, p[n - 1].y, c); + for (i = 1; (i < n); i++) + { + p++; + gdImageLine (im, lx, ly, p->x, p->y, c); + lx = p->x; + ly = p->y; + } } -int gdCompareInt(const void *a, const void *b); +int gdCompareInt (const void *a, const void *b); /* THANKS to Kirsten Schulz for the polygon fixes! */ @@ -1874,238 +2260,287 @@ int gdCompareInt(const void *a, const void *b); /* That could help to adjust intersections to produce a nice */ /* interior_extrema. */ -void gdImageFilledPolygon(gdImagePtr im, gdPointPtr p, int n, int c) +void +gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c) { - int i; - int y; - int miny, maxy; - int x1, y1; - int x2, y2; - int ind1, ind2; - int ints; - - if (!n) { - return; - } - if (!im->polyAllocated) { - im->polyInts = (int *) gdMalloc(sizeof(int) * n); - - im->polyAllocated = n; - } - if (im->polyAllocated < n) { - while (im->polyAllocated < n) { - im->polyAllocated *= 2; - } - im->polyInts = (int *) gdRealloc(im->polyInts, sizeof(int) * im->polyAllocated); - } - miny = p[0].y; - maxy = p[0].y; - for (i = 1; (i < n); i++) { - if (p[i].y < miny) { - miny = p[i].y; - } - if (p[i].y > maxy) { - maxy = p[i].y; - } - } - /* Fix in 1.3: count a vertex only once */ - for (y = miny; (y <= maxy); y++) { + int i; + int y; + int miny, maxy; + int x1, y1; + int x2, y2; + int ind1, ind2; + int ints; + if (!n) + { + return; + } + if (!im->polyAllocated) + { + im->polyInts = (int *) gdMalloc (sizeof (int) * n); + im->polyAllocated = n; + } + if (im->polyAllocated < n) + { + while (im->polyAllocated < n) + { + im->polyAllocated *= 2; + } + im->polyInts = (int *) gdRealloc (im->polyInts, + sizeof (int) * im->polyAllocated); + } + miny = p[0].y; + maxy = p[0].y; + for (i = 1; (i < n); i++) + { + if (p[i].y < miny) + { + miny = p[i].y; + } + if (p[i].y > maxy) + { + maxy = p[i].y; + } + } + /* Fix in 1.3: count a vertex only once */ + for (y = miny; (y <= maxy); y++) + { /*1.4 int interLast = 0; */ /* int dirLast = 0; */ /* int interFirst = 1; */ - ints = 0; - for (i = 0; (i < n); i++) { - if (!i) { - ind1 = n - 1; - ind2 = 0; - } else { - ind1 = i - 1; - ind2 = i; - } - y1 = p[ind1].y; - y2 = p[ind2].y; - if (y1 < y2) { - x1 = p[ind1].x; - x2 = p[ind2].x; - } else if (y1 > y2) { - y2 = p[ind1].y; - y1 = p[ind2].y; - x2 = p[ind1].x; - x1 = p[ind2].x; - } else { - continue; - } - if ((y >= y1) && (y < y2)) { - im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1; - } else if ((y == maxy) && (y > y1) && (y <= y2)) { - im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1; - } - } - qsort(im->polyInts, ints, sizeof(int), gdCompareInt); - - for (i = 0; (i < (ints)); i += 2) { - gdImageLine(im, im->polyInts[i], y, im->polyInts[i + 1], y, c); - } - } + 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; + } + if ((y >= y1) && (y < y2)) + { + im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1; + } + else if ((y == maxy) && (y > y1) && (y <= y2)) + { + im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1; + } + } + qsort (im->polyInts, ints, sizeof (int), gdCompareInt); + + for (i = 0; (i < (ints)); i += 2) + { + gdImageLine (im, im->polyInts[i], y, + im->polyInts[i + 1], y, c); + } + } } -int gdCompareInt(const void *a, const void *b) +int +gdCompareInt (const void *a, const void *b) { - return (*(const int *) a) - (*(const int *) b); + return (*(const int *) a) - (*(const int *) b); } -void gdImageSetStyle(gdImagePtr im, int *style, int noOfPixels) +void +gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels) { - 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; + 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; } -void gdImageSetThickness(gdImagePtr im, int thickness) +void +gdImageSetThickness (gdImagePtr im, int thickness) { - im->thick = thickness; + im->thick = thickness; } -void gdImageSetBrush(gdImagePtr im, gdImagePtr brush) +void +gdImageSetBrush (gdImagePtr im, gdImagePtr brush) { - 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; - } - } + 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; + } + } } -void gdImageSetTile(gdImagePtr im, gdImagePtr tile) +void +gdImageSetTile (gdImagePtr im, gdImagePtr tile) { - 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; - } - } + 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; + } + } } -void gdImageInterlace(gdImagePtr im, int interlaceArg) +void +gdImageInterlace (gdImagePtr im, int interlaceArg) { - im->interlace = interlaceArg; + im->interlace = interlaceArg; } -int gdImageCompare(gdImagePtr im1, gdImagePtr im2) +int +gdImageCompare (gdImagePtr im1, gdImagePtr im2) { - 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->pixels[y][x]; - p2 = im2->pixels[y][x]; - 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; - } + 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->pixels[y][x]; + p2 = im2->pixels[y][x]; + 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; - } + /* 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; - }; } + if (cmpStatus & GD_CMP_COLOR) + { + break; + }; + } - return cmpStatus; + return cmpStatus; } -int gdAlphaBlend(int dst, int src) +int +gdAlphaBlend (int dst, int src) { - return (((((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)); + return (((((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)); } -void gdImageAlphaBlending(gdImagePtr im, int alphaBlendingArg) +void +gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg) { - im->alphaBlendingFlag = alphaBlendingArg; + im->alphaBlendingFlag = alphaBlendingArg; } -void gdImageSaveAlpha(gdImagePtr im, int saveAlphaArg) +void +gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg) { - im->saveAlphaFlag = saveAlphaArg; + im->saveAlphaFlag = saveAlphaArg; } -- 2.40.0