#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
* 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;
}
* 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;
}
/*
* 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
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.
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! */
/* 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;
}
projects / php / commitdiff