![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd_rotate.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|
Return to gd_rotate.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd |
1.1 misho 1: #if HAVE_GD_BUNDLED
2: # include "gd.h"
3: #else
4: # include <gd.h>
5: #endif
6:
7: #include "gd_intern.h"
8: #include <math.h>
9:
10: /*
11: * Rotate function Added on 2003/12
12: * by Pierre-Alain Joye (pierre@php.net)
13: **/
14: /* Begin rotate function */
15: #ifdef ROTATE_PI
16: #undef ROTATE_PI
17: #endif /* ROTATE_PI */
18:
19: #define ROTATE_DEG2RAD 3.1415926535897932384626433832795/180
20: void gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, double dWeight, int clrBack, int ignoretransparent)
21: {
22: typedef int (*FuncPtr)(gdImagePtr, int, int);
23: int i, r, g, b, a, clrBackR, clrBackG, clrBackB, clrBackA;
24: FuncPtr f;
25:
26: int pxlOldLeft, pxlLeft=0, pxlSrc;
27:
28: /* Keep clrBack as color index if required */
29: if (src->trueColor) {
30: pxlOldLeft = clrBack;
31: f = gdImageGetTrueColorPixel;
32: } else {
33: pxlOldLeft = clrBack;
34: clrBackR = gdImageRed(src, clrBack);
35: clrBackG = gdImageGreen(src, clrBack);
36: clrBackB = gdImageBlue(src, clrBack);
37: clrBackA = gdImageAlpha(src, clrBack);
38: clrBack = gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA);
39: f = gdImageGetPixel;
40: }
41:
42: for (i = 0; i < iOffset; i++) {
43: gdImageSetPixel (dst, i, uRow, clrBack);
44: }
45:
46: if (i < dst->sx) {
47: gdImageSetPixel (dst, i, uRow, clrBack);
48: }
49:
50: for (i = 0; i < src->sx; i++) {
51: pxlSrc = f (src,i,uRow);
52:
53: r = (int)(gdImageRed(src,pxlSrc) * dWeight);
54: g = (int)(gdImageGreen(src,pxlSrc) * dWeight);
55: b = (int)(gdImageBlue(src,pxlSrc) * dWeight);
56: a = (int)(gdImageAlpha(src,pxlSrc) * dWeight);
57:
58: pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
59:
60: if (pxlLeft == -1) {
61: pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
62: }
63:
64: r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft));
65: g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft));
66: b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft));
67: a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft));
68:
69: if (r>255) {
70: r = 255;
71: }
72:
73: if (g>255) {
74: g = 255;
75: }
76:
77: if (b>255) {
78: b = 255;
79: }
80:
81: if (a>127) {
82: a = 127;
83: }
84:
85: if (ignoretransparent && pxlSrc == dst->transparent) {
86: pxlSrc = dst->transparent;
87: } else {
88: pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
89:
90: if (pxlSrc == -1) {
91: pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a);
92: }
93: }
94:
95: if ((i + iOffset >= 0) && (i + iOffset < dst->sx)) {
96: gdImageSetPixel (dst, i+iOffset, uRow, pxlSrc);
97: }
98:
99: pxlOldLeft = pxlLeft;
100: }
101:
102: i += iOffset;
103:
104: if (i < dst->sx) {
105: gdImageSetPixel (dst, i, uRow, pxlLeft);
106: }
107:
108: gdImageSetPixel (dst, iOffset, uRow, clrBack);
109:
110: i--;
111:
112: while (++i < dst->sx) {
113: gdImageSetPixel (dst, i, uRow, clrBack);
114: }
115: }
116:
117: void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, double dWeight, int clrBack, int ignoretransparent)
118: {
119: typedef int (*FuncPtr)(gdImagePtr, int, int);
120: int i, iYPos=0, r, g, b, a;
121: FuncPtr f;
122: int pxlOldLeft, pxlLeft=0, pxlSrc;
123:
124: if (src->trueColor) {
125: f = gdImageGetTrueColorPixel;
126: } else {
127: f = gdImageGetPixel;
128: }
129:
130: for (i = 0; i<=iOffset; i++) {
131: gdImageSetPixel (dst, uCol, i, clrBack);
132: }
133: r = (int)((double)gdImageRed(src,clrBack) * dWeight);
134: g = (int)((double)gdImageGreen(src,clrBack) * dWeight);
135: b = (int)((double)gdImageBlue(src,clrBack) * dWeight);
136: a = (int)((double)gdImageAlpha(src,clrBack) * dWeight);
137:
138: pxlOldLeft = gdImageColorAllocateAlpha(dst, r, g, b, a);
139:
140: for (i = 0; i < src->sy; i++) {
141: pxlSrc = f (src, uCol, i);
142: iYPos = i + iOffset;
143:
144: r = (int)((double)gdImageRed(src,pxlSrc) * dWeight);
145: g = (int)((double)gdImageGreen(src,pxlSrc) * dWeight);
146: b = (int)((double)gdImageBlue(src,pxlSrc) * dWeight);
147: a = (int)((double)gdImageAlpha(src,pxlSrc) * dWeight);
148:
149: pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a);
150:
151: if (pxlLeft == -1) {
152: pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a);
153: }
154:
155: r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft));
156: g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft));
157: b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft));
158: a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft));
159:
160: if (r>255) {
161: r = 255;
162: }
163:
164: if (g>255) {
165: g = 255;
166: }
167:
168: if (b>255) {
169: b = 255;
170: }
171:
172: if (a>127) {
173: a = 127;
174: }
175:
176: if (ignoretransparent && pxlSrc == dst->transparent) {
177: pxlSrc = dst->transparent;
178: } else {
179: pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a);
180:
181: if (pxlSrc == -1) {
182: pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a);
183: }
184: }
185:
186: if ((iYPos >= 0) && (iYPos < dst->sy)) {
187: gdImageSetPixel (dst, uCol, iYPos, pxlSrc);
188: }
189:
190: pxlOldLeft = pxlLeft;
191: }
192:
193: i = iYPos;
194: if (i < dst->sy) {
195: gdImageSetPixel (dst, uCol, i, pxlLeft);
196: }
197:
198: i--;
199: while (++i < dst->sy) {
200: gdImageSetPixel (dst, uCol, i, clrBack);
201: }
202: }
203:
204: /* Rotates an image by 90 degrees (counter clockwise) */
205: gdImagePtr gdImageRotate90 (gdImagePtr src, int ignoretransparent)
206: {
207: int uY, uX;
208: int c,r,g,b,a;
209: gdImagePtr dst;
210: typedef int (*FuncPtr)(gdImagePtr, int, int);
211: FuncPtr f;
212:
213: if (src->trueColor) {
214: f = gdImageGetTrueColorPixel;
215: } else {
216: f = gdImageGetPixel;
217: }
218: dst = gdImageCreateTrueColor(src->sy, src->sx);
219: dst->transparent = src->transparent;
220:
221: if (dst != NULL) {
222: int old_blendmode = dst->alphaBlendingFlag;
223: dst->alphaBlendingFlag = 0;
224:
225: gdImagePaletteCopy (dst, src);
226:
227: for (uY = 0; uY<src->sy; uY++) {
228: for (uX = 0; uX<src->sx; uX++) {
229: c = f (src, uX, uY);
230: if (!src->trueColor) {
231: r = gdImageRed(src,c);
232: g = gdImageGreen(src,c);
233: b = gdImageBlue(src,c);
234: a = gdImageAlpha(src,c);
235: c = gdTrueColorAlpha(r, g, b, a);
236: }
237: if (ignoretransparent && c == dst->transparent) {
238: gdImageSetPixel(dst, uY, (dst->sy - uX - 1), dst->transparent);
239: } else {
240: gdImageSetPixel(dst, uY, (dst->sy - uX - 1), c);
241: }
242: }
243: }
244: dst->alphaBlendingFlag = old_blendmode;
245: }
246:
247: return dst;
248: }
249:
250: /* Rotates an image by 180 degrees (counter clockwise) */
251: gdImagePtr gdImageRotate180 (gdImagePtr src, int ignoretransparent)
252: {
253: int uY, uX;
254: int c,r,g,b,a;
255: gdImagePtr dst;
256: typedef int (*FuncPtr)(gdImagePtr, int, int);
257: FuncPtr f;
258:
259: if (src->trueColor) {
260: f = gdImageGetTrueColorPixel;
261: } else {
262: f = gdImageGetPixel;
263: }
264: dst = gdImageCreateTrueColor(src->sx, src->sy);
265: dst->transparent = src->transparent;
266:
267: if (dst != NULL) {
268: int old_blendmode = dst->alphaBlendingFlag;
269: dst->alphaBlendingFlag = 0;
270:
271: gdImagePaletteCopy (dst, src);
272:
273: for (uY = 0; uY<src->sy; uY++) {
274: for (uX = 0; uX<src->sx; uX++) {
275: c = f (src, uX, uY);
276: if (!src->trueColor) {
277: r = gdImageRed(src,c);
278: g = gdImageGreen(src,c);
279: b = gdImageBlue(src,c);
280: a = gdImageAlpha(src,c);
281: c = gdTrueColorAlpha(r, g, b, a);
282: }
283:
284: if (ignoretransparent && c == dst->transparent) {
285: gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), dst->transparent);
286: } else {
287: gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), c);
288: }
289: }
290: }
291: dst->alphaBlendingFlag = old_blendmode;
292: }
293:
294: return dst;
295: }
296:
297: /* Rotates an image by 270 degrees (counter clockwise) */
298: gdImagePtr gdImageRotate270 (gdImagePtr src, int ignoretransparent)
299: {
300: int uY, uX;
301: int c,r,g,b,a;
302: gdImagePtr dst;
303: typedef int (*FuncPtr)(gdImagePtr, int, int);
304: FuncPtr f;
305:
306: if (src->trueColor) {
307: f = gdImageGetTrueColorPixel;
308: } else {
309: f = gdImageGetPixel;
310: }
311: dst = gdImageCreateTrueColor (src->sy, src->sx);
312: dst->transparent = src->transparent;
313:
314: if (dst != NULL) {
315: int old_blendmode = dst->alphaBlendingFlag;
316: dst->alphaBlendingFlag = 0;
317:
318: gdImagePaletteCopy (dst, src);
319:
320: for (uY = 0; uY<src->sy; uY++) {
321: for (uX = 0; uX<src->sx; uX++) {
322: c = f (src, uX, uY);
323: if (!src->trueColor) {
324: r = gdImageRed(src,c);
325: g = gdImageGreen(src,c);
326: b = gdImageBlue(src,c);
327: a = gdImageAlpha(src,c);
328: c = gdTrueColorAlpha(r, g, b, a);
329: }
330:
331: if (ignoretransparent && c == dst->transparent) {
332: gdImageSetPixel(dst, (dst->sx - uY - 1), uX, dst->transparent);
333: } else {
334: gdImageSetPixel(dst, (dst->sx - uY - 1), uX, c);
335: }
336: }
337: }
338: dst->alphaBlendingFlag = old_blendmode;
339: }
340:
341: return dst;
342: }
343:
344: gdImagePtr gdImageRotate45 (gdImagePtr src, double dAngle, int clrBack, int ignoretransparent)
345: {
346: typedef int (*FuncPtr)(gdImagePtr, int, int);
347: gdImagePtr dst1,dst2,dst3;
348: FuncPtr f;
349: double dRadAngle, dSinE, dTan, dShear;
350: double dOffset; /* Variable skew offset */
351: int u, iShear, newx, newy;
352: int clrBackR, clrBackG, clrBackB, clrBackA;
353:
354: /* See GEMS I for the algorithm details */
355: dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
356: dSinE = sin (dRadAngle);
357: dTan = tan (dRadAngle / 2.0);
358:
359: newx = (int)(src->sx + src->sy * fabs(dTan));
360: newy = src->sy;
361:
362: /* 1st shear */
363: if (src->trueColor) {
364: f = gdImageGetTrueColorPixel;
365: } else {
366: f = gdImageGetPixel;
367: }
368:
369: dst1 = gdImageCreateTrueColor(newx, newy);
370: /******* Perform 1st shear (horizontal) ******/
371: if (dst1 == NULL) {
372: return NULL;
373: }
374: #ifdef HAVE_GD_BUNDLED
375: dst1->alphaBlendingFlag = gdEffectReplace;
376: #else
377: gdImageAlphaBlending(dst1, 0);
378: #endif
379: if (dAngle == 0.0) {
380: /* Returns copy of src */
381: gdImageCopy (dst1, src,0,0,0,0,src->sx,src->sy);
382: return dst1;
383: }
384:
385: gdImagePaletteCopy (dst1, src);
386:
387: if (ignoretransparent) {
388: if (gdImageTrueColor(src)) {
389: dst1->transparent = src->transparent;
390: } else {
391:
392: dst1->transparent = gdTrueColorAlpha(gdImageRed(src, src->transparent), gdImageBlue(src, src->transparent), gdImageGreen(src, src->transparent), 127);
393: }
394: }
395:
396: dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */
397: dSinE = sin (dRadAngle);
398: dTan = tan (dRadAngle / 2.0);
399:
400: for (u = 0; u < dst1->sy; u++) {
401: if (dTan >= 0.0) {
402: dShear = ((double)(u + 0.5)) * dTan;
403: } else {
404: dShear = ((double)(u - dst1->sy) + 0.5) * dTan;
405: }
406:
407: iShear = (int)floor(dShear);
408: gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack, ignoretransparent);
409: }
410:
411: /*
412: The 1st shear may use the original clrBack as color index
413: Convert it once here
414: */
415: if(!src->trueColor) {
416: clrBackR = gdImageRed(src, clrBack);
417: clrBackG = gdImageGreen(src, clrBack);
418: clrBackB = gdImageBlue(src, clrBack);
419: clrBackA = gdImageAlpha(src, clrBack);
420: clrBack = gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA);
421: }
422: /* 2nd shear */
423: newx = dst1->sx;
424:
425: if (dSinE > 0.0) {
426: dOffset = (src->sx-1) * dSinE;
427: } else {
428: dOffset = -dSinE * (src->sx - newx);
429: }
430:
431: newy = (int) ((double) src->sx * fabs( dSinE ) + (double) src->sy * cos (dRadAngle))+1;
432:
433: if (src->trueColor) {
434: f = gdImageGetTrueColorPixel;
435: } else {
436: f = gdImageGetPixel;
437: }
438: dst2 = gdImageCreateTrueColor(newx, newy);
439: if (dst2 == NULL) {
440: gdImageDestroy(dst1);
441: return NULL;
442: }
443:
444: #ifdef HAVE_GD_BUNDLED
445: dst2->alphaBlendingFlag = gdEffectReplace;
446: #else
447: gdImageAlphaBlending(dst2, 0);
448: #endif
449:
450: if (ignoretransparent) {
451: dst2->transparent = dst1->transparent;
452: }
453:
454: for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) {
455: iShear = (int)floor (dOffset);
456: gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), clrBack, ignoretransparent);
457: }
458:
459: /* 3rd shear */
460: gdImageDestroy(dst1);
461:
462: newx = (int) ((double)src->sy * fabs (dSinE) + (double)src->sx * cos (dRadAngle)) + 1;
463: newy = dst2->sy;
464:
465: if (src->trueColor) {
466: f = gdImageGetTrueColorPixel;
467: } else {
468: f = gdImageGetPixel;
469: }
470: dst3 = gdImageCreateTrueColor(newx, newy);
471: if (dst3 == NULL) {
472: gdImageDestroy(dst2);
473: return NULL;
474: }
475:
476: #ifdef HAVE_GD_BUNDLED
477: dst3->alphaBlendingFlag = gdEffectReplace;
478: #else
479: gdImageAlphaBlending(dst3, 0);
480: #endif
481:
482: if (ignoretransparent) {
483: dst3->transparent = dst2->transparent;
484: }
485:
486: if (dSinE >= 0.0) {
487: dOffset = (double)(src->sx - 1) * dSinE * -dTan;
488: } else {
489: dOffset = dTan * ((double)(src->sx - 1) * -dSinE + (double)(1 - newy));
490: }
491:
492: for (u = 0; u < dst3->sy; u++, dOffset += dTan) {
493: int iShear = (int)floor(dOffset);
494: gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), clrBack, ignoretransparent);
495: }
496:
497: gdImageDestroy(dst2);
498:
499: return dst3;
500: }
501:
502: gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int ignoretransparent)
503: {
504: gdImagePtr pMidImg;
505: gdImagePtr rotatedImg;
506:
507: if (src == NULL) {
508: return NULL;
509: }
510:
511: if (!gdImageTrueColor(src) && (clrBack < 0 || clrBack>=gdImageColorsTotal(src))) {
512: return NULL;
513: }
514:
515: while (dAngle >= 360.0) {
516: dAngle -= 360.0;
517: }
518:
519: while (dAngle < 0) {
520: dAngle += 360.0;
521: }
522:
523: if (dAngle == 90.00) {
524: return gdImageRotate90(src, ignoretransparent);
525: }
526: if (dAngle == 180.00) {
527: return gdImageRotate180(src, ignoretransparent);
528: }
529: if(dAngle == 270.00) {
530: return gdImageRotate270 (src, ignoretransparent);
531: }
532:
533: if ((dAngle > 45.0) && (dAngle <= 135.0)) {
534: pMidImg = gdImageRotate90 (src, ignoretransparent);
535: dAngle -= 90.0;
536: } else if ((dAngle > 135.0) && (dAngle <= 225.0)) {
537: pMidImg = gdImageRotate180 (src, ignoretransparent);
538: dAngle -= 180.0;
539: } else if ((dAngle > 225.0) && (dAngle <= 315.0)) {
540: pMidImg = gdImageRotate270 (src, ignoretransparent);
541: dAngle -= 270.0;
542: } else {
543: return gdImageRotate45 (src, dAngle, clrBack, ignoretransparent);
544: }
545:
546: if (pMidImg == NULL) {
547: return NULL;
548: }
549:
550: rotatedImg = gdImageRotate45 (pMidImg, dAngle, clrBack, ignoretransparent);
551: gdImageDestroy(pMidImg);
552:
553: return rotatedImg;
554: }
555: /* End Rotate function */
556:
557: