Annotation of embedaddon/php/ext/gd/libgd/gd.c, revision 1.1
1.1 ! misho 1:
! 2: #include <math.h>
! 3: #include <string.h>
! 4: #include <stdlib.h>
! 5: #include "gd.h"
! 6: #include "gdhelpers.h"
! 7:
! 8: #include "php.h"
! 9:
! 10: #ifdef _MSC_VER
! 11: # if _MSC_VER >= 1300
! 12: /* in MSVC.NET these are available but only for __cplusplus and not _MSC_EXTENSIONS */
! 13: # if !defined(_MSC_EXTENSIONS) && defined(__cplusplus)
! 14: # define HAVE_FABSF 1
! 15: extern float fabsf(float x);
! 16: # define HAVE_FLOORF 1
! 17: extern float floorf(float x);
! 18: # endif /*MSVC.NET */
! 19: # endif /* MSC */
! 20: #endif
! 21: #ifndef HAVE_FABSF
! 22: # define HAVE_FABSF 0
! 23: #endif
! 24: #ifndef HAVE_FLOORF
! 25: # define HAVE_FLOORF 0
! 26: #endif
! 27: #if HAVE_FABSF == 0
! 28: /* float fabsf(float x); */
! 29: # ifndef fabsf
! 30: # define fabsf(x) ((float)(fabs(x)))
! 31: # endif
! 32: #endif
! 33: #if HAVE_FLOORF == 0
! 34: # ifndef floorf
! 35: /* float floorf(float x);*/
! 36: # define floorf(x) ((float)(floor(x)))
! 37: # endif
! 38: #endif
! 39:
! 40: #ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */
! 41: #define CHARSET_EBCDIC
! 42: #define __attribute__(any) /*nothing */
! 43: #endif
! 44: /*_OSD_POSIX*/
! 45:
! 46: #ifndef CHARSET_EBCDIC
! 47: #define ASC(ch) ch
! 48: #else /*CHARSET_EBCDIC */
! 49: #define ASC(ch) gd_toascii[(unsigned char)ch]
! 50: static const unsigned char gd_toascii[256] =
! 51: {
! 52: /*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f,
! 53: 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */
! 54: /*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97,
! 55: 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */
! 56: /*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b,
! 57: 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */
! 58: /*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
! 59: 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */
! 60: /*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5,
! 61: 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */
! 62: /*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef,
! 63: 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */
! 64: /*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5,
! 65: 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
! 66: /*-/........^,%_>?*/
! 67: /*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
! 68: 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */
! 69: /*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
! 70: 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */
! 71: /*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
! 72: 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */
! 73: /*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
! 74: 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */
! 75: /*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc,
! 76: 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */
! 77: /*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
! 78: 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */
! 79: /*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
! 80: 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */
! 81: /*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
! 82: 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */
! 83: /*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
! 84: 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */
! 85: };
! 86: #endif /*CHARSET_EBCDIC */
! 87:
! 88: /* 2.0.10: cast instead of floor() yields 35% performance improvement. Thanks to John Buckman. */
! 89: #define floor_cast(exp) ((long) exp)
! 90:
! 91: extern int gdCosT[];
! 92: extern int gdSinT[];
! 93:
! 94: static void gdImageBrushApply(gdImagePtr im, int x, int y);
! 95: static void gdImageTileApply(gdImagePtr im, int x, int y);
! 96: static void gdImageAntiAliasedApply(gdImagePtr im, int x, int y);
! 97: static int gdLayerOverlay(int dst, int src);
! 98: static int gdAlphaOverlayColor(int src, int dst, int max);
! 99: int gdImageGetTrueColorPixel(gdImagePtr im, int x, int y);
! 100:
! 101: void php_gd_error_ex(int type, const char *format, ...)
! 102: {
! 103: va_list args;
! 104:
! 105: TSRMLS_FETCH();
! 106:
! 107: va_start(args, format);
! 108: php_verror(NULL, "", type, format, args TSRMLS_CC);
! 109: va_end(args);
! 110: }
! 111:
! 112: void php_gd_error(const char *format, ...)
! 113: {
! 114: va_list args;
! 115:
! 116: TSRMLS_FETCH();
! 117:
! 118: va_start(args, format);
! 119: php_verror(NULL, "", E_WARNING, format, args TSRMLS_CC);
! 120: va_end(args);
! 121: }
! 122:
! 123: gdImagePtr gdImageCreate (int sx, int sy)
! 124: {
! 125: int i;
! 126: gdImagePtr im;
! 127:
! 128: if (overflow2(sx, sy)) {
! 129: return NULL;
! 130: }
! 131:
! 132: if (overflow2(sizeof(unsigned char *), sy)) {
! 133: return NULL;
! 134: }
! 135:
! 136: im = (gdImage *) gdCalloc(1, sizeof(gdImage));
! 137:
! 138: /* Row-major ever since gd 1.3 */
! 139: im->pixels = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy);
! 140: im->AA_opacity = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy);
! 141: im->polyInts = 0;
! 142: im->polyAllocated = 0;
! 143: im->brush = 0;
! 144: im->tile = 0;
! 145: im->style = 0;
! 146: for (i = 0; i < sy; i++) {
! 147: /* Row-major ever since gd 1.3 */
! 148: im->pixels[i] = (unsigned char *) gdCalloc(sx, sizeof(unsigned char));
! 149: im->AA_opacity[i] = (unsigned char *) gdCalloc(sx, sizeof(unsigned char));
! 150: }
! 151: im->sx = sx;
! 152: im->sy = sy;
! 153: im->colorsTotal = 0;
! 154: im->transparent = (-1);
! 155: im->interlace = 0;
! 156: im->thick = 1;
! 157: im->AA = 0;
! 158: im->AA_polygon = 0;
! 159: for (i = 0; i < gdMaxColors; i++) {
! 160: im->open[i] = 1;
! 161: im->red[i] = 0;
! 162: im->green[i] = 0;
! 163: im->blue[i] = 0;
! 164: }
! 165: im->trueColor = 0;
! 166: im->tpixels = 0;
! 167: im->cx1 = 0;
! 168: im->cy1 = 0;
! 169: im->cx2 = im->sx - 1;
! 170: im->cy2 = im->sy - 1;
! 171: return im;
! 172: }
! 173:
! 174: gdImagePtr gdImageCreateTrueColor (int sx, int sy)
! 175: {
! 176: int i;
! 177: gdImagePtr im;
! 178:
! 179: if (overflow2(sx, sy)) {
! 180: return NULL;
! 181: }
! 182:
! 183: if (overflow2(sizeof(unsigned char *), sy)) {
! 184: return NULL;
! 185: }
! 186:
! 187: if (overflow2(sizeof(int), sx)) {
! 188: return NULL;
! 189: }
! 190:
! 191: im = (gdImage *) gdMalloc(sizeof(gdImage));
! 192: memset(im, 0, sizeof(gdImage));
! 193: im->tpixels = (int **) gdMalloc(sizeof(int *) * sy);
! 194: im->AA_opacity = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy);
! 195: im->polyInts = 0;
! 196: im->polyAllocated = 0;
! 197: im->brush = 0;
! 198: im->tile = 0;
! 199: im->style = 0;
! 200: for (i = 0; i < sy; i++) {
! 201: im->tpixels[i] = (int *) gdCalloc(sx, sizeof(int));
! 202: im->AA_opacity[i] = (unsigned char *) gdCalloc(sx, sizeof(unsigned char));
! 203: }
! 204: im->sx = sx;
! 205: im->sy = sy;
! 206: im->transparent = (-1);
! 207: im->interlace = 0;
! 208: im->trueColor = 1;
! 209: /* 2.0.2: alpha blending is now on by default, and saving of alpha is
! 210: * off by default. This allows font antialiasing to work as expected
! 211: * on the first try in JPEGs -- quite important -- and also allows
! 212: * for smaller PNGs when saving of alpha channel is not really
! 213: * desired, which it usually isn't!
! 214: */
! 215: im->saveAlphaFlag = 0;
! 216: im->alphaBlendingFlag = 1;
! 217: im->thick = 1;
! 218: im->AA = 0;
! 219: im->AA_polygon = 0;
! 220: im->cx1 = 0;
! 221: im->cy1 = 0;
! 222: im->cx2 = im->sx - 1;
! 223: im->cy2 = im->sy - 1;
! 224: return im;
! 225: }
! 226:
! 227: void gdImageDestroy (gdImagePtr im)
! 228: {
! 229: int i;
! 230: if (im->pixels) {
! 231: for (i = 0; i < im->sy; i++) {
! 232: gdFree(im->pixels[i]);
! 233: }
! 234: gdFree(im->pixels);
! 235: }
! 236: if (im->tpixels) {
! 237: for (i = 0; i < im->sy; i++) {
! 238: gdFree(im->tpixels[i]);
! 239: }
! 240: gdFree(im->tpixels);
! 241: }
! 242: if (im->AA_opacity) {
! 243: for (i = 0; i < im->sy; i++) {
! 244: gdFree(im->AA_opacity[i]);
! 245: }
! 246: gdFree(im->AA_opacity);
! 247: }
! 248: if (im->polyInts) {
! 249: gdFree(im->polyInts);
! 250: }
! 251: if (im->style) {
! 252: gdFree(im->style);
! 253: }
! 254: gdFree(im);
! 255: }
! 256:
! 257: int gdImageColorClosest (gdImagePtr im, int r, int g, int b)
! 258: {
! 259: return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
! 260: }
! 261:
! 262: int gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
! 263: {
! 264: int i;
! 265: long rd, gd, bd, ad;
! 266: int ct = (-1);
! 267: int first = 1;
! 268: long mindist = 0;
! 269:
! 270: if (im->trueColor) {
! 271: return gdTrueColorAlpha(r, g, b, a);
! 272: }
! 273: for (i = 0; i < im->colorsTotal; i++) {
! 274: long dist;
! 275: if (im->open[i]) {
! 276: continue;
! 277: }
! 278: rd = im->red[i] - r;
! 279: gd = im->green[i] - g;
! 280: bd = im->blue[i] - b;
! 281: /* gd 2.02: whoops, was - b (thanks to David Marwood) */
! 282: ad = im->alpha[i] - a;
! 283: dist = rd * rd + gd * gd + bd * bd + ad * ad;
! 284: if (first || (dist < mindist)) {
! 285: mindist = dist;
! 286: ct = i;
! 287: first = 0;
! 288: }
! 289: }
! 290: return ct;
! 291: }
! 292:
! 293: /* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article
! 294: * on colour conversion to/from RBG and HWB colour systems.
! 295: * It has been modified to return the converted value as a * parameter.
! 296: */
! 297:
! 298: #define RETURN_HWB(h, w, b) {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}
! 299: #define RETURN_RGB(r, g, b) {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}
! 300: #define HWB_UNDEFINED -1
! 301: #define SETUP_RGB(s, r, g, b) {s.R = r/255.0f; s.G = g/255.0f; s.B = b/255.0f;}
! 302:
! 303: #ifndef MIN
! 304: #define MIN(a,b) ((a)<(b)?(a):(b))
! 305: #endif
! 306: #define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c)))
! 307: #ifndef MAX
! 308: #define MAX(a,b) ((a)<(b)?(b):(a))
! 309: #endif
! 310: #define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c)))
! 311:
! 312:
! 313: /*
! 314: * Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure
! 315: * red always maps to 6 in this implementation. Therefore UNDEFINED can be
! 316: * defined as 0 in situations where only unsigned numbers are desired.
! 317: */
! 318: typedef struct
! 319: {
! 320: float R, G, B;
! 321: }
! 322: RGBType;
! 323: typedef struct
! 324: {
! 325: float H, W, B;
! 326: }
! 327: HWBType;
! 328:
! 329: static HWBType * RGB_to_HWB (RGBType RGB, HWBType * HWB)
! 330: {
! 331: /*
! 332: * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is
! 333: * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.
! 334: */
! 335:
! 336: float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
! 337: int i;
! 338:
! 339: w = MIN3 (R, G, B);
! 340: v = MAX3 (R, G, B);
! 341: b = 1 - v;
! 342: if (v == w) {
! 343: RETURN_HWB(HWB_UNDEFINED, w, b);
! 344: }
! 345: f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
! 346: i = (R == w) ? 3 : ((G == w) ? 5 : 1);
! 347:
! 348: RETURN_HWB(i - f / (v - w), w, b);
! 349: }
! 350:
! 351: static float HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2)
! 352: {
! 353: RGBType RGB1, RGB2;
! 354: HWBType HWB1, HWB2;
! 355: float diff;
! 356:
! 357: SETUP_RGB(RGB1, r1, g1, b1);
! 358: SETUP_RGB(RGB2, r2, g2, b2);
! 359:
! 360: RGB_to_HWB(RGB1, &HWB1);
! 361: RGB_to_HWB(RGB2, &HWB2);
! 362:
! 363: /*
! 364: * I made this bit up; it seems to produce OK results, and it is certainly
! 365: * more visually correct than the current RGB metric. (PJW)
! 366: */
! 367:
! 368: if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED)) {
! 369: diff = 0.0f; /* Undefined hues always match... */
! 370: } else {
! 371: diff = fabsf(HWB1.H - HWB2.H);
! 372: if (diff > 3.0f) {
! 373: diff = 6.0f - diff; /* Remember, it's a colour circle */
! 374: }
! 375: }
! 376:
! 377: diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B);
! 378:
! 379: return diff;
! 380: }
! 381:
! 382:
! 383: #if 0
! 384: /*
! 385: * This is not actually used, but is here for completeness, in case someone wants to
! 386: * use the HWB stuff for anything else...
! 387: */
! 388: static RGBType * HWB_to_RGB (HWBType HWB, RGBType * RGB)
! 389: {
! 390: /*
! 391: * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1].
! 392: * RGB are each returned on [0, 1].
! 393: */
! 394:
! 395: float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f;
! 396: int i;
! 397:
! 398: v = 1 - b;
! 399: if (h == HWB_UNDEFINED) {
! 400: RETURN_RGB(v, v, v);
! 401: }
! 402: i = floor(h);
! 403: f = h - i;
! 404: if (i & 1) {
! 405: f = 1 - f; /* if i is odd */
! 406: }
! 407: n = w + f * (v - w); /* linear interpolation between w and v */
! 408: switch (i) {
! 409: case 6:
! 410: case 0:
! 411: RETURN_RGB(v, n, w);
! 412: case 1:
! 413: RETURN_RGB(n, v, w);
! 414: case 2:
! 415: RETURN_RGB(w, v, n);
! 416: case 3:
! 417: RETURN_RGB(w, n, v);
! 418: case 4:
! 419: RETURN_RGB(n, w, v);
! 420: case 5:
! 421: RETURN_RGB(v, w, n);
! 422: }
! 423:
! 424: return RGB;
! 425: }
! 426: #endif
! 427:
! 428: int gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
! 429: {
! 430: int i;
! 431: /* long rd, gd, bd; */
! 432: int ct = (-1);
! 433: int first = 1;
! 434: float mindist = 0;
! 435: if (im->trueColor) {
! 436: return gdTrueColor(r, g, b);
! 437: }
! 438: for (i = 0; i < im->colorsTotal; i++) {
! 439: float dist;
! 440: if (im->open[i]) {
! 441: continue;
! 442: }
! 443: dist = HWB_Diff(im->red[i], im->green[i], im->blue[i], r, g, b);
! 444: if (first || (dist < mindist)) {
! 445: mindist = dist;
! 446: ct = i;
! 447: first = 0;
! 448: }
! 449: }
! 450: return ct;
! 451: }
! 452:
! 453: int gdImageColorExact (gdImagePtr im, int r, int g, int b)
! 454: {
! 455: return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
! 456: }
! 457:
! 458: int gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
! 459: {
! 460: int i;
! 461: if (im->trueColor) {
! 462: return gdTrueColorAlpha(r, g, b, a);
! 463: }
! 464: for (i = 0; i < im->colorsTotal; i++) {
! 465: if (im->open[i]) {
! 466: continue;
! 467: }
! 468: if ((im->red[i] == r) && (im->green[i] == g) && (im->blue[i] == b) && (im->alpha[i] == a)) {
! 469: return i;
! 470: }
! 471: }
! 472: return -1;
! 473: }
! 474:
! 475: int gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
! 476: {
! 477: return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
! 478: }
! 479:
! 480: int gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
! 481: {
! 482: int i;
! 483: int ct = (-1);
! 484: if (im->trueColor) {
! 485: return gdTrueColorAlpha(r, g, b, a);
! 486: }
! 487: for (i = 0; i < im->colorsTotal; i++) {
! 488: if (im->open[i]) {
! 489: ct = i;
! 490: break;
! 491: }
! 492: }
! 493: if (ct == (-1)) {
! 494: ct = im->colorsTotal;
! 495: if (ct == gdMaxColors) {
! 496: return -1;
! 497: }
! 498: im->colorsTotal++;
! 499: }
! 500: im->red[ct] = r;
! 501: im->green[ct] = g;
! 502: im->blue[ct] = b;
! 503: im->alpha[ct] = a;
! 504: im->open[ct] = 0;
! 505:
! 506: return ct;
! 507: }
! 508:
! 509: /*
! 510: * gdImageColorResolve is an alternative for the code fragment:
! 511: *
! 512: * if ((color=gdImageColorExact(im,R,G,B)) < 0)
! 513: * if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
! 514: * color=gdImageColorClosest(im,R,G,B);
! 515: *
! 516: * in a single function. Its advantage is that it is guaranteed to
! 517: * return a color index in one search over the color table.
! 518: */
! 519:
! 520: int gdImageColorResolve (gdImagePtr im, int r, int g, int b)
! 521: {
! 522: return gdImageColorResolveAlpha(im, r, g, b, gdAlphaOpaque);
! 523: }
! 524:
! 525: int gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
! 526: {
! 527: int c;
! 528: int ct = -1;
! 529: int op = -1;
! 530: long rd, gd, bd, ad, dist;
! 531: long mindist = 4 * 255 * 255; /* init to max poss dist */
! 532: if (im->trueColor)
! 533: {
! 534: return gdTrueColorAlpha (r, g, b, a);
! 535: }
! 536:
! 537: for (c = 0; c < im->colorsTotal; c++)
! 538: {
! 539: if (im->open[c])
! 540: {
! 541: op = c; /* Save open slot */
! 542: continue; /* Color not in use */
! 543: }
! 544: if (c == im->transparent)
! 545: {
! 546: /* don't ever resolve to the color that has
! 547: * been designated as the transparent color */
! 548: continue;
! 549: }
! 550: rd = (long) (im->red[c] - r);
! 551: gd = (long) (im->green[c] - g);
! 552: bd = (long) (im->blue[c] - b);
! 553: ad = (long) (im->alpha[c] - a);
! 554: dist = rd * rd + gd * gd + bd * bd + ad * ad;
! 555: if (dist < mindist)
! 556: {
! 557: if (dist == 0)
! 558: {
! 559: return c; /* Return exact match color */
! 560: }
! 561: mindist = dist;
! 562: ct = c;
! 563: }
! 564: }
! 565: /* no exact match. We now know closest, but first try to allocate exact */
! 566: if (op == -1)
! 567: {
! 568: op = im->colorsTotal;
! 569: if (op == gdMaxColors)
! 570: { /* No room for more colors */
! 571: return ct; /* Return closest available color */
! 572: }
! 573: im->colorsTotal++;
! 574: }
! 575: im->red[op] = r;
! 576: im->green[op] = g;
! 577: im->blue[op] = b;
! 578: im->alpha[op] = a;
! 579: im->open[op] = 0;
! 580: return op; /* Return newly allocated color */
! 581: }
! 582:
! 583: void gdImageColorDeallocate (gdImagePtr im, int color)
! 584: {
! 585: if (im->trueColor) {
! 586: return;
! 587: }
! 588: /* Mark it open. */
! 589: im->open[color] = 1;
! 590: }
! 591:
! 592: void gdImageColorTransparent (gdImagePtr im, int color)
! 593: {
! 594: if (!im->trueColor) {
! 595: if (im->transparent != -1) {
! 596: im->alpha[im->transparent] = gdAlphaOpaque;
! 597: }
! 598: if (color > -1 && color < im->colorsTotal && color < gdMaxColors) {
! 599: im->alpha[color] = gdAlphaTransparent;
! 600: } else {
! 601: return;
! 602: }
! 603: }
! 604: im->transparent = color;
! 605: }
! 606:
! 607: void gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
! 608: {
! 609: int i;
! 610: int x, y, p;
! 611: int xlate[256];
! 612: if (to->trueColor || from->trueColor) {
! 613: return;
! 614: }
! 615:
! 616: for (i = 0; i < 256; i++) {
! 617: xlate[i] = -1;
! 618: }
! 619:
! 620: for (y = 0; y < to->sy; y++) {
! 621: for (x = 0; x < to->sx; x++) {
! 622: p = gdImageGetPixel(to, x, y);
! 623: if (xlate[p] == -1) {
! 624: /* This ought to use HWB, but we don't have an alpha-aware version of that yet. */
! 625: xlate[p] = gdImageColorClosestAlpha (from, to->red[p], to->green[p], to->blue[p], to->alpha[p]);
! 626: }
! 627: gdImageSetPixel(to, x, y, xlate[p]);
! 628: }
! 629: }
! 630:
! 631: for (i = 0; i < from->colorsTotal; i++) {
! 632: to->red[i] = from->red[i];
! 633: to->blue[i] = from->blue[i];
! 634: to->green[i] = from->green[i];
! 635: to->alpha[i] = from->alpha[i];
! 636: to->open[i] = 0;
! 637: }
! 638:
! 639: for (i = from->colorsTotal; i < to->colorsTotal; i++) {
! 640: to->open[i] = 1;
! 641: }
! 642:
! 643: to->colorsTotal = from->colorsTotal;
! 644: }
! 645:
! 646: /* 2.0.10: before the drawing routines, some code to clip points that are
! 647: * outside the drawing window. Nick Atty (nick@canalplan.org.uk)
! 648: *
! 649: * This is the Sutherland Hodgman Algorithm, as implemented by
! 650: * Duvanenko, Robbins and Gyurcsik - SH(DRG) for short. See Dr Dobb's
! 651: * Journal, January 1996, pp107-110 and 116-117
! 652: *
! 653: * Given the end points of a line, and a bounding rectangle (which we
! 654: * know to be from (0,0) to (SX,SY)), adjust the endpoints to be on
! 655: * the edges of the rectangle if the line should be drawn at all,
! 656: * otherwise return a failure code
! 657: */
! 658:
! 659: /* this does "one-dimensional" clipping: note that the second time it
! 660: * is called, all the x parameters refer to height and the y to width
! 661: * - the comments ignore this (if you can understand it when it's
! 662: * looking at the X parameters, it should become clear what happens on
! 663: * the second call!) The code is simplified from that in the article,
! 664: * as we know that gd images always start at (0,0)
! 665: */
! 666:
! 667: static int clip_1d(int *x0, int *y0, int *x1, int *y1, int maxdim) {
! 668: double m; /* gradient of line */
! 669:
! 670: if (*x0 < 0) { /* start of line is left of window */
! 671: if(*x1 < 0) { /* as is the end, so the line never cuts the window */
! 672: return 0;
! 673: }
! 674: m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
! 675: /* adjust x0 to be on the left boundary (ie to be zero), and y0 to match */
! 676: *y0 -= (int)(m * *x0);
! 677: *x0 = 0;
! 678: /* now, perhaps, adjust the far end of the line as well */
! 679: if (*x1 > maxdim) {
! 680: *y1 += (int)(m * (maxdim - *x1));
! 681: *x1 = maxdim;
! 682: }
! 683: return 1;
! 684: }
! 685: if (*x0 > maxdim) { /* start of line is right of window - complement of above */
! 686: if (*x1 > maxdim) { /* as is the end, so the line misses the window */
! 687: return 0;
! 688: }
! 689: m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
! 690: *y0 += (int)(m * (maxdim - *x0)); /* adjust so point is on the right boundary */
! 691: *x0 = maxdim;
! 692: /* now, perhaps, adjust the end of the line */
! 693: if (*x1 < 0) {
! 694: *y1 -= (int)(m * *x1);
! 695: *x1 = 0;
! 696: }
! 697: return 1;
! 698: }
! 699: /* the final case - the start of the line is inside the window */
! 700: if (*x1 > maxdim) { /* other end is outside to the right */
! 701: m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
! 702: *y1 += (int)(m * (maxdim - *x1));
! 703: *x1 = maxdim;
! 704: return 1;
! 705: }
! 706: if (*x1 < 0) { /* other end is outside to the left */
! 707: m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
! 708: *y1 -= (int)(m * *x1);
! 709: *x1 = 0;
! 710: return 1;
! 711: }
! 712: /* only get here if both points are inside the window */
! 713: return 1;
! 714: }
! 715:
! 716: void gdImageSetPixel (gdImagePtr im, int x, int y, int color)
! 717: {
! 718: int p;
! 719: switch (color) {
! 720: case gdStyled:
! 721: if (!im->style) {
! 722: /* Refuse to draw if no style is set. */
! 723: return;
! 724: } else {
! 725: p = im->style[im->stylePos++];
! 726: }
! 727: if (p != gdTransparent) {
! 728: gdImageSetPixel(im, x, y, p);
! 729: }
! 730: im->stylePos = im->stylePos % im->styleLength;
! 731: break;
! 732: case gdStyledBrushed:
! 733: if (!im->style) {
! 734: /* Refuse to draw if no style is set. */
! 735: return;
! 736: }
! 737: p = im->style[im->stylePos++];
! 738: if (p != gdTransparent && p != 0) {
! 739: gdImageSetPixel(im, x, y, gdBrushed);
! 740: }
! 741: im->stylePos = im->stylePos % im->styleLength;
! 742: break;
! 743: case gdBrushed:
! 744: gdImageBrushApply(im, x, y);
! 745: break;
! 746: case gdTiled:
! 747: gdImageTileApply(im, x, y);
! 748: break;
! 749: case gdAntiAliased:
! 750: gdImageAntiAliasedApply(im, x, y);
! 751: break;
! 752: default:
! 753: if (gdImageBoundsSafe(im, x, y)) {
! 754: if (im->trueColor) {
! 755: switch (im->alphaBlendingFlag) {
! 756: default:
! 757: case gdEffectReplace:
! 758: im->tpixels[y][x] = color;
! 759: break;
! 760: case gdEffectAlphaBlend:
! 761: im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
! 762: break;
! 763: case gdEffectNormal:
! 764: im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
! 765: break;
! 766: case gdEffectOverlay :
! 767: im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color);
! 768: break;
! 769: }
! 770: } else {
! 771: im->pixels[y][x] = color;
! 772: }
! 773: }
! 774: break;
! 775: }
! 776: }
! 777:
! 778: int gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
! 779: {
! 780: int p = gdImageGetPixel(im, x, y);
! 781:
! 782: if (!im->trueColor) {
! 783: return gdTrueColorAlpha(im->red[p], im->green[p], im->blue[p], (im->transparent == p) ? gdAlphaTransparent : im->alpha[p]);
! 784: } else {
! 785: return p;
! 786: }
! 787: }
! 788:
! 789: static void gdImageBrushApply (gdImagePtr im, int x, int y)
! 790: {
! 791: int lx, ly;
! 792: int hy, hx;
! 793: int x1, y1, x2, y2;
! 794: int srcx, srcy;
! 795:
! 796: if (!im->brush) {
! 797: return;
! 798: }
! 799:
! 800: hy = gdImageSY(im->brush) / 2;
! 801: y1 = y - hy;
! 802: y2 = y1 + gdImageSY(im->brush);
! 803: hx = gdImageSX(im->brush) / 2;
! 804: x1 = x - hx;
! 805: x2 = x1 + gdImageSX(im->brush);
! 806: srcy = 0;
! 807:
! 808: if (im->trueColor) {
! 809: if (im->brush->trueColor) {
! 810: for (ly = y1; ly < y2; ly++) {
! 811: srcx = 0;
! 812: for (lx = x1; (lx < x2); lx++) {
! 813: int p;
! 814: p = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
! 815: /* 2.0.9, Thomas Winzig: apply simple full transparency */
! 816: if (p != gdImageGetTransparent(im->brush)) {
! 817: gdImageSetPixel(im, lx, ly, p);
! 818: }
! 819: srcx++;
! 820: }
! 821: srcy++;
! 822: }
! 823: } else {
! 824: /* 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger for pointing out the issue) */
! 825: for (ly = y1; ly < y2; ly++) {
! 826: srcx = 0;
! 827: for (lx = x1; lx < x2; lx++) {
! 828: int p, tc;
! 829: p = gdImageGetPixel(im->brush, srcx, srcy);
! 830: tc = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
! 831: /* 2.0.9, Thomas Winzig: apply simple full transparency */
! 832: if (p != gdImageGetTransparent(im->brush)) {
! 833: gdImageSetPixel(im, lx, ly, tc);
! 834: }
! 835: srcx++;
! 836: }
! 837: srcy++;
! 838: }
! 839: }
! 840: } else {
! 841: for (ly = y1; ly < y2; ly++) {
! 842: srcx = 0;
! 843: for (lx = x1; lx < x2; lx++) {
! 844: int p;
! 845: p = gdImageGetPixel(im->brush, srcx, srcy);
! 846: /* Allow for non-square brushes! */
! 847: if (p != gdImageGetTransparent(im->brush)) {
! 848: /* Truecolor brush. Very slow on a palette destination. */
! 849: if (im->brush->trueColor) {
! 850: gdImageSetPixel(im, lx, ly, gdImageColorResolveAlpha(im, gdTrueColorGetRed(p),
! 851: gdTrueColorGetGreen(p),
! 852: gdTrueColorGetBlue(p),
! 853: gdTrueColorGetAlpha(p)));
! 854: } else {
! 855: gdImageSetPixel(im, lx, ly, im->brushColorMap[p]);
! 856: }
! 857: }
! 858: srcx++;
! 859: }
! 860: srcy++;
! 861: }
! 862: }
! 863: }
! 864:
! 865: static void gdImageTileApply (gdImagePtr im, int x, int y)
! 866: {
! 867: gdImagePtr tile = im->tile;
! 868: int srcx, srcy;
! 869: int p;
! 870: if (!tile) {
! 871: return;
! 872: }
! 873: srcx = x % gdImageSX(tile);
! 874: srcy = y % gdImageSY(tile);
! 875: if (im->trueColor) {
! 876: p = gdImageGetPixel(tile, srcx, srcy);
! 877: if (p != gdImageGetTransparent (tile)) {
! 878: if (!tile->trueColor) {
! 879: p = gdTrueColorAlpha(tile->red[p], tile->green[p], tile->blue[p], tile->alpha[p]);
! 880: }
! 881: gdImageSetPixel(im, x, y, p);
! 882: }
! 883: } else {
! 884: p = gdImageGetPixel(tile, srcx, srcy);
! 885: /* Allow for transparency */
! 886: if (p != gdImageGetTransparent(tile)) {
! 887: if (tile->trueColor) {
! 888: /* Truecolor tile. Very slow on a palette destination. */
! 889: gdImageSetPixel(im, x, y, gdImageColorResolveAlpha(im,
! 890: gdTrueColorGetRed(p),
! 891: gdTrueColorGetGreen(p),
! 892: gdTrueColorGetBlue(p),
! 893: gdTrueColorGetAlpha(p)));
! 894: } else {
! 895: gdImageSetPixel(im, x, y, im->tileColorMap[p]);
! 896: }
! 897: }
! 898: }
! 899: }
! 900:
! 901:
! 902: static int gdImageTileGet (gdImagePtr im, int x, int y)
! 903: {
! 904: int srcx, srcy;
! 905: int tileColor,p;
! 906: if (!im->tile) {
! 907: return -1;
! 908: }
! 909: srcx = x % gdImageSX(im->tile);
! 910: srcy = y % gdImageSY(im->tile);
! 911: p = gdImageGetPixel(im->tile, srcx, srcy);
! 912:
! 913: if (im->trueColor) {
! 914: if (im->tile->trueColor) {
! 915: tileColor = p;
! 916: } else {
! 917: tileColor = gdTrueColorAlpha( gdImageRed(im->tile,p), gdImageGreen(im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
! 918: }
! 919: } else {
! 920: if (im->tile->trueColor) {
! 921: tileColor = gdImageColorResolveAlpha(im, gdTrueColorGetRed (p), gdTrueColorGetGreen (p), gdTrueColorGetBlue (p), gdTrueColorGetAlpha (p));
! 922: } else {
! 923: tileColor = p;
! 924: tileColor = gdImageColorResolveAlpha(im, gdImageRed (im->tile,p), gdImageGreen (im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
! 925: }
! 926: }
! 927: return tileColor;
! 928: }
! 929:
! 930:
! 931: static void gdImageAntiAliasedApply (gdImagePtr im, int px, int py)
! 932: {
! 933: float p_dist, p_alpha;
! 934: unsigned char opacity;
! 935:
! 936: /*
! 937: * Find the perpendicular distance from point C (px, py) to the line
! 938: * segment AB that is being drawn. (Adapted from an algorithm from the
! 939: * comp.graphics.algorithms FAQ.)
! 940: */
! 941:
! 942: int LAC_2, LBC_2;
! 943:
! 944: int Ax_Cx = im->AAL_x1 - px;
! 945: int Ay_Cy = im->AAL_y1 - py;
! 946:
! 947: int Bx_Cx = im->AAL_x2 - px;
! 948: int By_Cy = im->AAL_y2 - py;
! 949:
! 950: /* 2.0.13: bounds check! AA_opacity is just as capable of
! 951: * overflowing as the main pixel array. Arne Jorgensen.
! 952: * 2.0.14: typo fixed. 2.0.15: moved down below declarations
! 953: * to satisfy non-C++ compilers.
! 954: */
! 955: if (!gdImageBoundsSafe(im, px, py)) {
! 956: return;
! 957: }
! 958:
! 959: /* Get the squares of the lengths of the segemnts AC and BC. */
! 960: LAC_2 = (Ax_Cx * Ax_Cx) + (Ay_Cy * Ay_Cy);
! 961: LBC_2 = (Bx_Cx * Bx_Cx) + (By_Cy * By_Cy);
! 962:
! 963: if (((im->AAL_LAB_2 + LAC_2) >= LBC_2) && ((im->AAL_LAB_2 + LBC_2) >= LAC_2)) {
! 964: /* The two angles are acute. The point lies inside the portion of the
! 965: * plane spanned by the line segment.
! 966: */
! 967: p_dist = fabs ((float) ((Ay_Cy * im->AAL_Bx_Ax) - (Ax_Cx * im->AAL_By_Ay)) / im->AAL_LAB);
! 968: } else {
! 969: /* The point is past an end of the line segment. It's length from the
! 970: * segment is the shorter of the lengths from the endpoints, but call
! 971: * the distance -1, so as not to compute the alpha nor draw the pixel.
! 972: */
! 973: p_dist = -1;
! 974: }
! 975:
! 976: if ((p_dist >= 0) && (p_dist <= (float) (im->thick))) {
! 977: p_alpha = pow (1.0 - (p_dist / 1.5), 2);
! 978:
! 979: if (p_alpha > 0) {
! 980: if (p_alpha >= 1) {
! 981: opacity = 255;
! 982: } else {
! 983: opacity = (unsigned char) (p_alpha * 255.0);
! 984: }
! 985: if (!im->AA_polygon || (im->AA_opacity[py][px] < opacity)) {
! 986: im->AA_opacity[py][px] = opacity;
! 987: }
! 988: }
! 989: }
! 990: }
! 991:
! 992:
! 993: int gdImageGetPixel (gdImagePtr im, int x, int y)
! 994: {
! 995: if (gdImageBoundsSafe(im, x, y)) {
! 996: if (im->trueColor) {
! 997: return im->tpixels[y][x];
! 998: } else {
! 999: return im->pixels[y][x];
! 1000: }
! 1001: } else {
! 1002: return 0;
! 1003: }
! 1004: }
! 1005:
! 1006: void gdImageAABlend (gdImagePtr im)
! 1007: {
! 1008: float p_alpha, old_alpha;
! 1009: int color = im->AA_color, color_red, color_green, color_blue;
! 1010: int old_color, old_red, old_green, old_blue;
! 1011: int p_color, p_red, p_green, p_blue;
! 1012: int px, py;
! 1013:
! 1014: color_red = gdImageRed(im, color);
! 1015: color_green = gdImageGreen(im, color);
! 1016: color_blue = gdImageBlue(im, color);
! 1017:
! 1018: /* Impose the anti-aliased drawing on the image. */
! 1019: for (py = 0; py < im->sy; py++) {
! 1020: for (px = 0; px < im->sx; px++) {
! 1021: if (im->AA_opacity[py][px] != 0) {
! 1022: old_color = gdImageGetPixel(im, px, py);
! 1023:
! 1024: if ((old_color != color) && ((old_color != im->AA_dont_blend) || (im->AA_opacity[py][px] == 255))) {
! 1025: /* Only blend with different colors that aren't the dont_blend color. */
! 1026: p_alpha = (float) (im->AA_opacity[py][px]) / 255.0;
! 1027: old_alpha = 1.0 - p_alpha;
! 1028:
! 1029: if (p_alpha >= 1.0) {
! 1030: p_color = color;
! 1031: } else {
! 1032: old_red = gdImageRed(im, old_color);
! 1033: old_green = gdImageGreen(im, old_color);
! 1034: old_blue = gdImageBlue(im, old_color);
! 1035:
! 1036: p_red = (int) (((float) color_red * p_alpha) + ((float) old_red * old_alpha));
! 1037: p_green = (int) (((float) color_green * p_alpha) + ((float) old_green * old_alpha));
! 1038: p_blue = (int) (((float) color_blue * p_alpha) + ((float) old_blue * old_alpha));
! 1039: p_color = gdImageColorResolve(im, p_red, p_green, p_blue);
! 1040: }
! 1041: gdImageSetPixel(im, px, py, p_color);
! 1042: }
! 1043: }
! 1044: }
! 1045: /* Clear the AA_opacity array behind us. */
! 1046: memset(im->AA_opacity[py], 0, im->sx);
! 1047: }
! 1048: }
! 1049:
! 1050: static void gdImageHLine(gdImagePtr im, int y, int x1, int x2, int col)
! 1051: {
! 1052: if (im->thick > 1) {
! 1053: int thickhalf = im->thick >> 1;
! 1054: gdImageFilledRectangle(im, x1, y - thickhalf, x2, y + im->thick - thickhalf - 1, col);
! 1055: } else {
! 1056: if (x2 < x1) {
! 1057: int t = x2;
! 1058: x2 = x1;
! 1059: x1 = t;
! 1060: }
! 1061:
! 1062: for (;x1 <= x2; x1++) {
! 1063: gdImageSetPixel(im, x1, y, col);
! 1064: }
! 1065: }
! 1066: return;
! 1067: }
! 1068:
! 1069: static void gdImageVLine(gdImagePtr im, int x, int y1, int y2, int col)
! 1070: {
! 1071: if (im->thick > 1) {
! 1072: int thickhalf = im->thick >> 1;
! 1073: gdImageFilledRectangle(im, x - thickhalf, y1, x + im->thick - thickhalf - 1, y2, col);
! 1074: } else {
! 1075: if (y2 < y1) {
! 1076: int t = y1;
! 1077: y1 = y2;
! 1078: y2 = t;
! 1079: }
! 1080:
! 1081: for (;y1 <= y2; y1++) {
! 1082: gdImageSetPixel(im, x, y1, col);
! 1083: }
! 1084: }
! 1085: return;
! 1086: }
! 1087:
! 1088: /* Bresenham as presented in Foley & Van Dam */
! 1089: void gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
! 1090: {
! 1091: int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
! 1092: int wid;
! 1093: int w, wstart;
! 1094: int thick = im->thick;
! 1095:
! 1096: if (color == gdAntiAliased) {
! 1097: /*
! 1098: gdAntiAliased passed as color: use the much faster, much cheaper
! 1099: and equally attractive gdImageAALine implementation. That
! 1100: clips too, so don't clip twice.
! 1101: */
! 1102: gdImageAALine(im, x1, y1, x2, y2, im->AA_color);
! 1103: return;
! 1104: }
! 1105:
! 1106: /* 2.0.10: Nick Atty: clip to edges of drawing rectangle, return if no points need to be drawn */
! 1107: if (!clip_1d(&x1,&y1,&x2,&y2,gdImageSX(im)) || !clip_1d(&y1,&x1,&y2,&x2,gdImageSY(im))) {
! 1108: return;
! 1109: }
! 1110:
! 1111: dx = abs (x2 - x1);
! 1112: dy = abs (y2 - y1);
! 1113:
! 1114: if (dx == 0) {
! 1115: gdImageVLine(im, x1, y1, y2, color);
! 1116: return;
! 1117: } else if (dy == 0) {
! 1118: gdImageHLine(im, y1, x1, x2, color);
! 1119: return;
! 1120: }
! 1121:
! 1122: if (dy <= dx) {
! 1123: /* More-or-less horizontal. use wid for vertical stroke */
! 1124: /* Doug Claar: watch out for NaN in atan2 (2.0.5) */
! 1125: if ((dx == 0) && (dy == 0)) {
! 1126: wid = 1;
! 1127: } else {
! 1128: /* 2.0.12: Michael Schwartz: divide rather than multiply;
! 1129: TBB: but watch out for /0! */
! 1130: double ac = cos (atan2 (dy, dx));
! 1131: if (ac != 0) {
! 1132: wid = thick / ac;
! 1133: } else {
! 1134: wid = 1;
! 1135: }
! 1136: if (wid == 0) {
! 1137: wid = 1;
! 1138: }
! 1139: }
! 1140: d = 2 * dy - dx;
! 1141: incr1 = 2 * dy;
! 1142: incr2 = 2 * (dy - dx);
! 1143: if (x1 > x2) {
! 1144: x = x2;
! 1145: y = y2;
! 1146: ydirflag = (-1);
! 1147: xend = x1;
! 1148: } else {
! 1149: x = x1;
! 1150: y = y1;
! 1151: ydirflag = 1;
! 1152: xend = x2;
! 1153: }
! 1154:
! 1155: /* Set up line thickness */
! 1156: wstart = y - wid / 2;
! 1157: for (w = wstart; w < wstart + wid; w++) {
! 1158: gdImageSetPixel(im, x, w, color);
! 1159: }
! 1160:
! 1161: if (((y2 - y1) * ydirflag) > 0) {
! 1162: while (x < xend) {
! 1163: x++;
! 1164: if (d < 0) {
! 1165: d += incr1;
! 1166: } else {
! 1167: y++;
! 1168: d += incr2;
! 1169: }
! 1170: wstart = y - wid / 2;
! 1171: for (w = wstart; w < wstart + wid; w++) {
! 1172: gdImageSetPixel (im, x, w, color);
! 1173: }
! 1174: }
! 1175: } else {
! 1176: while (x < xend) {
! 1177: x++;
! 1178: if (d < 0) {
! 1179: d += incr1;
! 1180: } else {
! 1181: y--;
! 1182: d += incr2;
! 1183: }
! 1184: wstart = y - wid / 2;
! 1185: for (w = wstart; w < wstart + wid; w++) {
! 1186: gdImageSetPixel (im, x, w, color);
! 1187: }
! 1188: }
! 1189: }
! 1190: } else {
! 1191: /* More-or-less vertical. use wid for horizontal stroke */
! 1192: /* 2.0.12: Michael Schwartz: divide rather than multiply;
! 1193: TBB: but watch out for /0! */
! 1194: double as = sin (atan2 (dy, dx));
! 1195: if (as != 0) {
! 1196: wid = thick / as;
! 1197: } else {
! 1198: wid = 1;
! 1199: }
! 1200: if (wid == 0) {
! 1201: wid = 1;
! 1202: }
! 1203:
! 1204: d = 2 * dx - dy;
! 1205: incr1 = 2 * dx;
! 1206: incr2 = 2 * (dx - dy);
! 1207: if (y1 > y2) {
! 1208: y = y2;
! 1209: x = x2;
! 1210: yend = y1;
! 1211: xdirflag = (-1);
! 1212: } else {
! 1213: y = y1;
! 1214: x = x1;
! 1215: yend = y2;
! 1216: xdirflag = 1;
! 1217: }
! 1218:
! 1219: /* Set up line thickness */
! 1220: wstart = x - wid / 2;
! 1221: for (w = wstart; w < wstart + wid; w++) {
! 1222: gdImageSetPixel (im, w, y, color);
! 1223: }
! 1224:
! 1225: if (((x2 - x1) * xdirflag) > 0) {
! 1226: while (y < yend) {
! 1227: y++;
! 1228: if (d < 0) {
! 1229: d += incr1;
! 1230: } else {
! 1231: x++;
! 1232: d += incr2;
! 1233: }
! 1234: wstart = x - wid / 2;
! 1235: for (w = wstart; w < wstart + wid; w++) {
! 1236: gdImageSetPixel (im, w, y, color);
! 1237: }
! 1238: }
! 1239: } else {
! 1240: while (y < yend) {
! 1241: y++;
! 1242: if (d < 0) {
! 1243: d += incr1;
! 1244: } else {
! 1245: x--;
! 1246: d += incr2;
! 1247: }
! 1248: wstart = x - wid / 2;
! 1249: for (w = wstart; w < wstart + wid; w++) {
! 1250: gdImageSetPixel (im, w, y, color);
! 1251: }
! 1252: }
! 1253: }
! 1254: }
! 1255: }
! 1256:
! 1257:
! 1258: /*
! 1259: * Added on 2003/12 by Pierre-Alain Joye (pajoye@pearfr.org)
! 1260: * */
! 1261: #define BLEND_COLOR(a, nc, c, cc) \
! 1262: nc = (cc) + (((((c) - (cc)) * (a)) + ((((c) - (cc)) * (a)) >> 8) + 0x80) >> 8);
! 1263:
! 1264: inline static void gdImageSetAAPixelColor(gdImagePtr im, int x, int y, int color, int t)
! 1265: {
! 1266: int dr,dg,db,p,r,g,b;
! 1267: dr = gdTrueColorGetRed(color);
! 1268: dg = gdTrueColorGetGreen(color);
! 1269: db = gdTrueColorGetBlue(color);
! 1270:
! 1271: p = gdImageGetPixel(im,x,y);
! 1272: r = gdTrueColorGetRed(p);
! 1273: g = gdTrueColorGetGreen(p);
! 1274: b = gdTrueColorGetBlue(p);
! 1275:
! 1276: BLEND_COLOR(t, dr, r, dr);
! 1277: BLEND_COLOR(t, dg, g, dg);
! 1278: BLEND_COLOR(t, db, b, db);
! 1279: im->tpixels[y][x]=gdTrueColorAlpha(dr, dg, db, gdAlphaOpaque);
! 1280: }
! 1281:
! 1282: /*
! 1283: * Added on 2003/12 by Pierre-Alain Joye (pajoye@pearfr.org)
! 1284: **/
! 1285: void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int col)
! 1286: {
! 1287: /* keep them as 32bits */
! 1288: long x, y, inc;
! 1289: long dx, dy,tmp;
! 1290:
! 1291: if (y1 < 0 && y2 < 0) {
! 1292: return;
! 1293: }
! 1294: if (y1 < 0) {
! 1295: x1 += (y1 * (x1 - x2)) / (y2 - y1);
! 1296: y1 = 0;
! 1297: }
! 1298: if (y2 < 0) {
! 1299: x2 += (y2 * (x1 - x2)) / (y2 - y1);
! 1300: y2 = 0;
! 1301: }
! 1302:
! 1303: /* bottom edge */
! 1304: if (y1 >= im->sy && y2 >= im->sy) {
! 1305: return;
! 1306: }
! 1307: if (y1 >= im->sy) {
! 1308: x1 -= ((im->sy - y1) * (x1 - x2)) / (y2 - y1);
! 1309: y1 = im->sy - 1;
! 1310: }
! 1311: if (y2 >= im->sy) {
! 1312: x2 -= ((im->sy - y2) * (x1 - x2)) / (y2 - y1);
! 1313: y2 = im->sy - 1;
! 1314: }
! 1315:
! 1316: /* left edge */
! 1317: if (x1 < 0 && x2 < 0) {
! 1318: return;
! 1319: }
! 1320: if (x1 < 0) {
! 1321: y1 += (x1 * (y1 - y2)) / (x2 - x1);
! 1322: x1 = 0;
! 1323: }
! 1324: if (x2 < 0) {
! 1325: y2 += (x2 * (y1 - y2)) / (x2 - x1);
! 1326: x2 = 0;
! 1327: }
! 1328: /* right edge */
! 1329: if (x1 >= im->sx && x2 >= im->sx) {
! 1330: return;
! 1331: }
! 1332: if (x1 >= im->sx) {
! 1333: y1 -= ((im->sx - x1) * (y1 - y2)) / (x2 - x1);
! 1334: x1 = im->sx - 1;
! 1335: }
! 1336: if (x2 >= im->sx) {
! 1337: y2 -= ((im->sx - x2) * (y1 - y2)) / (x2 - x1);
! 1338: x2 = im->sx - 1;
! 1339: }
! 1340:
! 1341: dx = x2 - x1;
! 1342: dy = y2 - y1;
! 1343:
! 1344: if (dx == 0 && dy == 0) {
! 1345: return;
! 1346: }
! 1347: if (abs(dx) > abs(dy)) {
! 1348: if (dx < 0) {
! 1349: tmp = x1;
! 1350: x1 = x2;
! 1351: x2 = tmp;
! 1352: tmp = y1;
! 1353: y1 = y2;
! 1354: y2 = tmp;
! 1355: dx = x2 - x1;
! 1356: dy = y2 - y1;
! 1357: }
! 1358: x = x1 << 16;
! 1359: y = y1 << 16;
! 1360: inc = (dy * 65536) / dx;
! 1361: while ((x >> 16) <= x2) {
! 1362: gdImageSetAAPixelColor(im, x >> 16, y >> 16, col, (y >> 8) & 0xFF);
! 1363: if ((y >> 16) + 1 < im->sy) {
! 1364: gdImageSetAAPixelColor(im, x >> 16, (y >> 16) + 1,col, (~y >> 8) & 0xFF);
! 1365: }
! 1366: x += (1 << 16);
! 1367: y += inc;
! 1368: }
! 1369: } else {
! 1370: if (dy < 0) {
! 1371: tmp = x1;
! 1372: x1 = x2;
! 1373: x2 = tmp;
! 1374: tmp = y1;
! 1375: y1 = y2;
! 1376: y2 = tmp;
! 1377: dx = x2 - x1;
! 1378: dy = y2 - y1;
! 1379: }
! 1380: x = x1 << 16;
! 1381: y = y1 << 16;
! 1382: inc = (dx * 65536) / dy;
! 1383: while ((y>>16) <= y2) {
! 1384: gdImageSetAAPixelColor(im, x >> 16, y >> 16, col, (x >> 8) & 0xFF);
! 1385: if ((x >> 16) + 1 < im->sx) {
! 1386: gdImageSetAAPixelColor(im, (x >> 16) + 1, (y >> 16),col, (~x >> 8) & 0xFF);
! 1387: }
! 1388: x += inc;
! 1389: y += (1<<16);
! 1390: }
! 1391: }
! 1392: }
! 1393:
! 1394: static void dashedSet (gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert);
! 1395:
! 1396: void gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
! 1397: {
! 1398: int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
! 1399: int dashStep = 0;
! 1400: int on = 1;
! 1401: int wid;
! 1402: int vert;
! 1403: int thick = im->thick;
! 1404:
! 1405: dx = abs(x2 - x1);
! 1406: dy = abs(y2 - y1);
! 1407: if (dy <= dx) {
! 1408: /* More-or-less horizontal. use wid for vertical stroke */
! 1409: /* 2.0.12: Michael Schwartz: divide rather than multiply;
! 1410: TBB: but watch out for /0! */
! 1411: double as = sin(atan2(dy, dx));
! 1412: if (as != 0) {
! 1413: wid = thick / as;
! 1414: } else {
! 1415: wid = 1;
! 1416: }
! 1417: wid = (int)(thick * sin(atan2(dy, dx)));
! 1418: vert = 1;
! 1419:
! 1420: d = 2 * dy - dx;
! 1421: incr1 = 2 * dy;
! 1422: incr2 = 2 * (dy - dx);
! 1423: if (x1 > x2) {
! 1424: x = x2;
! 1425: y = y2;
! 1426: ydirflag = (-1);
! 1427: xend = x1;
! 1428: } else {
! 1429: x = x1;
! 1430: y = y1;
! 1431: ydirflag = 1;
! 1432: xend = x2;
! 1433: }
! 1434: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1435: if (((y2 - y1) * ydirflag) > 0) {
! 1436: while (x < xend) {
! 1437: x++;
! 1438: if (d < 0) {
! 1439: d += incr1;
! 1440: } else {
! 1441: y++;
! 1442: d += incr2;
! 1443: }
! 1444: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1445: }
! 1446: } else {
! 1447: while (x < xend) {
! 1448: x++;
! 1449: if (d < 0) {
! 1450: d += incr1;
! 1451: } else {
! 1452: y--;
! 1453: d += incr2;
! 1454: }
! 1455: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1456: }
! 1457: }
! 1458: } else {
! 1459: /* 2.0.12: Michael Schwartz: divide rather than multiply;
! 1460: TBB: but watch out for /0! */
! 1461: double as = sin (atan2 (dy, dx));
! 1462: if (as != 0) {
! 1463: wid = thick / as;
! 1464: } else {
! 1465: wid = 1;
! 1466: }
! 1467: vert = 0;
! 1468:
! 1469: d = 2 * dx - dy;
! 1470: incr1 = 2 * dx;
! 1471: incr2 = 2 * (dx - dy);
! 1472: if (y1 > y2) {
! 1473: y = y2;
! 1474: x = x2;
! 1475: yend = y1;
! 1476: xdirflag = (-1);
! 1477: } else {
! 1478: y = y1;
! 1479: x = x1;
! 1480: yend = y2;
! 1481: xdirflag = 1;
! 1482: }
! 1483: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1484: if (((x2 - x1) * xdirflag) > 0) {
! 1485: while (y < yend) {
! 1486: y++;
! 1487: if (d < 0) {
! 1488: d += incr1;
! 1489: } else {
! 1490: x++;
! 1491: d += incr2;
! 1492: }
! 1493: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1494: }
! 1495: } else {
! 1496: while (y < yend) {
! 1497: y++;
! 1498: if (d < 0) {
! 1499: d += incr1;
! 1500: } else {
! 1501: x--;
! 1502: d += incr2;
! 1503: }
! 1504: dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
! 1505: }
! 1506: }
! 1507: }
! 1508: }
! 1509:
! 1510: static void dashedSet (gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert)
! 1511: {
! 1512: int dashStep = *dashStepP;
! 1513: int on = *onP;
! 1514: int w, wstart;
! 1515:
! 1516: dashStep++;
! 1517: if (dashStep == gdDashSize) {
! 1518: dashStep = 0;
! 1519: on = !on;
! 1520: }
! 1521: if (on) {
! 1522: if (vert) {
! 1523: wstart = y - wid / 2;
! 1524: for (w = wstart; w < wstart + wid; w++) {
! 1525: gdImageSetPixel(im, x, w, color);
! 1526: }
! 1527: } else {
! 1528: wstart = x - wid / 2;
! 1529: for (w = wstart; w < wstart + wid; w++) {
! 1530: gdImageSetPixel(im, w, y, color);
! 1531: }
! 1532: }
! 1533: }
! 1534: *dashStepP = dashStep;
! 1535: *onP = on;
! 1536: }
! 1537:
! 1538: void gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
! 1539: {
! 1540: int cx, cy;
! 1541: int px, py;
! 1542: int fline;
! 1543: cx = 0;
! 1544: cy = 0;
! 1545: #ifdef CHARSET_EBCDIC
! 1546: c = ASC (c);
! 1547: #endif /*CHARSET_EBCDIC */
! 1548: if ((c < f->offset) || (c >= (f->offset + f->nchars))) {
! 1549: return;
! 1550: }
! 1551: fline = (c - f->offset) * f->h * f->w;
! 1552: for (py = y; (py < (y + f->h)); py++) {
! 1553: for (px = x; (px < (x + f->w)); px++) {
! 1554: if (f->data[fline + cy * f->w + cx]) {
! 1555: gdImageSetPixel(im, px, py, color);
! 1556: }
! 1557: cx++;
! 1558: }
! 1559: cx = 0;
! 1560: cy++;
! 1561: }
! 1562: }
! 1563:
! 1564: void gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
! 1565: {
! 1566: int cx, cy;
! 1567: int px, py;
! 1568: int fline;
! 1569: cx = 0;
! 1570: cy = 0;
! 1571: #ifdef CHARSET_EBCDIC
! 1572: c = ASC (c);
! 1573: #endif /*CHARSET_EBCDIC */
! 1574: if ((c < f->offset) || (c >= (f->offset + f->nchars))) {
! 1575: return;
! 1576: }
! 1577: fline = (c - f->offset) * f->h * f->w;
! 1578: for (py = y; py > (y - f->w); py--) {
! 1579: for (px = x; px < (x + f->h); px++) {
! 1580: if (f->data[fline + cy * f->w + cx]) {
! 1581: gdImageSetPixel(im, px, py, color);
! 1582: }
! 1583: cy++;
! 1584: }
! 1585: cy = 0;
! 1586: cx++;
! 1587: }
! 1588: }
! 1589:
! 1590: void gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
! 1591: {
! 1592: int i;
! 1593: int l;
! 1594: l = strlen ((char *) s);
! 1595: for (i = 0; (i < l); i++) {
! 1596: gdImageChar(im, f, x, y, s[i], color);
! 1597: x += f->w;
! 1598: }
! 1599: }
! 1600:
! 1601: void gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
! 1602: {
! 1603: int i;
! 1604: int l;
! 1605: l = strlen ((char *) s);
! 1606: for (i = 0; (i < l); i++) {
! 1607: gdImageCharUp(im, f, x, y, s[i], color);
! 1608: y -= f->w;
! 1609: }
! 1610: }
! 1611:
! 1612: static int strlen16 (unsigned short *s);
! 1613:
! 1614: void gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
! 1615: {
! 1616: int i;
! 1617: int l;
! 1618: l = strlen16(s);
! 1619: for (i = 0; (i < l); i++) {
! 1620: gdImageChar(im, f, x, y, s[i], color);
! 1621: x += f->w;
! 1622: }
! 1623: }
! 1624:
! 1625: void gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
! 1626: {
! 1627: int i;
! 1628: int l;
! 1629: l = strlen16(s);
! 1630: for (i = 0; i < l; i++) {
! 1631: gdImageCharUp(im, f, x, y, s[i], color);
! 1632: y -= f->w;
! 1633: }
! 1634: }
! 1635:
! 1636: static int strlen16 (unsigned short *s)
! 1637: {
! 1638: int len = 0;
! 1639: while (*s) {
! 1640: s++;
! 1641: len++;
! 1642: }
! 1643: return len;
! 1644: }
! 1645:
! 1646: #ifndef HAVE_LSQRT
! 1647: /* If you don't have a nice square root function for longs, you can use
! 1648: ** this hack
! 1649: */
! 1650: long lsqrt (long n)
! 1651: {
! 1652: long result = (long) sqrt ((double) n);
! 1653: return result;
! 1654: }
! 1655: #endif
! 1656:
! 1657: /* s and e are integers modulo 360 (degrees), with 0 degrees
! 1658: being the rightmost extreme and degrees changing clockwise.
! 1659: cx and cy are the center in pixels; w and h are the horizontal
! 1660: and vertical diameter in pixels. Nice interface, but slow.
! 1661: See gd_arc_f_buggy.c for a better version that doesn't
! 1662: seem to be bug-free yet. */
! 1663:
! 1664: void gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color)
! 1665: {
! 1666: if ((s % 360) == (e % 360)) {
! 1667: gdImageEllipse(im, cx, cy, w, h, color);
! 1668: } else {
! 1669: gdImageFilledArc(im, cx, cy, w, h, s, e, color, gdNoFill);
! 1670: }
! 1671: }
! 1672:
! 1673: void gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style)
! 1674: {
! 1675: gdPoint pts[3];
! 1676: int i;
! 1677: int lx = 0, ly = 0;
! 1678: int fx = 0, fy = 0;
! 1679:
! 1680:
! 1681: if ((s % 360) == (e % 360)) {
! 1682: s = 0; e = 360;
! 1683: } else {
! 1684: if (s > 360) {
! 1685: s = s % 360;
! 1686: }
! 1687:
! 1688: if (e > 360) {
! 1689: e = e % 360;
! 1690: }
! 1691:
! 1692: while (s < 0) {
! 1693: s += 360;
! 1694: }
! 1695:
! 1696: while (e < s) {
! 1697: e += 360;
! 1698: }
! 1699: if (s == e) {
! 1700: s = 0; e = 360;
! 1701: }
! 1702: }
! 1703:
! 1704: for (i = s; i <= e; i++) {
! 1705: int x, y;
! 1706: x = ((long) gdCosT[i % 360] * (long) w / (2 * 1024)) + cx;
! 1707: y = ((long) gdSinT[i % 360] * (long) h / (2 * 1024)) + cy;
! 1708: if (i != s) {
! 1709: if (!(style & gdChord)) {
! 1710: if (style & gdNoFill) {
! 1711: gdImageLine(im, lx, ly, x, y, color);
! 1712: } else {
! 1713: /* This is expensive! */
! 1714: pts[0].x = lx;
! 1715: pts[0].y = ly;
! 1716: pts[1].x = x;
! 1717: pts[1].y = y;
! 1718: pts[2].x = cx;
! 1719: pts[2].y = cy;
! 1720: gdImageFilledPolygon(im, pts, 3, color);
! 1721: }
! 1722: }
! 1723: } else {
! 1724: fx = x;
! 1725: fy = y;
! 1726: }
! 1727: lx = x;
! 1728: ly = y;
! 1729: }
! 1730: if (style & gdChord) {
! 1731: if (style & gdNoFill) {
! 1732: if (style & gdEdged) {
! 1733: gdImageLine(im, cx, cy, lx, ly, color);
! 1734: gdImageLine(im, cx, cy, fx, fy, color);
! 1735: }
! 1736: gdImageLine(im, fx, fy, lx, ly, color);
! 1737: } else {
! 1738: pts[0].x = fx;
! 1739: pts[0].y = fy;
! 1740: pts[1].x = lx;
! 1741: pts[1].y = ly;
! 1742: pts[2].x = cx;
! 1743: pts[2].y = cy;
! 1744: gdImageFilledPolygon(im, pts, 3, color);
! 1745: }
! 1746: } else {
! 1747: if (style & gdNoFill) {
! 1748: if (style & gdEdged) {
! 1749: gdImageLine(im, cx, cy, lx, ly, color);
! 1750: gdImageLine(im, cx, cy, fx, fy, color);
! 1751: }
! 1752: }
! 1753: }
! 1754: }
! 1755:
! 1756: void gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
! 1757: {
! 1758: int lastBorder;
! 1759: /* Seek left */
! 1760: int leftLimit = -1, rightLimit;
! 1761: int i, restoreAlphaBlending = 0;
! 1762:
! 1763: if (border < 0) {
! 1764: /* Refuse to fill to a non-solid border */
! 1765: return;
! 1766: }
! 1767:
! 1768: restoreAlphaBlending = im->alphaBlendingFlag;
! 1769: im->alphaBlendingFlag = 0;
! 1770:
! 1771: if (x >= im->sx) {
! 1772: x = im->sx - 1;
! 1773: }
! 1774: if (y >= im->sy) {
! 1775: y = im->sy - 1;
! 1776: }
! 1777:
! 1778: for (i = x; i >= 0; i--) {
! 1779: if (gdImageGetPixel(im, i, y) == border) {
! 1780: break;
! 1781: }
! 1782: gdImageSetPixel(im, i, y, color);
! 1783: leftLimit = i;
! 1784: }
! 1785: if (leftLimit == -1) {
! 1786: im->alphaBlendingFlag = restoreAlphaBlending;
! 1787: return;
! 1788: }
! 1789: /* Seek right */
! 1790: rightLimit = x;
! 1791: for (i = (x + 1); i < im->sx; i++) {
! 1792: if (gdImageGetPixel(im, i, y) == border) {
! 1793: break;
! 1794: }
! 1795: gdImageSetPixel(im, i, y, color);
! 1796: rightLimit = i;
! 1797: }
! 1798: /* Look at lines above and below and start paints */
! 1799: /* Above */
! 1800: if (y > 0) {
! 1801: lastBorder = 1;
! 1802: for (i = leftLimit; i <= rightLimit; i++) {
! 1803: int c = gdImageGetPixel(im, i, y - 1);
! 1804: if (lastBorder) {
! 1805: if ((c != border) && (c != color)) {
! 1806: gdImageFillToBorder(im, i, y - 1, border, color);
! 1807: lastBorder = 0;
! 1808: }
! 1809: } else if ((c == border) || (c == color)) {
! 1810: lastBorder = 1;
! 1811: }
! 1812: }
! 1813: }
! 1814:
! 1815: /* Below */
! 1816: if (y < ((im->sy) - 1)) {
! 1817: lastBorder = 1;
! 1818: for (i = leftLimit; i <= rightLimit; i++) {
! 1819: int c = gdImageGetPixel(im, i, y + 1);
! 1820:
! 1821: if (lastBorder) {
! 1822: if ((c != border) && (c != color)) {
! 1823: gdImageFillToBorder(im, i, y + 1, border, color);
! 1824: lastBorder = 0;
! 1825: }
! 1826: } else if ((c == border) || (c == color)) {
! 1827: lastBorder = 1;
! 1828: }
! 1829: }
! 1830: }
! 1831: im->alphaBlendingFlag = restoreAlphaBlending;
! 1832: }
! 1833:
! 1834: /*
! 1835: * set the pixel at (x,y) and its 4-connected neighbors
! 1836: * with the same pixel value to the new pixel value nc (new color).
! 1837: * A 4-connected neighbor: pixel above, below, left, or right of a pixel.
! 1838: * ideas from comp.graphics discussions.
! 1839: * For tiled fill, the use of a flag buffer is mandatory. As the tile image can
! 1840: * contain the same color as the color to fill. To do not bloat normal filling
! 1841: * code I added a 2nd private function.
! 1842: */
! 1843:
! 1844: /* horizontal segment of scan line y */
! 1845: struct seg {int y, xl, xr, dy;};
! 1846:
! 1847: /* max depth of stack */
! 1848: #define FILL_MAX ((int)(im->sy*im->sx)/4)
! 1849: #define FILL_PUSH(Y, XL, XR, DY) \
! 1850: if (sp<stack+FILL_MAX && Y+(DY)>=0 && Y+(DY)<wy2) \
! 1851: {sp->y = Y; sp->xl = XL; sp->xr = XR; sp->dy = DY; sp++;}
! 1852:
! 1853: #define FILL_POP(Y, XL, XR, DY) \
! 1854: {sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;}
! 1855:
! 1856: static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc);
! 1857:
! 1858: void gdImageFill(gdImagePtr im, int x, int y, int nc)
! 1859: {
! 1860: int l, x1, x2, dy;
! 1861: int oc; /* old pixel value */
! 1862: int wx2,wy2;
! 1863:
! 1864: int alphablending_bak;
! 1865:
! 1866: /* stack of filled segments */
! 1867: /* struct seg stack[FILL_MAX],*sp = stack;; */
! 1868: struct seg *stack = NULL;
! 1869: struct seg *sp;
! 1870:
! 1871: if (!im->trueColor && nc > (im->colorsTotal -1)) {
! 1872: return;
! 1873: }
! 1874:
! 1875: alphablending_bak = im->alphaBlendingFlag;
! 1876: im->alphaBlendingFlag = 0;
! 1877:
! 1878: if (nc==gdTiled){
! 1879: _gdImageFillTiled(im,x,y,nc);
! 1880: im->alphaBlendingFlag = alphablending_bak;
! 1881: return;
! 1882: }
! 1883:
! 1884: wx2=im->sx;wy2=im->sy;
! 1885: oc = gdImageGetPixel(im, x, y);
! 1886: if (oc==nc || x<0 || x>wx2 || y<0 || y>wy2) {
! 1887: im->alphaBlendingFlag = alphablending_bak;
! 1888: return;
! 1889: }
! 1890:
! 1891: /* Do not use the 4 neighbors implementation with
! 1892: * small images
! 1893: */
! 1894: if (im->sx < 4) {
! 1895: int ix = x, iy = y, c;
! 1896: do {
! 1897: do {
! 1898: c = gdImageGetPixel(im, ix, iy);
! 1899: if (c != oc) {
! 1900: goto done;
! 1901: }
! 1902: gdImageSetPixel(im, ix, iy, nc);
! 1903: } while(ix++ < (im->sx -1));
! 1904: ix = x;
! 1905: } while(iy++ < (im->sy -1));
! 1906: goto done;
! 1907: }
! 1908:
! 1909: stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
! 1910: sp = stack;
! 1911:
! 1912: /* required! */
! 1913: FILL_PUSH(y,x,x,1);
! 1914: /* seed segment (popped 1st) */
! 1915: FILL_PUSH(y+1, x, x, -1);
! 1916: while (sp>stack) {
! 1917: FILL_POP(y, x1, x2, dy);
! 1918:
! 1919: for (x=x1; x>=0 && gdImageGetPixel(im,x, y)==oc; x--) {
! 1920: gdImageSetPixel(im,x, y, nc);
! 1921: }
! 1922: if (x>=x1) {
! 1923: goto skip;
! 1924: }
! 1925: l = x+1;
! 1926:
! 1927: /* leak on left? */
! 1928: if (l<x1) {
! 1929: FILL_PUSH(y, l, x1-1, -dy);
! 1930: }
! 1931: x = x1+1;
! 1932: do {
! 1933: for (; x<=wx2 && gdImageGetPixel(im,x, y)==oc; x++) {
! 1934: gdImageSetPixel(im, x, y, nc);
! 1935: }
! 1936: FILL_PUSH(y, l, x-1, dy);
! 1937: /* leak on right? */
! 1938: if (x>x2+1) {
! 1939: FILL_PUSH(y, x2+1, x-1, -dy);
! 1940: }
! 1941: skip: for (x++; x<=x2 && (gdImageGetPixel(im, x, y)!=oc); x++);
! 1942:
! 1943: l = x;
! 1944: } while (x<=x2);
! 1945: }
! 1946:
! 1947: efree(stack);
! 1948:
! 1949: done:
! 1950: im->alphaBlendingFlag = alphablending_bak;
! 1951: }
! 1952:
! 1953: static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc)
! 1954: {
! 1955: int i, l, x1, x2, dy;
! 1956: int oc; /* old pixel value */
! 1957: int tiled;
! 1958: int wx2,wy2;
! 1959: /* stack of filled segments */
! 1960: struct seg *stack;
! 1961: struct seg *sp;
! 1962: char **pts;
! 1963:
! 1964: if (!im->tile) {
! 1965: return;
! 1966: }
! 1967:
! 1968: wx2=im->sx;wy2=im->sy;
! 1969: tiled = nc==gdTiled;
! 1970:
! 1971: nc = gdImageTileGet(im,x,y);
! 1972:
! 1973: pts = (char **) ecalloc(im->sy + 1, sizeof(char *));
! 1974: for (i = 0; i < im->sy + 1; i++) {
! 1975: pts[i] = (char *) ecalloc(im->sx + 1, sizeof(char));
! 1976: }
! 1977:
! 1978: stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
! 1979: sp = stack;
! 1980:
! 1981: oc = gdImageGetPixel(im, x, y);
! 1982:
! 1983: /* required! */
! 1984: FILL_PUSH(y,x,x,1);
! 1985: /* seed segment (popped 1st) */
! 1986: FILL_PUSH(y+1, x, x, -1);
! 1987: while (sp>stack) {
! 1988: FILL_POP(y, x1, x2, dy);
! 1989: for (x=x1; x>=0 && (!pts[y][x] && gdImageGetPixel(im,x,y)==oc); x--) {
! 1990: nc = gdImageTileGet(im,x,y);
! 1991: pts[y][x] = 1;
! 1992: gdImageSetPixel(im,x, y, nc);
! 1993: }
! 1994: if (x>=x1) {
! 1995: goto skip;
! 1996: }
! 1997: l = x+1;
! 1998:
! 1999: /* leak on left? */
! 2000: if (l<x1) {
! 2001: FILL_PUSH(y, l, x1-1, -dy);
! 2002: }
! 2003: x = x1+1;
! 2004: do {
! 2005: for(; x<wx2 && (!pts[y][x] && gdImageGetPixel(im,x, y)==oc); x++) {
! 2006: nc = gdImageTileGet(im,x,y);
! 2007: pts[y][x] = 1;
! 2008: gdImageSetPixel(im, x, y, nc);
! 2009: }
! 2010: FILL_PUSH(y, l, x-1, dy);
! 2011: /* leak on right? */
! 2012: if (x>x2+1) {
! 2013: FILL_PUSH(y, x2+1, x-1, -dy);
! 2014: }
! 2015: skip: for(x++; x<=x2 && (pts[y][x] || gdImageGetPixel(im,x, y)!=oc); x++);
! 2016: l = x;
! 2017: } while (x<=x2);
! 2018: }
! 2019:
! 2020: for(i = 0; i < im->sy + 1; i++) {
! 2021: efree(pts[i]);
! 2022: }
! 2023:
! 2024: efree(pts);
! 2025: efree(stack);
! 2026: }
! 2027:
! 2028:
! 2029:
! 2030: void gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
! 2031: {
! 2032: int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2, y2v = y2;
! 2033: int thick = im->thick;
! 2034: int half1 = 1;
! 2035: int t;
! 2036:
! 2037: if (x1 == x2 && y1 == y2 && thick == 1) {
! 2038: gdImageSetPixel(im, x1, y1, color);
! 2039: return;
! 2040: }
! 2041:
! 2042: if (y2 < y1) {
! 2043: t=y1;
! 2044: y1 = y2;
! 2045: y2 = t;
! 2046:
! 2047: t = x1;
! 2048: x1 = x2;
! 2049: x2 = t;
! 2050: }
! 2051:
! 2052: x1h = x1; x1v = x1; y1h = y1; y1v = y1; x2h = x2; x2v = x2; y2h = y2; y2v = y2;
! 2053: if (thick > 1) {
! 2054: int cx, cy, x1ul, y1ul, x2lr, y2lr;
! 2055: int half = thick >> 1;
! 2056: half1 = thick - half;
! 2057: x1ul = x1 - half;
! 2058: y1ul = y1 - half;
! 2059:
! 2060: x2lr = x2 + half;
! 2061: y2lr = y2 + half;
! 2062:
! 2063: cy = y1ul + thick;
! 2064: while (cy-- > y1ul) {
! 2065: cx = x1ul - 1;
! 2066: while (cx++ < x2lr) {
! 2067: gdImageSetPixel(im, cx, cy, color);
! 2068: }
! 2069: }
! 2070:
! 2071: cy = y2lr - thick;
! 2072: while (cy++ < y2lr) {
! 2073: cx = x1ul - 1;
! 2074: while (cx++ < x2lr) {
! 2075: gdImageSetPixel(im, cx, cy, color);
! 2076: }
! 2077: }
! 2078:
! 2079: cy = y1ul + thick - 1;
! 2080: while (cy++ < y2lr -thick) {
! 2081: cx = x1ul - 1;
! 2082: while (cx++ < x1ul + thick) {
! 2083: gdImageSetPixel(im, cx, cy, color);
! 2084: }
! 2085: }
! 2086:
! 2087: cy = y1ul + thick - 1;
! 2088: while (cy++ < y2lr -thick) {
! 2089: cx = x2lr - thick - 1;
! 2090: while (cx++ < x2lr) {
! 2091: gdImageSetPixel(im, cx, cy, color);
! 2092: }
! 2093: }
! 2094:
! 2095: return;
! 2096: } else {
! 2097: y1v = y1h + 1;
! 2098: y2v = y2h - 1;
! 2099: gdImageLine(im, x1h, y1h, x2h, y1h, color);
! 2100: gdImageLine(im, x1h, y2h, x2h, y2h, color);
! 2101: gdImageLine(im, x1v, y1v, x1v, y2v, color);
! 2102: gdImageLine(im, x2v, y1v, x2v, y2v, color);
! 2103: }
! 2104: }
! 2105:
! 2106: void gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
! 2107: {
! 2108: int x, y;
! 2109:
! 2110:
! 2111: if (x1 == x2 && y1 == y2) {
! 2112: gdImageSetPixel(im, x1, y1, color);
! 2113: return;
! 2114: }
! 2115:
! 2116: if (x1 > x2) {
! 2117: x = x1;
! 2118: x1 = x2;
! 2119: x2 = x;
! 2120: }
! 2121:
! 2122: if (y1 > y2) {
! 2123: y = y1;
! 2124: y1 = y2;
! 2125: y2 = y;
! 2126: }
! 2127:
! 2128: if (x1 < 0) {
! 2129: x1 = 0;
! 2130: }
! 2131:
! 2132: if (x2 >= gdImageSX(im)) {
! 2133: x2 = gdImageSX(im) - 1;
! 2134: }
! 2135:
! 2136: if (y1 < 0) {
! 2137: y1 = 0;
! 2138: }
! 2139:
! 2140: if (y2 >= gdImageSY(im)) {
! 2141: y2 = gdImageSY(im) - 1;
! 2142: }
! 2143:
! 2144: for (y = y1; (y <= y2); y++) {
! 2145: for (x = x1; (x <= x2); x++) {
! 2146: gdImageSetPixel (im, x, y, color);
! 2147: }
! 2148: }
! 2149: }
! 2150:
! 2151: void gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
! 2152: {
! 2153: int c;
! 2154: int x, y;
! 2155: int tox, toy;
! 2156: int i;
! 2157: int colorMap[gdMaxColors];
! 2158:
! 2159: if (dst->trueColor) {
! 2160: /* 2.0: much easier when the destination is truecolor. */
! 2161: /* 2.0.10: needs a transparent-index check that is still valid if
! 2162: * the source is not truecolor. Thanks to Frank Warmerdam.
! 2163: */
! 2164:
! 2165: if (src->trueColor) {
! 2166: for (y = 0; (y < h); y++) {
! 2167: for (x = 0; (x < w); x++) {
! 2168: int c = gdImageGetTrueColorPixel (src, srcX + x, srcY + y);
! 2169: gdImageSetPixel (dst, dstX + x, dstY + y, c);
! 2170: }
! 2171: }
! 2172: } else {
! 2173: /* source is palette based */
! 2174: for (y = 0; (y < h); y++) {
! 2175: for (x = 0; (x < w); x++) {
! 2176: int c = gdImageGetPixel (src, srcX + x, srcY + y);
! 2177: if (c != src->transparent) {
! 2178: gdImageSetPixel(dst, dstX + x, dstY + y, gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]));
! 2179: }
! 2180: }
! 2181: }
! 2182: }
! 2183: return;
! 2184: }
! 2185:
! 2186: /* Destination is palette based */
! 2187: if (src->trueColor) { /* But source is truecolor (Ouch!) */
! 2188: toy = dstY;
! 2189: for (y = srcY; (y < (srcY + h)); y++) {
! 2190: tox = dstX;
! 2191: for (x = srcX; x < (srcX + w); x++) {
! 2192: int nc;
! 2193: c = gdImageGetPixel (src, x, y);
! 2194:
! 2195: /* Get best match possible. */
! 2196: nc = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c), gdTrueColorGetGreen(c), gdTrueColorGetBlue(c), gdTrueColorGetAlpha(c));
! 2197:
! 2198: gdImageSetPixel(dst, tox, toy, nc);
! 2199: tox++;
! 2200: }
! 2201: toy++;
! 2202: }
! 2203: return;
! 2204: }
! 2205:
! 2206: /* Palette based to palette based */
! 2207: for (i = 0; i < gdMaxColors; i++) {
! 2208: colorMap[i] = (-1);
! 2209: }
! 2210: toy = dstY;
! 2211: for (y = srcY; y < (srcY + h); y++) {
! 2212: tox = dstX;
! 2213: for (x = srcX; x < (srcX + w); x++) {
! 2214: int nc;
! 2215: int mapTo;
! 2216: c = gdImageGetPixel (src, x, y);
! 2217: /* Added 7/24/95: support transparent copies */
! 2218: if (gdImageGetTransparent (src) == c) {
! 2219: tox++;
! 2220: continue;
! 2221: }
! 2222: /* Have we established a mapping for this color? */
! 2223: if (src->trueColor) {
! 2224: /* 2.05: remap to the palette available in the destination image. This is slow and
! 2225: * works badly, but it beats crashing! Thanks to Padhrig McCarthy.
! 2226: */
! 2227: mapTo = gdImageColorResolveAlpha (dst, gdTrueColorGetRed (c), gdTrueColorGetGreen (c), gdTrueColorGetBlue (c), gdTrueColorGetAlpha (c));
! 2228: } else if (colorMap[c] == (-1)) {
! 2229: /* If it's the same image, mapping is trivial */
! 2230: if (dst == src) {
! 2231: nc = c;
! 2232: } else {
! 2233: /* Get best match possible. This function never returns error. */
! 2234: nc = gdImageColorResolveAlpha (dst, src->red[c], src->green[c], src->blue[c], src->alpha[c]);
! 2235: }
! 2236: colorMap[c] = nc;
! 2237: mapTo = colorMap[c];
! 2238: } else {
! 2239: mapTo = colorMap[c];
! 2240: }
! 2241: gdImageSetPixel (dst, tox, toy, mapTo);
! 2242: tox++;
! 2243: }
! 2244: toy++;
! 2245: }
! 2246: }
! 2247:
! 2248: /* This function is a substitute for real alpha channel operations,
! 2249: so it doesn't pay attention to the alpha channel. */
! 2250: void gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
! 2251: {
! 2252: int c, dc;
! 2253: int x, y;
! 2254: int tox, toy;
! 2255: int ncR, ncG, ncB;
! 2256: toy = dstY;
! 2257:
! 2258: for (y = srcY; y < (srcY + h); y++) {
! 2259: tox = dstX;
! 2260: for (x = srcX; x < (srcX + w); x++) {
! 2261: int nc;
! 2262: c = gdImageGetPixel(src, x, y);
! 2263: /* Added 7/24/95: support transparent copies */
! 2264: if (gdImageGetTransparent(src) == c) {
! 2265: tox++;
! 2266: continue;
! 2267: }
! 2268: /* If it's the same image, mapping is trivial */
! 2269: if (dst == src) {
! 2270: nc = c;
! 2271: } else {
! 2272: dc = gdImageGetPixel(dst, tox, toy);
! 2273:
! 2274: ncR = (int)(gdImageRed (src, c) * (pct / 100.0) + gdImageRed (dst, dc) * ((100 - pct) / 100.0));
! 2275: ncG = (int)(gdImageGreen (src, c) * (pct / 100.0) + gdImageGreen (dst, dc) * ((100 - pct) / 100.0));
! 2276: ncB = (int)(gdImageBlue (src, c) * (pct / 100.0) + gdImageBlue (dst, dc) * ((100 - pct) / 100.0));
! 2277:
! 2278: /* Find a reasonable color */
! 2279: nc = gdImageColorResolve (dst, ncR, ncG, ncB);
! 2280: }
! 2281: gdImageSetPixel (dst, tox, toy, nc);
! 2282: tox++;
! 2283: }
! 2284: toy++;
! 2285: }
! 2286: }
! 2287:
! 2288: /* This function is a substitute for real alpha channel operations,
! 2289: so it doesn't pay attention to the alpha channel. */
! 2290: void gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
! 2291: {
! 2292: int c, dc;
! 2293: int x, y;
! 2294: int tox, toy;
! 2295: int ncR, ncG, ncB;
! 2296: float g;
! 2297: toy = dstY;
! 2298:
! 2299: for (y = srcY; (y < (srcY + h)); y++) {
! 2300: tox = dstX;
! 2301: for (x = srcX; (x < (srcX + w)); x++) {
! 2302: int nc;
! 2303: c = gdImageGetPixel (src, x, y);
! 2304: /* Added 7/24/95: support transparent copies */
! 2305: if (gdImageGetTransparent(src) == c) {
! 2306: tox++;
! 2307: continue;
! 2308: }
! 2309:
! 2310: /*
! 2311: * If it's the same image, mapping is NOT trivial since we
! 2312: * merge with greyscale target, but if pct is 100, the grey
! 2313: * value is not used, so it becomes trivial. pjw 2.0.12.
! 2314: */
! 2315: if (dst == src && pct == 100) {
! 2316: nc = c;
! 2317: } else {
! 2318: dc = gdImageGetPixel(dst, tox, toy);
! 2319: g = (0.29900f * gdImageRed(dst, dc)) + (0.58700f * gdImageGreen(dst, dc)) + (0.11400f * gdImageBlue(dst, dc));
! 2320:
! 2321: ncR = (int)(gdImageRed (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
! 2322: ncG = (int)(gdImageGreen (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
! 2323: ncB = (int)(gdImageBlue (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
! 2324:
! 2325:
! 2326: /* First look for an exact match */
! 2327: nc = gdImageColorExact(dst, ncR, ncG, ncB);
! 2328: if (nc == (-1)) {
! 2329: /* No, so try to allocate it */
! 2330: nc = gdImageColorAllocate(dst, ncR, ncG, ncB);
! 2331: /* If we're out of colors, go for the closest color */
! 2332: if (nc == (-1)) {
! 2333: nc = gdImageColorClosest(dst, ncR, ncG, ncB);
! 2334: }
! 2335: }
! 2336: }
! 2337: gdImageSetPixel(dst, tox, toy, nc);
! 2338: tox++;
! 2339: }
! 2340: toy++;
! 2341: }
! 2342: }
! 2343:
! 2344: void gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
! 2345: {
! 2346: int c;
! 2347: int x, y;
! 2348: int tox, toy;
! 2349: int ydest;
! 2350: int i;
! 2351: int colorMap[gdMaxColors];
! 2352: /* Stretch vectors */
! 2353: int *stx, *sty;
! 2354: /* We only need to use floating point to determine the correct stretch vector for one line's worth. */
! 2355: double accum;
! 2356:
! 2357: if (overflow2(sizeof(int), srcW)) {
! 2358: return;
! 2359: }
! 2360: if (overflow2(sizeof(int), srcH)) {
! 2361: return;
! 2362: }
! 2363:
! 2364: stx = (int *) gdMalloc (sizeof (int) * srcW);
! 2365: sty = (int *) gdMalloc (sizeof (int) * srcH);
! 2366: accum = 0;
! 2367:
! 2368: /* Fixed by Mao Morimoto 2.0.16 */
! 2369: for (i = 0; (i < srcW); i++) {
! 2370: stx[i] = dstW * (i+1) / srcW - dstW * i / srcW ;
! 2371: }
! 2372: for (i = 0; (i < srcH); i++) {
! 2373: sty[i] = dstH * (i+1) / srcH - dstH * i / srcH ;
! 2374: }
! 2375: for (i = 0; (i < gdMaxColors); i++) {
! 2376: colorMap[i] = (-1);
! 2377: }
! 2378: toy = dstY;
! 2379: for (y = srcY; (y < (srcY + srcH)); y++) {
! 2380: for (ydest = 0; (ydest < sty[y - srcY]); ydest++) {
! 2381: tox = dstX;
! 2382: for (x = srcX; (x < (srcX + srcW)); x++) {
! 2383: int nc = 0;
! 2384: int mapTo;
! 2385: if (!stx[x - srcX]) {
! 2386: continue;
! 2387: }
! 2388: if (dst->trueColor) {
! 2389: /* 2.0.9: Thorben Kundinger: Maybe the source image is not a truecolor image */
! 2390: if (!src->trueColor) {
! 2391: int tmp = gdImageGetPixel (src, x, y);
! 2392: mapTo = gdImageGetTrueColorPixel (src, x, y);
! 2393: if (gdImageGetTransparent (src) == tmp) {
! 2394: /* 2.0.21, TK: not tox++ */
! 2395: tox += stx[x - srcX];
! 2396: continue;
! 2397: }
! 2398: } else {
! 2399: /* TK: old code follows */
! 2400: mapTo = gdImageGetTrueColorPixel (src, x, y);
! 2401: /* Added 7/24/95: support transparent copies */
! 2402: if (gdImageGetTransparent (src) == mapTo) {
! 2403: /* 2.0.21, TK: not tox++ */
! 2404: tox += stx[x - srcX];
! 2405: continue;
! 2406: }
! 2407: }
! 2408: } else {
! 2409: c = gdImageGetPixel (src, x, y);
! 2410: /* Added 7/24/95: support transparent copies */
! 2411: if (gdImageGetTransparent (src) == c) {
! 2412: tox += stx[x - srcX];
! 2413: continue;
! 2414: }
! 2415: if (src->trueColor) {
! 2416: /* Remap to the palette available in the destination image. This is slow and works badly. */
! 2417: mapTo = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c),
! 2418: gdTrueColorGetGreen(c),
! 2419: gdTrueColorGetBlue(c),
! 2420: gdTrueColorGetAlpha (c));
! 2421: } else {
! 2422: /* Have we established a mapping for this color? */
! 2423: if (colorMap[c] == (-1)) {
! 2424: /* If it's the same image, mapping is trivial */
! 2425: if (dst == src) {
! 2426: nc = c;
! 2427: } else {
! 2428: /* Find or create the best match */
! 2429: /* 2.0.5: can't use gdTrueColorGetRed, etc with palette */
! 2430: nc = gdImageColorResolveAlpha(dst, gdImageRed(src, c),
! 2431: gdImageGreen(src, c),
! 2432: gdImageBlue(src, c),
! 2433: gdImageAlpha(src, c));
! 2434: }
! 2435: colorMap[c] = nc;
! 2436: }
! 2437: mapTo = colorMap[c];
! 2438: }
! 2439: }
! 2440: for (i = 0; (i < stx[x - srcX]); i++) {
! 2441: gdImageSetPixel (dst, tox, toy, mapTo);
! 2442: tox++;
! 2443: }
! 2444: }
! 2445: toy++;
! 2446: }
! 2447: }
! 2448: gdFree (stx);
! 2449: gdFree (sty);
! 2450: }
! 2451:
! 2452: /* When gd 1.x was first created, floating point was to be avoided.
! 2453: These days it is often faster than table lookups or integer
! 2454: arithmetic. The routine below is shamelessly, gloriously
! 2455: floating point. TBB */
! 2456:
! 2457: void gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
! 2458: {
! 2459: int x, y;
! 2460: double sy1, sy2, sx1, sx2;
! 2461:
! 2462: if (!dst->trueColor) {
! 2463: gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
! 2464: return;
! 2465: }
! 2466: for (y = dstY; (y < dstY + dstH); y++) {
! 2467: sy1 = ((double) y - (double) dstY) * (double) srcH / (double) dstH;
! 2468: sy2 = ((double) (y + 1) - (double) dstY) * (double) srcH / (double) dstH;
! 2469: for (x = dstX; (x < dstX + dstW); x++) {
! 2470: double sx, sy;
! 2471: double spixels = 0;
! 2472: double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
! 2473: double alpha_factor, alpha_sum = 0.0, contrib_sum = 0.0;
! 2474: sx1 = ((double) x - (double) dstX) * (double) srcW / dstW;
! 2475: sx2 = ((double) (x + 1) - (double) dstX) * (double) srcW / dstW;
! 2476: sy = sy1;
! 2477: do {
! 2478: double yportion;
! 2479: if (floor_cast(sy) == floor_cast(sy1)) {
! 2480: yportion = 1.0f - (sy - floor_cast(sy));
! 2481: if (yportion > sy2 - sy1) {
! 2482: yportion = sy2 - sy1;
! 2483: }
! 2484: sy = floor_cast(sy);
! 2485: } else if (sy == floorf(sy2)) {
! 2486: yportion = sy2 - floor_cast(sy2);
! 2487: } else {
! 2488: yportion = 1.0f;
! 2489: }
! 2490: sx = sx1;
! 2491: do {
! 2492: double xportion;
! 2493: double pcontribution;
! 2494: int p;
! 2495: if (floorf(sx) == floor_cast(sx1)) {
! 2496: xportion = 1.0f - (sx - floor_cast(sx));
! 2497: if (xportion > sx2 - sx1) {
! 2498: xportion = sx2 - sx1;
! 2499: }
! 2500: sx = floor_cast(sx);
! 2501: } else if (sx == floorf(sx2)) {
! 2502: xportion = sx2 - floor_cast(sx2);
! 2503: } else {
! 2504: xportion = 1.0f;
! 2505: }
! 2506: pcontribution = xportion * yportion;
! 2507: p = gdImageGetTrueColorPixel(src, (int) sx + srcX, (int) sy + srcY);
! 2508:
! 2509: alpha_factor = ((gdAlphaMax - gdTrueColorGetAlpha(p))) * pcontribution;
! 2510: red += gdTrueColorGetRed (p) * alpha_factor;
! 2511: green += gdTrueColorGetGreen (p) * alpha_factor;
! 2512: blue += gdTrueColorGetBlue (p) * alpha_factor;
! 2513: alpha += gdTrueColorGetAlpha (p) * pcontribution;
! 2514: alpha_sum += alpha_factor;
! 2515: contrib_sum += pcontribution;
! 2516: spixels += xportion * yportion;
! 2517: sx += 1.0f;
! 2518: }
! 2519: while (sx < sx2);
! 2520:
! 2521: sy += 1.0f;
! 2522: }
! 2523:
! 2524: while (sy < sy2);
! 2525:
! 2526: if (spixels != 0.0f) {
! 2527: red /= spixels;
! 2528: green /= spixels;
! 2529: blue /= spixels;
! 2530: alpha /= spixels;
! 2531: alpha += 0.5;
! 2532: }
! 2533: if ( alpha_sum != 0.0f) {
! 2534: if( contrib_sum != 0.0f) {
! 2535: alpha_sum /= contrib_sum;
! 2536: }
! 2537: red /= alpha_sum;
! 2538: green /= alpha_sum;
! 2539: blue /= alpha_sum;
! 2540: }
! 2541: /* Clamping to allow for rounding errors above */
! 2542: if (red > 255.0f) {
! 2543: red = 255.0f;
! 2544: }
! 2545: if (green > 255.0f) {
! 2546: green = 255.0f;
! 2547: }
! 2548: if (blue > 255.0f) {
! 2549: blue = 255.0f;
! 2550: }
! 2551: if (alpha > gdAlphaMax) {
! 2552: alpha = gdAlphaMax;
! 2553: }
! 2554: gdImageSetPixel(dst, x, y, gdTrueColorAlpha ((int) red, (int) green, (int) blue, (int) alpha));
! 2555: }
! 2556: }
! 2557: }
! 2558:
! 2559: void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
! 2560: {
! 2561: int i;
! 2562: int lx, ly;
! 2563: typedef void (*image_line)(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 2564: image_line draw_line;
! 2565:
! 2566: if (n <= 0) {
! 2567: return;
! 2568: }
! 2569:
! 2570: /* Let it be known that we are drawing a polygon so that the opacity
! 2571: * mask doesn't get cleared after each line.
! 2572: */
! 2573: if (c == gdAntiAliased) {
! 2574: im->AA_polygon = 1;
! 2575: }
! 2576:
! 2577: if ( im->antialias) {
! 2578: draw_line = gdImageAALine;
! 2579: } else {
! 2580: draw_line = gdImageLine;
! 2581: }
! 2582: lx = p->x;
! 2583: ly = p->y;
! 2584: draw_line(im, lx, ly, p[n - 1].x, p[n - 1].y, c);
! 2585: for (i = 1; i < n; i++) {
! 2586: p++;
! 2587: draw_line(im, lx, ly, p->x, p->y, c);
! 2588: lx = p->x;
! 2589: ly = p->y;
! 2590: }
! 2591:
! 2592: if (c == gdAntiAliased) {
! 2593: im->AA_polygon = 0;
! 2594: gdImageAABlend(im);
! 2595: }
! 2596: }
! 2597:
! 2598: int gdCompareInt (const void *a, const void *b);
! 2599:
! 2600: /* THANKS to Kirsten Schulz for the polygon fixes! */
! 2601:
! 2602: /* The intersection finding technique of this code could be improved
! 2603: * by remembering the previous intertersection, and by using the slope.
! 2604: * That could help to adjust intersections to produce a nice
! 2605: * interior_extrema.
! 2606: */
! 2607:
! 2608: void gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
! 2609: {
! 2610: int i;
! 2611: int y;
! 2612: int miny, maxy, pmaxy;
! 2613: int x1, y1;
! 2614: int x2, y2;
! 2615: int ind1, ind2;
! 2616: int ints;
! 2617: int fill_color;
! 2618:
! 2619: if (n <= 0) {
! 2620: return;
! 2621: }
! 2622:
! 2623: if (overflow2(sizeof(int), n)) {
! 2624: return;
! 2625: }
! 2626:
! 2627: if (c == gdAntiAliased) {
! 2628: fill_color = im->AA_color;
! 2629: } else {
! 2630: fill_color = c;
! 2631: }
! 2632:
! 2633: if (!im->polyAllocated) {
! 2634: im->polyInts = (int *) gdMalloc(sizeof(int) * n);
! 2635: im->polyAllocated = n;
! 2636: }
! 2637: if (im->polyAllocated < n) {
! 2638: while (im->polyAllocated < n) {
! 2639: im->polyAllocated *= 2;
! 2640: }
! 2641: if (overflow2(sizeof(int), im->polyAllocated)) {
! 2642: return;
! 2643: }
! 2644: im->polyInts = (int *) gdRealloc(im->polyInts, sizeof(int) * im->polyAllocated);
! 2645: }
! 2646: miny = p[0].y;
! 2647: maxy = p[0].y;
! 2648: for (i = 1; i < n; i++) {
! 2649: if (p[i].y < miny) {
! 2650: miny = p[i].y;
! 2651: }
! 2652: if (p[i].y > maxy) {
! 2653: maxy = p[i].y;
! 2654: }
! 2655: }
! 2656: pmaxy = maxy;
! 2657: /* 2.0.16: Optimization by Ilia Chipitsine -- don't waste time offscreen */
! 2658: if (miny < 0) {
! 2659: miny = 0;
! 2660: }
! 2661: if (maxy >= gdImageSY(im)) {
! 2662: maxy = gdImageSY(im) - 1;
! 2663: }
! 2664:
! 2665: /* Fix in 1.3: count a vertex only once */
! 2666: for (y = miny; y <= maxy; y++) {
! 2667: /*1.4 int interLast = 0; */
! 2668: /* int dirLast = 0; */
! 2669: /* int interFirst = 1; */
! 2670: ints = 0;
! 2671: for (i = 0; i < n; i++) {
! 2672: if (!i) {
! 2673: ind1 = n - 1;
! 2674: ind2 = 0;
! 2675: } else {
! 2676: ind1 = i - 1;
! 2677: ind2 = i;
! 2678: }
! 2679: y1 = p[ind1].y;
! 2680: y2 = p[ind2].y;
! 2681: if (y1 < y2) {
! 2682: x1 = p[ind1].x;
! 2683: x2 = p[ind2].x;
! 2684: } else if (y1 > y2) {
! 2685: y2 = p[ind1].y;
! 2686: y1 = p[ind2].y;
! 2687: x2 = p[ind1].x;
! 2688: x1 = p[ind2].x;
! 2689: } else {
! 2690: continue;
! 2691: }
! 2692: /* Do the following math as float intermediately, and round to ensure
! 2693: * that Polygon and FilledPolygon for the same set of points have the
! 2694: * same footprint.
! 2695: */
! 2696: if (y >= y1 && y < y2) {
! 2697: im->polyInts[ints++] = (float) ((y - y1) * (x2 - x1)) / (float) (y2 - y1) + 0.5 + x1;
! 2698: } else if (y == pmaxy && y == y2) {
! 2699: im->polyInts[ints++] = x2;
! 2700: }
! 2701: }
! 2702: qsort(im->polyInts, ints, sizeof(int), gdCompareInt);
! 2703:
! 2704: for (i = 0; i < ints - 1; i += 2) {
! 2705: gdImageLine(im, im->polyInts[i], y, im->polyInts[i + 1], y, fill_color);
! 2706: }
! 2707: }
! 2708:
! 2709: /* If we are drawing this AA, then redraw the border with AA lines. */
! 2710: if (c == gdAntiAliased) {
! 2711: gdImagePolygon(im, p, n, c);
! 2712: }
! 2713: }
! 2714:
! 2715: int gdCompareInt (const void *a, const void *b)
! 2716: {
! 2717: return (*(const int *) a) - (*(const int *) b);
! 2718: }
! 2719:
! 2720: void gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
! 2721: {
! 2722: if (im->style) {
! 2723: gdFree(im->style);
! 2724: }
! 2725: im->style = (int *) gdMalloc(sizeof(int) * noOfPixels);
! 2726: memcpy(im->style, style, sizeof(int) * noOfPixels);
! 2727: im->styleLength = noOfPixels;
! 2728: im->stylePos = 0;
! 2729: }
! 2730:
! 2731: void gdImageSetThickness (gdImagePtr im, int thickness)
! 2732: {
! 2733: im->thick = thickness;
! 2734: }
! 2735:
! 2736: void gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
! 2737: {
! 2738: int i;
! 2739: im->brush = brush;
! 2740: if (!im->trueColor && !im->brush->trueColor) {
! 2741: for (i = 0; i < gdImageColorsTotal(brush); i++) {
! 2742: int index;
! 2743: index = gdImageColorResolveAlpha(im, gdImageRed(brush, i), gdImageGreen(brush, i), gdImageBlue(brush, i), gdImageAlpha(brush, i));
! 2744: im->brushColorMap[i] = index;
! 2745: }
! 2746: }
! 2747: }
! 2748:
! 2749: void gdImageSetTile (gdImagePtr im, gdImagePtr tile)
! 2750: {
! 2751: int i;
! 2752: im->tile = tile;
! 2753: if (!im->trueColor && !im->tile->trueColor) {
! 2754: for (i = 0; i < gdImageColorsTotal(tile); i++) {
! 2755: int index;
! 2756: index = gdImageColorResolveAlpha(im, gdImageRed(tile, i), gdImageGreen(tile, i), gdImageBlue(tile, i), gdImageAlpha(tile, i));
! 2757: im->tileColorMap[i] = index;
! 2758: }
! 2759: }
! 2760: }
! 2761:
! 2762: void gdImageSetAntiAliased (gdImagePtr im, int c)
! 2763: {
! 2764: im->AA = 1;
! 2765: im->AA_color = c;
! 2766: im->AA_dont_blend = -1;
! 2767: }
! 2768:
! 2769: void gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend)
! 2770: {
! 2771: im->AA = 1;
! 2772: im->AA_color = c;
! 2773: im->AA_dont_blend = dont_blend;
! 2774: }
! 2775:
! 2776:
! 2777: void gdImageInterlace (gdImagePtr im, int interlaceArg)
! 2778: {
! 2779: im->interlace = interlaceArg;
! 2780: }
! 2781:
! 2782: int gdImageCompare (gdImagePtr im1, gdImagePtr im2)
! 2783: {
! 2784: int x, y;
! 2785: int p1, p2;
! 2786: int cmpStatus = 0;
! 2787: int sx, sy;
! 2788:
! 2789: if (im1->interlace != im2->interlace) {
! 2790: cmpStatus |= GD_CMP_INTERLACE;
! 2791: }
! 2792:
! 2793: if (im1->transparent != im2->transparent) {
! 2794: cmpStatus |= GD_CMP_TRANSPARENT;
! 2795: }
! 2796:
! 2797: if (im1->trueColor != im2->trueColor) {
! 2798: cmpStatus |= GD_CMP_TRUECOLOR;
! 2799: }
! 2800:
! 2801: sx = im1->sx;
! 2802: if (im1->sx != im2->sx) {
! 2803: cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE;
! 2804: if (im2->sx < im1->sx) {
! 2805: sx = im2->sx;
! 2806: }
! 2807: }
! 2808:
! 2809: sy = im1->sy;
! 2810: if (im1->sy != im2->sy) {
! 2811: cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE;
! 2812: if (im2->sy < im1->sy) {
! 2813: sy = im2->sy;
! 2814: }
! 2815: }
! 2816:
! 2817: if (im1->colorsTotal != im2->colorsTotal) {
! 2818: cmpStatus |= GD_CMP_NUM_COLORS;
! 2819: }
! 2820:
! 2821: for (y = 0; y < sy; y++) {
! 2822: for (x = 0; x < sx; x++) {
! 2823: p1 = im1->trueColor ? gdImageTrueColorPixel(im1, x, y) : gdImagePalettePixel(im1, x, y);
! 2824: p2 = im2->trueColor ? gdImageTrueColorPixel(im2, x, y) : gdImagePalettePixel(im2, x, y);
! 2825:
! 2826: if (gdImageRed(im1, p1) != gdImageRed(im2, p2)) {
! 2827: cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
! 2828: break;
! 2829: }
! 2830: if (gdImageGreen(im1, p1) != gdImageGreen(im2, p2)) {
! 2831: cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
! 2832: break;
! 2833: }
! 2834: if (gdImageBlue(im1, p1) != gdImageBlue(im2, p2)) {
! 2835: cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
! 2836: break;
! 2837: }
! 2838: #if 0
! 2839: /* Soon we'll add alpha channel to palettes */
! 2840: if (gdImageAlpha(im1, p1) != gdImageAlpha(im2, p2)) {
! 2841: cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
! 2842: break;
! 2843: }
! 2844: #endif
! 2845: }
! 2846: if (cmpStatus & GD_CMP_COLOR) {
! 2847: break;
! 2848: }
! 2849: }
! 2850:
! 2851: return cmpStatus;
! 2852: }
! 2853:
! 2854: int
! 2855: gdAlphaBlendOld (int dst, int src)
! 2856: {
! 2857: /* 2.0.12: TBB: alpha in the destination should be a
! 2858: * component of the result. Thanks to Frank Warmerdam for
! 2859: * pointing out the issue.
! 2860: */
! 2861: return ((((gdTrueColorGetAlpha (src) *
! 2862: gdTrueColorGetAlpha (dst)) / gdAlphaMax) << 24) +
! 2863: ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
! 2864: gdTrueColorGetRed (src) / gdAlphaMax) +
! 2865: (gdTrueColorGetAlpha (src) *
! 2866: gdTrueColorGetRed (dst)) / gdAlphaMax) << 16) +
! 2867: ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
! 2868: gdTrueColorGetGreen (src) / gdAlphaMax) +
! 2869: (gdTrueColorGetAlpha (src) *
! 2870: gdTrueColorGetGreen (dst)) / gdAlphaMax) << 8) +
! 2871: (((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
! 2872: gdTrueColorGetBlue (src) / gdAlphaMax) +
! 2873: (gdTrueColorGetAlpha (src) *
! 2874: gdTrueColorGetBlue (dst)) / gdAlphaMax));
! 2875: }
! 2876:
! 2877: int gdAlphaBlend (int dst, int src) {
! 2878: int src_alpha = gdTrueColorGetAlpha(src);
! 2879: int dst_alpha, alpha, red, green, blue;
! 2880: int src_weight, dst_weight, tot_weight;
! 2881:
! 2882: /* -------------------------------------------------------------------- */
! 2883: /* Simple cases we want to handle fast. */
! 2884: /* -------------------------------------------------------------------- */
! 2885: if( src_alpha == gdAlphaOpaque )
! 2886: return src;
! 2887:
! 2888: dst_alpha = gdTrueColorGetAlpha(dst);
! 2889: if( src_alpha == gdAlphaTransparent )
! 2890: return dst;
! 2891: if( dst_alpha == gdAlphaTransparent )
! 2892: return src;
! 2893:
! 2894: /* -------------------------------------------------------------------- */
! 2895: /* What will the source and destination alphas be? Note that */
! 2896: /* the destination weighting is substantially reduced as the */
! 2897: /* overlay becomes quite opaque. */
! 2898: /* -------------------------------------------------------------------- */
! 2899: src_weight = gdAlphaTransparent - src_alpha;
! 2900: dst_weight = (gdAlphaTransparent - dst_alpha) * src_alpha / gdAlphaMax;
! 2901: tot_weight = src_weight + dst_weight;
! 2902:
! 2903: /* -------------------------------------------------------------------- */
! 2904: /* What red, green and blue result values will we use? */
! 2905: /* -------------------------------------------------------------------- */
! 2906: alpha = src_alpha * dst_alpha / gdAlphaMax;
! 2907:
! 2908: red = (gdTrueColorGetRed(src) * src_weight
! 2909: + gdTrueColorGetRed(dst) * dst_weight) / tot_weight;
! 2910: green = (gdTrueColorGetGreen(src) * src_weight
! 2911: + gdTrueColorGetGreen(dst) * dst_weight) / tot_weight;
! 2912: blue = (gdTrueColorGetBlue(src) * src_weight
! 2913: + gdTrueColorGetBlue(dst) * dst_weight) / tot_weight;
! 2914:
! 2915: /* -------------------------------------------------------------------- */
! 2916: /* Return merged result. */
! 2917: /* -------------------------------------------------------------------- */
! 2918: return ((alpha << 24) + (red << 16) + (green << 8) + blue);
! 2919:
! 2920: }
! 2921:
! 2922: void gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
! 2923: {
! 2924: im->alphaBlendingFlag = alphaBlendingArg;
! 2925: }
! 2926:
! 2927: void gdImageAntialias (gdImagePtr im, int antialias)
! 2928: {
! 2929: if (im->trueColor){
! 2930: im->antialias = antialias;
! 2931: }
! 2932: }
! 2933:
! 2934: void gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
! 2935: {
! 2936: im->saveAlphaFlag = saveAlphaArg;
! 2937: }
! 2938:
! 2939: static int gdLayerOverlay (int dst, int src)
! 2940: {
! 2941: int a1, a2;
! 2942: a1 = gdAlphaMax - gdTrueColorGetAlpha(dst);
! 2943: a2 = gdAlphaMax - gdTrueColorGetAlpha(src);
! 2944: return ( ((gdAlphaMax - a1*a2/gdAlphaMax) << 24) +
! 2945: (gdAlphaOverlayColor( gdTrueColorGetRed(src), gdTrueColorGetRed(dst), gdRedMax ) << 16) +
! 2946: (gdAlphaOverlayColor( gdTrueColorGetGreen(src), gdTrueColorGetGreen(dst), gdGreenMax ) << 8) +
! 2947: (gdAlphaOverlayColor( gdTrueColorGetBlue(src), gdTrueColorGetBlue(dst), gdBlueMax ))
! 2948: );
! 2949: }
! 2950:
! 2951: static int gdAlphaOverlayColor (int src, int dst, int max )
! 2952: {
! 2953: /* this function implements the algorithm
! 2954: *
! 2955: * for dst[rgb] < 0.5,
! 2956: * c[rgb] = 2.src[rgb].dst[rgb]
! 2957: * and for dst[rgb] > 0.5,
! 2958: * c[rgb] = -2.src[rgb].dst[rgb] + 2.dst[rgb] + 2.src[rgb] - 1
! 2959: *
! 2960: */
! 2961:
! 2962: dst = dst << 1;
! 2963: if( dst > max ) {
! 2964: /* in the "light" zone */
! 2965: return dst + (src << 1) - (dst * src / max) - max;
! 2966: } else {
! 2967: /* in the "dark" zone */
! 2968: return dst * src / max;
! 2969: }
! 2970: }
! 2971:
! 2972: void gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2)
! 2973: {
! 2974: if (x1 < 0) {
! 2975: x1 = 0;
! 2976: }
! 2977: if (x1 >= im->sx) {
! 2978: x1 = im->sx - 1;
! 2979: }
! 2980: if (x2 < 0) {
! 2981: x2 = 0;
! 2982: }
! 2983: if (x2 >= im->sx) {
! 2984: x2 = im->sx - 1;
! 2985: }
! 2986: if (y1 < 0) {
! 2987: y1 = 0;
! 2988: }
! 2989: if (y1 >= im->sy) {
! 2990: y1 = im->sy - 1;
! 2991: }
! 2992: if (y2 < 0) {
! 2993: y2 = 0;
! 2994: }
! 2995: if (y2 >= im->sy) {
! 2996: y2 = im->sy - 1;
! 2997: }
! 2998: im->cx1 = x1;
! 2999: im->cy1 = y1;
! 3000: im->cx2 = x2;
! 3001: im->cy2 = y2;
! 3002: }
! 3003:
! 3004: void gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P)
! 3005: {
! 3006: *x1P = im->cx1;
! 3007: *y1P = im->cy1;
! 3008: *x2P = im->cx2;
! 3009: *y2P = im->cy2;
! 3010: }
! 3011:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd