![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd_filter.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_filter.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:
9: /* Filters function added on 2003/12
10: * by Pierre-Alain Joye (pierre@php.net)
11: **/
12: /* Begin filters function */
13: #define GET_PIXEL_FUNCTION(src)(src->trueColor?gdImageGetTrueColorPixel:gdImageGetPixel)
14:
15: /* invert src image */
16: int gdImageNegate(gdImagePtr src)
17: {
18: int x, y;
19: int r,g,b,a;
20: int new_pxl, pxl;
21: typedef int (*FuncPtr)(gdImagePtr, int, int);
22: FuncPtr f;
23:
24: if (src==NULL) {
25: return 0;
26: }
27:
28: f = GET_PIXEL_FUNCTION(src);
29:
30: for (y=0; y<src->sy; ++y) {
31: for (x=0; x<src->sx; ++x) {
32: pxl = f (src, x, y);
33: r = gdImageRed(src, pxl);
34: g = gdImageGreen(src, pxl);
35: b = gdImageBlue(src, pxl);
36: a = gdImageAlpha(src, pxl);
37:
38: new_pxl = gdImageColorAllocateAlpha(src, 255-r, 255-g, 255-b, a);
39: if (new_pxl == -1) {
40: new_pxl = gdImageColorClosestAlpha(src, 255-r, 255-g, 255-b, a);
41: }
42: gdImageSetPixel (src, x, y, new_pxl);
43: }
44: }
45: return 1;
46: }
47:
48: /* Convert the image src to a grayscale image */
49: int gdImageGrayScale(gdImagePtr src)
50: {
51: int x, y;
52: int r,g,b,a;
53: int new_pxl, pxl;
54: typedef int (*FuncPtr)(gdImagePtr, int, int);
55: FuncPtr f;
56: f = GET_PIXEL_FUNCTION(src);
57:
58: if (src==NULL) {
59: return 0;
60: }
61:
62: for (y=0; y<src->sy; ++y) {
63: for (x=0; x<src->sx; ++x) {
64: pxl = f (src, x, y);
65: r = gdImageRed(src, pxl);
66: g = gdImageGreen(src, pxl);
67: b = gdImageBlue(src, pxl);
68: a = gdImageAlpha(src, pxl);
69: r = g = b = (int) (.299 * r + .587 * g + .114 * b);
70:
71: new_pxl = gdImageColorAllocateAlpha(src, r, g, b, a);
72: if (new_pxl == -1) {
73: new_pxl = gdImageColorClosestAlpha(src, r, g, b, a);
74: }
75: gdImageSetPixel (src, x, y, new_pxl);
76: }
77: }
78: return 1;
79: }
80:
81: /* Set the brightness level <level> for the image src */
82: int gdImageBrightness(gdImagePtr src, int brightness)
83: {
84: int x, y;
85: int r,g,b,a;
86: int new_pxl, pxl;
87: typedef int (*FuncPtr)(gdImagePtr, int, int);
88: FuncPtr f;
89: f = GET_PIXEL_FUNCTION(src);
90:
91: if (src==NULL || (brightness < -255 || brightness>255)) {
92: return 0;
93: }
94:
95: if (brightness==0) {
96: return 1;
97: }
98:
99: for (y=0; y<src->sy; ++y) {
100: for (x=0; x<src->sx; ++x) {
101: pxl = f (src, x, y);
102:
103: r = gdImageRed(src, pxl);
104: g = gdImageGreen(src, pxl);
105: b = gdImageBlue(src, pxl);
106: a = gdImageAlpha(src, pxl);
107:
108: r = r + brightness;
109: g = g + brightness;
110: b = b + brightness;
111:
112: r = (r > 255)? 255 : ((r < 0)? 0:r);
113: g = (g > 255)? 255 : ((g < 0)? 0:g);
114: b = (b > 255)? 255 : ((b < 0)? 0:b);
115:
116: new_pxl = gdImageColorAllocateAlpha(src, (int)r, (int)g, (int)b, a);
117: if (new_pxl == -1) {
118: new_pxl = gdImageColorClosestAlpha(src, (int)r, (int)g, (int)b, a);
119: }
120: gdImageSetPixel (src, x, y, new_pxl);
121: }
122: }
123: return 1;
124: }
125:
126:
127: int gdImageContrast(gdImagePtr src, double contrast)
128: {
129: int x, y;
130: int r,g,b,a;
131: double rf,gf,bf;
132: int new_pxl, pxl;
133: typedef int (*FuncPtr)(gdImagePtr, int, int);
134:
135: FuncPtr f;
136: f = GET_PIXEL_FUNCTION(src);
137:
138: if (src==NULL) {
139: return 0;
140: }
141:
142: contrast = (double)(100.0-contrast)/100.0;
143: contrast = contrast*contrast;
144:
145: for (y=0; y<src->sy; ++y) {
146: for (x=0; x<src->sx; ++x) {
147: pxl = f(src, x, y);
148:
149: r = gdImageRed(src, pxl);
150: g = gdImageGreen(src, pxl);
151: b = gdImageBlue(src, pxl);
152: a = gdImageAlpha(src, pxl);
153:
154: rf = (double)r/255.0;
155: rf = rf-0.5;
156: rf = rf*contrast;
157: rf = rf+0.5;
158: rf = rf*255.0;
159:
160: bf = (double)b/255.0;
161: bf = bf-0.5;
162: bf = bf*contrast;
163: bf = bf+0.5;
164: bf = bf*255.0;
165:
166: gf = (double)g/255.0;
167: gf = gf-0.5;
168: gf = gf*contrast;
169: gf = gf+0.5;
170: gf = gf*255.0;
171:
172: rf = (rf > 255.0)? 255.0 : ((rf < 0.0)? 0.0:rf);
173: gf = (gf > 255.0)? 255.0 : ((gf < 0.0)? 0.0:gf);
174: bf = (bf > 255.0)? 255.0 : ((bf < 0.0)? 0.0:bf);
175:
176: new_pxl = gdImageColorAllocateAlpha(src, (int)rf, (int)gf, (int)bf, a);
177: if (new_pxl == -1) {
178: new_pxl = gdImageColorClosestAlpha(src, (int)rf, (int)gf, (int)bf, a);
179: }
180: gdImageSetPixel (src, x, y, new_pxl);
181: }
182: }
183: return 1;
184: }
185:
186:
187: int gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha)
188: {
189: int x, y;
190: int new_pxl, pxl;
191: typedef int (*FuncPtr)(gdImagePtr, int, int);
192: FuncPtr f;
193:
194: if (src == NULL) {
195: return 0;
196: }
197:
198: f = GET_PIXEL_FUNCTION(src);
199:
200: for (y=0; y<src->sy; ++y) {
201: for (x=0; x<src->sx; ++x) {
202: int r,g,b,a;
203:
204: pxl = f(src, x, y);
205: r = gdImageRed(src, pxl);
206: g = gdImageGreen(src, pxl);
207: b = gdImageBlue(src, pxl);
208: a = gdImageAlpha(src, pxl);
209:
210: r = r + red;
211: g = g + green;
212: b = b + blue;
213: a = a + alpha;
214:
215: r = (r > 255)? 255 : ((r < 0)? 0 : r);
216: g = (g > 255)? 255 : ((g < 0)? 0 : g);
217: b = (b > 255)? 255 : ((b < 0)? 0 : b);
218: a = (a > 127)? 127 : ((a < 0)? 0 : a);
219:
220: new_pxl = gdImageColorAllocateAlpha(src, r, g, b, a);
221: if (new_pxl == -1) {
222: new_pxl = gdImageColorClosestAlpha(src, r, g, b, a);
223: }
224: gdImageSetPixel (src, x, y, new_pxl);
225: }
226: }
227: return 1;
228: }
229:
230: int gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset)
231: {
232: int x, y, i, j, new_a;
233: float new_r, new_g, new_b;
234: int new_pxl, pxl=0;
235: gdImagePtr srcback;
236: typedef int (*FuncPtr)(gdImagePtr, int, int);
237: FuncPtr f;
238:
239: if (src==NULL) {
240: return 0;
241: }
242:
243: /* We need the orinal image with each safe neoghb. pixel */
244: srcback = gdImageCreateTrueColor (src->sx, src->sy);
245: if (srcback==NULL) {
246: return 0;
247: }
248:
249: gdImageSaveAlpha(srcback, 1);
250: new_pxl = gdImageColorAllocateAlpha(srcback, 0, 0, 0, 127);
251: gdImageFill(srcback, 0, 0, new_pxl);
252:
253: gdImageCopy(srcback, src,0,0,0,0,src->sx,src->sy);
254:
255: f = GET_PIXEL_FUNCTION(src);
256:
257: for ( y=0; y<src->sy; y++) {
258: for(x=0; x<src->sx; x++) {
259: new_r = new_g = new_b = 0;
260: new_a = gdImageAlpha(srcback, pxl);
261:
262: for (j=0; j<3; j++) {
263: int yv = MIN(MAX(y - 1 + j, 0), src->sy - 1);
264: for (i=0; i<3; i++) {
265: pxl = f(srcback, MIN(MAX(x - 1 + i, 0), src->sx - 1), yv);
266: new_r += (float)gdImageRed(srcback, pxl) * filter[j][i];
267: new_g += (float)gdImageGreen(srcback, pxl) * filter[j][i];
268: new_b += (float)gdImageBlue(srcback, pxl) * filter[j][i];
269: }
270: }
271:
272: new_r = (new_r/filter_div)+offset;
273: new_g = (new_g/filter_div)+offset;
274: new_b = (new_b/filter_div)+offset;
275:
276: new_r = (new_r > 255.0f)? 255.0f : ((new_r < 0.0f)? 0.0f:new_r);
277: new_g = (new_g > 255.0f)? 255.0f : ((new_g < 0.0f)? 0.0f:new_g);
278: new_b = (new_b > 255.0f)? 255.0f : ((new_b < 0.0f)? 0.0f:new_b);
279:
280: new_pxl = gdImageColorAllocateAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a);
281: if (new_pxl == -1) {
282: new_pxl = gdImageColorClosestAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a);
283: }
284: gdImageSetPixel (src, x, y, new_pxl);
285: }
286: }
287: gdImageDestroy(srcback);
288: return 1;
289: }
290:
291: int gdImageSelectiveBlur( gdImagePtr src)
292: {
293: int x, y, i, j;
294: float new_r, new_g, new_b;
295: int new_pxl, cpxl, pxl, new_a=0;
296: float flt_r [3][3];
297: float flt_g [3][3];
298: float flt_b [3][3];
299: float flt_r_sum, flt_g_sum, flt_b_sum;
300:
301: gdImagePtr srcback;
302: typedef int (*FuncPtr)(gdImagePtr, int, int);
303: FuncPtr f;
304:
305: if (src==NULL) {
306: return 0;
307: }
308:
309: /* We need the orinal image with each safe neoghb. pixel */
310: srcback = gdImageCreateTrueColor (src->sx, src->sy);
311: if (srcback==NULL) {
312: return 0;
313: }
314: gdImageCopy(srcback, src,0,0,0,0,src->sx,src->sy);
315:
316: f = GET_PIXEL_FUNCTION(src);
317:
318: for(y = 0; y<src->sy; y++) {
319: for (x=0; x<src->sx; x++) {
320: flt_r_sum = flt_g_sum = flt_b_sum = 0.0;
321: cpxl = f(src, x, y);
322:
323: for (j=0; j<3; j++) {
324: for (i=0; i<3; i++) {
325: if ((j == 1) && (i == 1)) {
326: flt_r[1][1] = flt_g[1][1] = flt_b[1][1] = 0.5;
327: } else {
328: pxl = f(src, x-(3>>1)+i, y-(3>>1)+j);
329: new_a = gdImageAlpha(srcback, pxl);
330:
331: new_r = ((float)gdImageRed(srcback, cpxl)) - ((float)gdImageRed (srcback, pxl));
332:
333: if (new_r < 0.0f) {
334: new_r = -new_r;
335: }
336: if (new_r != 0) {
337: flt_r[j][i] = 1.0f/new_r;
338: } else {
339: flt_r[j][i] = 1.0f;
340: }
341:
342: new_g = ((float)gdImageGreen(srcback, cpxl)) - ((float)gdImageGreen(srcback, pxl));
343:
344: if (new_g < 0.0f) {
345: new_g = -new_g;
346: }
347: if (new_g != 0) {
348: flt_g[j][i] = 1.0f/new_g;
349: } else {
350: flt_g[j][i] = 1.0f;
351: }
352:
353: new_b = ((float)gdImageBlue(srcback, cpxl)) - ((float)gdImageBlue(srcback, pxl));
354:
355: if (new_b < 0.0f) {
356: new_b = -new_b;
357: }
358: if (new_b != 0) {
359: flt_b[j][i] = 1.0f/new_b;
360: } else {
361: flt_b[j][i] = 1.0f;
362: }
363: }
364:
365: flt_r_sum += flt_r[j][i];
366: flt_g_sum += flt_g[j][i];
367: flt_b_sum += flt_b [j][i];
368: }
369: }
370:
371: for (j=0; j<3; j++) {
372: for (i=0; i<3; i++) {
373: if (flt_r_sum != 0.0) {
374: flt_r[j][i] /= flt_r_sum;
375: }
376: if (flt_g_sum != 0.0) {
377: flt_g[j][i] /= flt_g_sum;
378: }
379: if (flt_b_sum != 0.0) {
380: flt_b [j][i] /= flt_b_sum;
381: }
382: }
383: }
384:
385: new_r = new_g = new_b = 0.0;
386:
387: for (j=0; j<3; j++) {
388: for (i=0; i<3; i++) {
389: pxl = f(src, x-(3>>1)+i, y-(3>>1)+j);
390: new_r += (float)gdImageRed(srcback, pxl) * flt_r[j][i];
391: new_g += (float)gdImageGreen(srcback, pxl) * flt_g[j][i];
392: new_b += (float)gdImageBlue(srcback, pxl) * flt_b[j][i];
393: }
394: }
395:
396: new_r = (new_r > 255.0f)? 255.0f : ((new_r < 0.0f)? 0.0f:new_r);
397: new_g = (new_g > 255.0f)? 255.0f : ((new_g < 0.0f)? 0.0f:new_g);
398: new_b = (new_b > 255.0f)? 255.0f : ((new_b < 0.0f)? 0.0f:new_b);
399: new_pxl = gdImageColorAllocateAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a);
400: if (new_pxl == -1) {
401: new_pxl = gdImageColorClosestAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a);
402: }
403: gdImageSetPixel (src, x, y, new_pxl);
404: }
405: }
406: gdImageDestroy(srcback);
407: return 1;
408: }
409:
410: int gdImageEdgeDetectQuick(gdImagePtr src)
411: {
412: float filter[3][3] = {{-1.0,0.0,-1.0},
413: {0.0,4.0,0.0},
414: {-1.0,0.0,-1.0}};
415:
416: return gdImageConvolution(src, filter, 1, 127);
417: }
418:
419: int gdImageGaussianBlur(gdImagePtr im)
420: {
421: float filter[3][3] = {{1.0,2.0,1.0},
422: {2.0,4.0,2.0},
423: {1.0,2.0,1.0}};
424:
425: return gdImageConvolution(im, filter, 16, 0);
426: }
427:
428: int gdImageEmboss(gdImagePtr im)
429: {
430: /*
431: float filter[3][3] = {{1.0,1.0,1.0},
432: {0.0,0.0,0.0},
433: {-1.0,-1.0,-1.0}};
434: */
435: float filter[3][3] = {{ 1.5, 0.0, 0.0},
436: { 0.0, 0.0, 0.0},
437: { 0.0, 0.0,-1.5}};
438:
439: return gdImageConvolution(im, filter, 1, 127);
440: }
441:
442: int gdImageMeanRemoval(gdImagePtr im)
443: {
444: float filter[3][3] = {{-1.0,-1.0,-1.0},
445: {-1.0,9.0,-1.0},
446: {-1.0,-1.0,-1.0}};
447:
448: return gdImageConvolution(im, filter, 1, 0);
449: }
450:
451: int gdImageSmooth(gdImagePtr im, float weight)
452: {
453: float filter[3][3] = {{1.0,1.0,1.0},
454: {1.0,0.0,1.0},
455: {1.0,1.0,1.0}};
456:
457: filter[1][1] = weight;
458:
459: return gdImageConvolution(im, filter, weight+8, 0);
460: }
461: /* End filters function */