source: extensions/stripped_black_bloc/library/phpthumb/phpthumb.filters.php @ 12048

Last change on this file since 12048 was 12048, checked in by flop25, 13 years ago

adding an option to create big thumbnails periodically : new class css, admin option
changing timthumb to phpThumb.php : it's safer and works according document_root
=> new keys to translate
File size: 67.3 KB
Line 
1<?php
2//////////////////////////////////////////////////////////////
3///  phpThumb() by James Heinrich <info@silisoftware.com>   //
4//        available at http://phpthumb.sourceforge.net     ///
5//////////////////////////////////////////////////////////////
6///                                                         //
7// phpthumb.filters.php - image processing filter functions //
8//                                                         ///
9//////////////////////////////////////////////////////////////
10
11class phpthumb_filters {
12
13        var $phpThumbObject = null;
14
15        function phpthumb_filters() {
16                return true;
17        }
18
19        function ApplyMask(&$gdimg_mask, &$gdimg_image) {
20                if (phpthumb_functions::gd_version() < 2) {
21                        $this->DebugMessage('Skipping ApplyMask() because gd_version is "'.phpthumb_functions::gd_version().'"', __FILE__, __LINE__);
22                        return false;
23                }
24                if (phpthumb_functions::version_compare_replacement(phpversion(), '4.3.2', '>=')) {
25
26                        $this->DebugMessage('Using alpha ApplyMask() technique', __FILE__, __LINE__);
27                        if ($gdimg_mask_resized = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg_image), ImageSY($gdimg_image))) {
28
29                                ImageCopyResampled($gdimg_mask_resized, $gdimg_mask, 0, 0, 0, 0, ImageSX($gdimg_image), ImageSY($gdimg_image), ImageSX($gdimg_mask), ImageSY($gdimg_mask));
30                                if ($gdimg_mask_blendtemp = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg_image), ImageSY($gdimg_image))) {
31
32                                        $color_background = ImageColorAllocate($gdimg_mask_blendtemp, 0, 0, 0);
33                                        ImageFilledRectangle($gdimg_mask_blendtemp, 0, 0, ImageSX($gdimg_mask_blendtemp), ImageSY($gdimg_mask_blendtemp), $color_background);
34                                        ImageAlphaBlending($gdimg_mask_blendtemp, false);
35                                        ImageSaveAlpha($gdimg_mask_blendtemp, true);
36                                        for ($x = 0; $x < ImageSX($gdimg_image); $x++) {
37                                                for ($y = 0; $y < ImageSY($gdimg_image); $y++) {
38                                                        //$RealPixel = phpthumb_functions::GetPixelColor($gdimg_mask_blendtemp, $x, $y);
39                                                        $RealPixel = phpthumb_functions::GetPixelColor($gdimg_image, $x, $y);
40                                                        $MaskPixel = phpthumb_functions::GrayscalePixel(phpthumb_functions::GetPixelColor($gdimg_mask_resized, $x, $y));
41                                                        $MaskAlpha = 127 - (floor($MaskPixel['red'] / 2) * (1 - ($RealPixel['alpha'] / 127)));
42                                                        $newcolor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg_mask_blendtemp, $RealPixel['red'], $RealPixel['green'], $RealPixel['blue'], $MaskAlpha);
43                                                        ImageSetPixel($gdimg_mask_blendtemp, $x, $y, $newcolor);
44                                                }
45                                        }
46                                        ImageAlphaBlending($gdimg_image, false);
47                                        ImageSaveAlpha($gdimg_image, true);
48                                        ImageCopy($gdimg_image, $gdimg_mask_blendtemp, 0, 0, 0, 0, ImageSX($gdimg_mask_blendtemp), ImageSY($gdimg_mask_blendtemp));
49                                        ImageDestroy($gdimg_mask_blendtemp);
50
51                                } else {
52                                        $this->DebugMessage('ImageCreateFunction() failed', __FILE__, __LINE__);
53                                }
54                                ImageDestroy($gdimg_mask_resized);
55
56                        } else {
57                                $this->DebugMessage('ImageCreateFunction() failed', __FILE__, __LINE__);
58                        }
59
60                } else {
61                        // alpha merging requires PHP v4.3.2+
62                        $this->DebugMessage('Skipping ApplyMask() technique because PHP is v"'.phpversion().'"', __FILE__, __LINE__);
63                }
64                return true;
65        }
66
67
68    function Bevel(&$gdimg, $width, $hexcolor1, $hexcolor2) {
69        $width     = ($width     ? $width     : 5);
70        $hexcolor1 = ($hexcolor1 ? $hexcolor1 : 'FFFFFF');
71        $hexcolor2 = ($hexcolor2 ? $hexcolor2 : '000000');
72
73        ImageAlphaBlending($gdimg, true);
74        for ($i = 0; $i < $width; $i++) {
75            $alpha = round(($i / $width) * 127);
76            $color1 = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor1, false, $alpha);
77            $color2 = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor2, false, $alpha);
78
79            ImageLine($gdimg,                   $i,                   $i + 1,                   $i, ImageSY($gdimg) - $i - 1, $color1); // left
80            ImageLine($gdimg,                   $i,                   $i    , ImageSX($gdimg) - $i,                   $i    , $color1); // top
81            ImageLine($gdimg, ImageSX($gdimg) - $i, ImageSY($gdimg) - $i - 1, ImageSX($gdimg) - $i,                   $i + 1, $color2); // right
82            ImageLine($gdimg, ImageSX($gdimg) - $i, ImageSY($gdimg) - $i    ,                   $i, ImageSY($gdimg) - $i    , $color2); // bottom
83        }
84        return true;
85    }
86
87
88        function Blur(&$gdimg, $radius=0.5) {
89                // Taken from Torstein Hønsi's phpUnsharpMask (see phpthumb.unsharp.php)
90
91                $radius = round(max(0, min($radius, 50)) * 2);
92                if (!$radius) {
93                        return false;
94                }
95
96                $w = ImageSX($gdimg);
97                $h = ImageSY($gdimg);
98                if ($imgBlur = ImageCreateTrueColor($w, $h)) {
99                        // Gaussian blur matrix:
100                        //      1       2       1
101                        //      2       4       2
102                        //      1       2       1
103
104                        // Move copies of the image around one pixel at the time and merge them with weight
105                        // according to the matrix. The same matrix is simply repeated for higher radii.
106                        for ($i = 0; $i < $radius; $i++)        {
107                                ImageCopy     ($imgBlur, $gdimg, 0, 0, 1, 1, $w - 1, $h - 1);            // up left
108                                ImageCopyMerge($imgBlur, $gdimg, 1, 1, 0, 0, $w,     $h,     50.00000);  // down right
109                                ImageCopyMerge($imgBlur, $gdimg, 0, 1, 1, 0, $w - 1, $h,     33.33333);  // down left
110                                ImageCopyMerge($imgBlur, $gdimg, 1, 0, 0, 1, $w,     $h - 1, 25.00000);  // up right
111                                ImageCopyMerge($imgBlur, $gdimg, 0, 0, 1, 0, $w - 1, $h,     33.33333);  // left
112                                ImageCopyMerge($imgBlur, $gdimg, 1, 0, 0, 0, $w,     $h,     25.00000);  // right
113                                ImageCopyMerge($imgBlur, $gdimg, 0, 0, 0, 1, $w,     $h - 1, 20.00000);  // up
114                                ImageCopyMerge($imgBlur, $gdimg, 0, 1, 0, 0, $w,     $h,     16.666667); // down
115                                ImageCopyMerge($imgBlur, $gdimg, 0, 0, 0, 0, $w,     $h,     50.000000); // center
116                                ImageCopy     ($gdimg, $imgBlur, 0, 0, 0, 0, $w,     $h);
117                        }
118                        return true;
119                }
120                return false;
121        }
122
123
124        function BlurGaussian(&$gdimg) {
125                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
126                        if (ImageFilter($gdimg, IMG_FILTER_GAUSSIAN_BLUR)) {
127                                return true;
128                        }
129                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_GAUSSIAN_BLUR)', __FILE__, __LINE__);
130                        // fall through and try it the hard way
131                }
132                $this->DebugMessage('FAILED: phpthumb_filters::BlurGaussian($gdimg) [using phpthumb_filters::Blur() instead]', __FILE__, __LINE__);
133                return phpthumb_filters::Blur($gdimg, 0.5);
134        }
135
136
137        function BlurSelective(&$gdimg) {
138                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
139                        if (ImageFilter($gdimg, IMG_FILTER_SELECTIVE_BLUR)) {
140                                return true;
141                        }
142                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_SELECTIVE_BLUR)', __FILE__, __LINE__);
143                        // fall through and try it the hard way
144                }
145                // currently not implemented "the hard way"
146                $this->DebugMessage('FAILED: phpthumb_filters::BlurSelective($gdimg) [function not implemented]', __FILE__, __LINE__);
147                return false;
148        }
149
150
151        function Brightness(&$gdimg, $amount=0) {
152                if ($amount == 0) {
153                        return true;
154                }
155                $amount = max(-255, min(255, $amount));
156
157                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
158                        if (ImageFilter($gdimg, IMG_FILTER_BRIGHTNESS, $amount)) {
159                                return true;
160                        }
161                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_BRIGHTNESS, '.$amount.')', __FILE__, __LINE__);
162                        // fall through and try it the hard way
163                }
164
165                $scaling = (255 - abs($amount)) / 255;
166                $baseamount = (($amount > 0) ? $amount : 0);
167                for ($x = 0; $x < ImageSX($gdimg); $x++) {
168                        for ($y = 0; $y < ImageSY($gdimg); $y++) {
169                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
170                                foreach ($OriginalPixel as $key => $value) {
171                                        $NewPixel[$key] = round($baseamount + ($OriginalPixel[$key] * $scaling));
172                                }
173                                $newColor = ImageColorAllocate($gdimg, $NewPixel['red'], $NewPixel['green'], $NewPixel['blue']);
174                                ImageSetPixel($gdimg, $x, $y, $newColor);
175                        }
176                }
177                return true;
178        }
179
180
181        function Contrast(&$gdimg, $amount=0) {
182                if ($amount == 0) {
183                        return true;
184                }
185                $amount = max(-255, min(255, $amount));
186
187                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
188                        // ImageFilter(IMG_FILTER_CONTRAST) has range +100 to -100 (positive numbers make it darker!)
189                        $amount = ($amount / 255) * -100;
190                        if (ImageFilter($gdimg, IMG_FILTER_CONTRAST, $amount)) {
191                                return true;
192                        }
193                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_CONTRAST, '.$amount.')', __FILE__, __LINE__);
194                        // fall through and try it the hard way
195                }
196
197                if ($amount > 0) {
198                        $scaling = 1 + ($amount / 255);
199                } else {
200                        $scaling = (255 - abs($amount)) / 255;
201                }
202                for ($x = 0; $x < ImageSX($gdimg); $x++) {
203                        for ($y = 0; $y < ImageSY($gdimg); $y++) {
204                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
205                                foreach ($OriginalPixel as $key => $value) {
206                                        $NewPixel[$key] = min(255, max(0, round($OriginalPixel[$key] * $scaling)));
207                                }
208                                $newColor = ImageColorAllocate($gdimg, $NewPixel['red'], $NewPixel['green'], $NewPixel['blue']);
209                                ImageSetPixel($gdimg, $x, $y, $newColor);
210                        }
211                }
212        }
213
214
215        function Colorize(&$gdimg, $amount, $targetColor) {
216                $amount      = (is_numeric($amount)                          ? $amount      : 25);
217                $amountPct   = $amount / 100;
218                $targetColor = (phpthumb_functions::IsHexColor($targetColor) ? $targetColor : 'gray');
219
220                if ($amount == 0) {
221                        return true;
222                }
223
224                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
225                        if ($targetColor == 'gray') {
226                                $targetColor = '808080';
227                        }
228                        $r = round($amountPct * hexdec(substr($targetColor, 0, 2)));
229                        $g = round($amountPct * hexdec(substr($targetColor, 2, 2)));
230                        $b = round($amountPct * hexdec(substr($targetColor, 4, 2)));
231                        if (ImageFilter($gdimg, IMG_FILTER_COLORIZE, $r, $g, $b)) {
232                                return true;
233                        }
234                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_COLORIZE)', __FILE__, __LINE__);
235                        // fall through and try it the hard way
236                }
237
238                // overridden below for grayscale
239                if ($targetColor != 'gray') {
240                        $TargetPixel['red']   = hexdec(substr($targetColor, 0, 2));
241                        $TargetPixel['green'] = hexdec(substr($targetColor, 2, 2));
242                        $TargetPixel['blue']  = hexdec(substr($targetColor, 4, 2));
243                }
244
245                for ($x = 0; $x < ImageSX($gdimg); $x++) {
246                        for ($y = 0; $y < ImageSY($gdimg); $y++) {
247                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
248                                if ($targetColor == 'gray') {
249                                        $TargetPixel = phpthumb_functions::GrayscalePixel($OriginalPixel);
250                                }
251                                foreach ($TargetPixel as $key => $value) {
252                                        $NewPixel[$key] = round(max(0, min(255, ($OriginalPixel[$key] * ((100 - $amount) / 100)) + ($TargetPixel[$key] * $amountPct))));
253                                }
254                                //$newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, $NewPixel['red'], $NewPixel['green'], $NewPixel['blue'], $OriginalPixel['alpha']);
255                                $newColor = ImageColorAllocate($gdimg, $NewPixel['red'], $NewPixel['green'], $NewPixel['blue']);
256                                ImageSetPixel($gdimg, $x, $y, $newColor);
257                        }
258                }
259                return true;
260        }
261
262
263        function Crop(&$gdimg, $left=0, $right=0, $top=0, $bottom=0) {
264                if (!$left && !$right && !$top && !$bottom) {
265                        return true;
266                }
267                $oldW = ImageSX($gdimg);
268                $oldH = ImageSY($gdimg);
269                if (($left   > 0) && ($left   < 1)) { $left   = round($left   * $oldW); }
270                if (($right  > 0) && ($right  < 1)) { $right  = round($right  * $oldW); }
271                if (($top    > 0) && ($top    < 1)) { $top    = round($top    * $oldH); }
272                if (($bottom > 0) && ($bottom < 1)) { $bottom = round($bottom * $oldH); }
273                $right  = min($oldW - $left - 1, $right);
274                $bottom = min($oldH - $top  - 1, $bottom);
275                $newW = $oldW - $left - $right;
276                $newH = $oldH - $top  - $bottom;
277
278                if ($imgCropped = ImageCreateTrueColor($newW, $newH)) {
279                        ImageCopy($imgCropped, $gdimg, 0, 0, $left, $top, $newW, $newH);
280                        if ($gdimg = ImageCreateTrueColor($newW, $newH)) {
281                                ImageCopy($gdimg, $imgCropped, 0, 0, 0, 0, $newW, $newH);
282                                ImageDestroy($imgCropped);
283                                return true;
284                        }
285                        ImageDestroy($imgCropped);
286                }
287                return false;
288        }
289
290
291        function Desaturate(&$gdimg, $amount, $color='') {
292                if ($amount == 0) {
293                        return true;
294                }
295                return phpthumb_filters::Colorize($gdimg, $amount, (phpthumb_functions::IsHexColor($color) ? $color : 'gray'));
296        }
297
298
299        function DropShadow(&$gdimg, $distance, $width, $hexcolor, $angle, $alpha) {
300                if (phpthumb_functions::gd_version() < 2) {
301                        return false;
302                }
303                $distance =                 ($distance ? $distance : 10);
304                $width    =                 ($width    ? $width    : 10);
305                $hexcolor =                 ($hexcolor ? $hexcolor : '000000');
306                $angle    =                 ($angle    ? $angle    : 225) % 360;
307                $alpha    = max(0, min(100, ($alpha    ? $alpha    : 100)));
308
309                if ($alpha <= 0) {
310                        // invisible shadow, nothing to do
311                        return true;
312                }
313                if ($distance <= 0) {
314                        // shadow completely obscured by source image, nothing to do
315                        return true;
316                }
317
318                $width_shadow  = cos(deg2rad($angle)) * ($distance + $width);
319                $height_shadow = sin(deg2rad($angle)) * ($distance + $width);
320
321                $scaling = min(ImageSX($gdimg) / (ImageSX($gdimg) + abs($width_shadow)), ImageSY($gdimg) / (ImageSY($gdimg) + abs($height_shadow)));
322
323                for ($i = 0; $i < $width; $i++) {
324                        $WidthAlpha[$i] = (abs(($width / 2) - $i) / $width);
325                        $Offset['x'] = cos(deg2rad($angle)) * ($distance + $i);
326                        $Offset['y'] = sin(deg2rad($angle)) * ($distance + $i);
327                }
328
329                $tempImageWidth  = ImageSX($gdimg)  + abs($Offset['x']);
330                $tempImageHeight = ImageSY($gdimg) + abs($Offset['y']);
331
332                if ($gdimg_dropshadow_temp = phpthumb_functions::ImageCreateFunction($tempImageWidth, $tempImageHeight)) {
333
334                        ImageAlphaBlending($gdimg_dropshadow_temp, false);
335                        ImageSaveAlpha($gdimg_dropshadow_temp, true);
336                        $transparent1 = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg_dropshadow_temp, 0, 0, 0, 127);
337                        ImageFill($gdimg_dropshadow_temp, 0, 0, $transparent1);
338
339                        for ($x = 0; $x < ImageSX($gdimg); $x++) {
340                                for ($y = 0; $y < ImageSY($gdimg); $y++) {
341                                        $PixelMap[$x][$y] = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
342                                }
343                        }
344                        for ($x = 0; $x < $tempImageWidth; $x++) {
345                                for ($y = 0; $y < $tempImageHeight; $y++) {
346                                        //for ($i = 0; $i < $width; $i++) {
347                                        for ($i = 0; $i < 1; $i++) {
348                                                if (!isset($PixelMap[$x][$y]['alpha']) || ($PixelMap[$x][$y]['alpha'] > 0)) {
349                                                        if (isset($PixelMap[$x + $Offset['x']][$y + $Offset['y']]['alpha']) && ($PixelMap[$x + $Offset['x']][$y + $Offset['y']]['alpha'] < 127)) {
350                                                                $thisColor = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor, false, $PixelMap[$x + $Offset['x']][$y + $Offset['y']]['alpha']);
351                                                                ImageSetPixel($gdimg_dropshadow_temp, $x, $y, $thisColor);
352                                                        }
353                                                }
354                                        }
355                                }
356                        }
357
358                        ImageAlphaBlending($gdimg_dropshadow_temp, true);
359                        for ($x = 0; $x < ImageSX($gdimg); $x++) {
360                                for ($y = 0; $y < ImageSY($gdimg); $y++) {
361                                        if ($PixelMap[$x][$y]['alpha'] < 127) {
362                                                $thisColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg_dropshadow_temp, $PixelMap[$x][$y]['red'], $PixelMap[$x][$y]['green'], $PixelMap[$x][$y]['blue'], $PixelMap[$x][$y]['alpha']);
363                                                ImageSetPixel($gdimg_dropshadow_temp, $x, $y, $thisColor);
364                                        }
365                                }
366                        }
367
368                        ImageSaveAlpha($gdimg, true);
369                        ImageAlphaBlending($gdimg, false);
370                        //$this->is_alpha = true;
371                        $transparent2 = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, 0, 0, 0, 127);
372                        ImageFilledRectangle($gdimg, 0, 0, ImageSX($gdimg), ImageSY($gdimg), $transparent2);
373                        ImageCopyResampled($gdimg, $gdimg_dropshadow_temp, 0, 0, 0, 0, ImageSX($gdimg), ImageSY($gdimg), ImageSX($gdimg_dropshadow_temp), ImageSY($gdimg_dropshadow_temp));
374
375                        ImageDestroy($gdimg_dropshadow_temp);
376                }
377                return true;
378        }
379
380
381        function EdgeDetect(&$gdimg) {
382                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
383                        if (ImageFilter($gdimg, IMG_FILTER_EDGEDETECT)) {
384                                return true;
385                        }
386                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_EDGEDETECT)', __FILE__, __LINE__);
387                        // fall through and try it the hard way
388                }
389                // currently not implemented "the hard way"
390                $this->DebugMessage('FAILED: phpthumb_filters::EdgeDetect($gdimg) [function not implemented]', __FILE__, __LINE__);
391                return false;
392        }
393
394
395        function Elipse($gdimg) {
396                if (phpthumb_functions::gd_version() < 2) {
397                        return false;
398                }
399                // generate mask at twice desired resolution and downsample afterwards for easy antialiasing
400                if ($gdimg_elipsemask_double = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg) * 2, ImageSY($gdimg) * 2)) {
401                        if ($gdimg_elipsemask = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg), ImageSY($gdimg))) {
402
403                                $color_transparent = ImageColorAllocate($gdimg_elipsemask_double, 255, 255, 255);
404                                ImageFilledEllipse($gdimg_elipsemask_double, ImageSX($gdimg), ImageSY($gdimg), (ImageSX($gdimg) - 1) * 2, (ImageSY($gdimg) - 1) * 2, $color_transparent);
405                                ImageCopyResampled($gdimg_elipsemask, $gdimg_elipsemask_double, 0, 0, 0, 0, ImageSX($gdimg), ImageSY($gdimg), ImageSX($gdimg) * 2, ImageSY($gdimg) * 2);
406
407                                phpthumb_filters::ApplyMask($gdimg_elipsemask, $gdimg);
408                                ImageDestroy($gdimg_elipsemask);
409                                return true;
410
411                        } else {
412                                $this->DebugMessage('$gdimg_elipsemask = phpthumb_functions::ImageCreateFunction() failed', __FILE__, __LINE__);
413                        }
414                        ImageDestroy($gdimg_elipsemask_double);
415                } else {
416                        $this->DebugMessage('$gdimg_elipsemask_double = phpthumb_functions::ImageCreateFunction() failed', __FILE__, __LINE__);
417                }
418                return false;
419        }
420
421
422        function Emboss(&$gdimg) {
423                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
424                        if (ImageFilter($gdimg, IMG_FILTER_EMBOSS)) {
425                                return true;
426                        }
427                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_EMBOSS)', __FILE__, __LINE__);
428                        // fall through and try it the hard way
429                }
430                // currently not implemented "the hard way"
431                $this->DebugMessage('FAILED: phpthumb_filters::Emboss($gdimg) [function not implemented]', __FILE__, __LINE__);
432                return false;
433        }
434
435
436        function Flip(&$gdimg, $x=false, $y=false) {
437                if (!$x && !$y) {
438                        return false;
439                }
440                if ($tempImage = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg), ImageSY($gdimg))) {
441                        if ($x) {
442                                ImageCopy($tempImage, $gdimg, 0, 0, 0, 0, ImageSX($gdimg), ImageSY($gdimg));
443                                for ($x = 0; $x < ImageSX($gdimg); $x++) {
444                                        ImageCopy($gdimg, $tempImage, ImageSX($gdimg) - 1 - $x, 0, $x, 0, 1, ImageSY($gdimg));
445                                }
446                        }
447                        if ($y) {
448                                ImageCopy($tempImage, $gdimg, 0, 0, 0, 0, ImageSX($gdimg), ImageSY($gdimg));
449                                for ($y = 0; $y < ImageSY($gdimg); $y++) {
450                                        ImageCopy($gdimg, $tempImage, 0, ImageSY($gdimg) - 1 - $y, 0, $y, ImageSX($gdimg), 1);
451                                }
452                        }
453                        ImageDestroy($tempImage);
454                }
455                return true;
456        }
457
458
459        function Frame(&$gdimg, $frame_width, $edge_width, $hexcolor_frame, $hexcolor1, $hexcolor2) {
460                $frame_width    = ($frame_width    ? $frame_width    : 5);
461                $edge_width     = ($edge_width     ? $edge_width     : 1);
462                $hexcolor_frame = ($hexcolor_frame ? $hexcolor_frame : 'CCCCCC');
463                $hexcolor1      = ($hexcolor1      ? $hexcolor1      : 'FFFFFF');
464                $hexcolor2      = ($hexcolor2      ? $hexcolor2      : '000000');
465
466                $color_frame = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor_frame);
467                $color1      = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor1);
468                $color2      = phpthumb_functions::ImageHexColorAllocate($gdimg, $hexcolor2);
469                for ($i = 0; $i < $edge_width; $i++) {
470                        // outer bevel
471                        ImageLine($gdimg,                   $i,                   $i,                   $i, ImageSY($gdimg) - $i, $color1); // left
472                        ImageLine($gdimg,                   $i,                   $i, ImageSX($gdimg) - $i,                   $i, $color1); // top
473                        ImageLine($gdimg, ImageSX($gdimg) - $i, ImageSY($gdimg) - $i, ImageSX($gdimg) - $i,                   $i, $color2); // right
474                        ImageLine($gdimg, ImageSX($gdimg) - $i, ImageSY($gdimg) - $i,                   $i, ImageSY($gdimg) - $i, $color2); // bottom
475                }
476                for ($i = 0; $i < $frame_width; $i++) {
477                        // actual frame
478                        ImageRectangle($gdimg, $edge_width + $i, $edge_width + $i, ImageSX($gdimg) - $edge_width - $i, ImageSY($gdimg) - $edge_width - $i, $color_frame);
479                }
480                for ($i = 0; $i < $edge_width; $i++) {
481                        // inner bevel
482                        ImageLine($gdimg,                   $frame_width + $edge_width + $i,                   $frame_width + $edge_width + $i,                   $frame_width + $edge_width + $i, ImageSY($gdimg) - $frame_width - $edge_width - $i, $color2); // left
483                        ImageLine($gdimg,                   $frame_width + $edge_width + $i,                   $frame_width + $edge_width + $i, ImageSX($gdimg) - $frame_width - $edge_width - $i,                   $frame_width + $edge_width + $i, $color2); // top
484                        ImageLine($gdimg, ImageSX($gdimg) - $frame_width - $edge_width - $i, ImageSY($gdimg) - $frame_width - $edge_width - $i, ImageSX($gdimg) - $frame_width - $edge_width - $i,                   $frame_width + $edge_width + $i, $color1); // right
485                        ImageLine($gdimg, ImageSX($gdimg) - $frame_width - $edge_width - $i, ImageSY($gdimg) - $frame_width - $edge_width - $i,                   $frame_width + $edge_width + $i, ImageSY($gdimg) - $frame_width - $edge_width - $i, $color1); // bottom
486                }
487                return true;
488        }
489
490
491        function Gamma(&$gdimg, $amount) {
492                if (number_format($amount, 4) == '1.0000') {
493                        return true;
494                }
495                return ImageGammaCorrect($gdimg, 1.0, $amount);
496        }
497
498
499        function Grayscale(&$gdimg) {
500                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
501                        if (ImageFilter($gdimg, IMG_FILTER_GRAYSCALE)) {
502                                return true;
503                        }
504                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_GRAYSCALE)', __FILE__, __LINE__);
505                        // fall through and try it the hard way
506                }
507                return phpthumb_filters::Colorize($gdimg, 100, 'gray');
508        }
509
510
511        function HistogramAnalysis(&$gdimg, $calculateGray=false) {
512                $ImageSX = ImageSX($gdimg);
513                $ImageSY = ImageSY($gdimg);
514                for ($x = 0; $x < $ImageSX; $x++) {
515                        for ($y = 0; $y < $ImageSY; $y++) {
516                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
517                                @$Analysis['red'][$OriginalPixel['red']]++;
518                                @$Analysis['green'][$OriginalPixel['green']]++;
519                                @$Analysis['blue'][$OriginalPixel['blue']]++;
520                                @$Analysis['alpha'][$OriginalPixel['alpha']]++;
521                                if ($calculateGray) {
522                                        $GrayPixel = phpthumb_functions::GrayscalePixel($OriginalPixel);
523                                        @$Analysis['gray'][$GrayPixel['red']]++;
524                                }
525                        }
526                }
527                $keys = array('red', 'green', 'blue', 'alpha');
528                if ($calculateGray) {
529                        $keys[] = 'gray';
530                }
531                foreach ($keys as $dummy => $key) {
532                        ksort($Analysis[$key]);
533                }
534                return $Analysis;
535        }
536
537
538        function HistogramStretch(&$gdimg, $band='*', $method=0, $threshold=0.1) {
539                // equivalent of "Auto Contrast" in Adobe Photoshop
540                // method 0 stretches according to RGB colors. Gives a more conservative stretch.
541                // method 1 band stretches according to grayscale which is color-biased (59% green, 30% red, 11% blue). May give a punchier / more aggressive stretch, possibly appearing over-saturated
542                $Analysis = phpthumb_filters::HistogramAnalysis($gdimg, true);
543                $keys = array('r'=>'red', 'g'=>'green', 'b'=>'blue', 'a'=>'alpha', '*'=>(($method == 0) ? 'all' : 'gray'));
544                $band = substr($band, 0, 1);
545                if (!isset($keys[$band])) {
546                        return false;
547                }
548                $key = $keys[$band];
549
550                // If the absolute brightest and darkest pixels are used then one random
551                // pixel in the image could throw off the whole system. Instead, count up/down
552                // from the limit and allow <threshold> (default = 0.1%) of brightest/darkest
553                // pixels to be clipped to min/max
554                $threshold = floatval($threshold) / 100;
555                $clip_threshold = ImageSX($gdimg) * ImageSX($gdimg) * $threshold;
556                //if ($min >= 0) {
557                //      $range_min = min($min, 255);
558                //} else {
559                        $countsum = 0;
560                        for ($i = 0; $i <= 255; $i++) {
561                                if ($method == 0) {
562                                        $countsum = max(@$Analysis['red'][$i], @$Analysis['green'][$i], @$Analysis['blue'][$i]);
563                                } else {
564                                        $countsum += @$Analysis[$key][$i];
565                                }
566                                if ($countsum >= $clip_threshold) {
567                                        $range_min = $i - 1;
568                                        break;
569                                }
570                        }
571                        $range_min = max($range_min, 0);
572                //}
573                //if ($max > 0) {
574                //      $range_max = max($max, 255);
575                //} else {
576                        $countsum = 0;
577                        for ($i = 255; $i >= 0; $i--) {
578                                if ($method == 0) {
579                                        $countsum = max(@$Analysis['red'][$i], @$Analysis['green'][$i], @$Analysis['blue'][$i]);
580                                } else {
581                                        $countsum += @$Analysis[$key][$i];
582                                }
583                                if ($countsum >= $clip_threshold) {
584                                        $range_max = $i + 1;
585                                        break;
586                                }
587                        }
588                        $range_max = min($range_max, 255);
589                //}
590                $range_scale = (($range_max == $range_min) ? 1 : (255 / ($range_max - $range_min)));
591                if (($range_min == 0) && ($range_max == 255)) {
592                        // no adjustment neccesary - don't waste CPU time!
593                        return true;
594                }
595
596                $ImageSX = ImageSX($gdimg);
597                $ImageSY = ImageSY($gdimg);
598                for ($x = 0; $x < $ImageSX; $x++) {
599                        for ($y = 0; $y < $ImageSY; $y++) {
600                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
601                                if ($band == '*') {
602                                        $new['red']   = min(255, max(0, ($OriginalPixel['red']   - $range_min) * $range_scale));
603                                        $new['green'] = min(255, max(0, ($OriginalPixel['green'] - $range_min) * $range_scale));
604                                        $new['blue']  = min(255, max(0, ($OriginalPixel['blue']  - $range_min) * $range_scale));
605                                        $new['alpha'] = min(255, max(0, ($OriginalPixel['alpha'] - $range_min) * $range_scale));
606                                } else {
607                                        $new = $OriginalPixel;
608                                        $new[$key] = min(255, max(0, ($OriginalPixel[$key] - $range_min) * $range_scale));
609                                }
610                                $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, $new['red'], $new['green'], $new['blue'], $new['alpha']);
611                                ImageSetPixel($gdimg, $x, $y, $newColor);
612                        }
613                }
614
615                return true;
616        }
617
618
619        function HistogramOverlay(&$gdimg, $bands='*', $colors='', $width=0.25, $height=0.25, $alignment='BR', $opacity=50, $margin_x=5, $margin_y=null) {
620                $margin_y = (is_null($margin_y) ? $margin_x : $margin_y);
621
622                $Analysis = phpthumb_filters::HistogramAnalysis($gdimg, true);
623                $histW = round(($width > 1) ? min($width, ImageSX($gdimg)) : ImageSX($gdimg) * $width);
624                $histH = round(($width > 1) ? min($width, ImageSX($gdimg)) : ImageSX($gdimg) * $width);
625                if ($gdHist = ImageCreateTrueColor($histW, $histH)) {
626                        $color_back = phpthumb_functions::ImageColorAllocateAlphaSafe($gdHist, 0, 0, 0, 127);
627                        ImageFilledRectangle($gdHist, 0, 0, $histW, $histH, $color_back);
628                        ImageAlphaBlending($gdHist, false);
629                        ImageSaveAlpha($gdHist, true);
630
631                        $HistogramTempWidth  = 256;
632                        $HistogramTempHeight = 100;
633                        if ($gdHistTemp = ImageCreateTrueColor($HistogramTempWidth, $HistogramTempHeight)) {
634                                $color_back_temp = phpthumb_functions::ImageColorAllocateAlphaSafe($gdHistTemp, 255, 0, 255, 127);
635                                ImageAlphaBlending($gdHistTemp, false);
636                                ImageSaveAlpha($gdHistTemp, true);
637                                ImageFilledRectangle($gdHistTemp, 0, 0, ImageSX($gdHistTemp), ImageSY($gdHistTemp), $color_back_temp);
638
639                                $DefaultColors = array('r'=>'FF0000', 'g'=>'00FF00', 'b'=>'0000FF', 'a'=>'999999', '*'=>'FFFFFF');
640                                $Colors = explode(';', $colors);
641                                $BandsToGraph = array_unique(preg_split('##', $bands));
642                                $keys = array('r'=>'red', 'g'=>'green', 'b'=>'blue', 'a'=>'alpha', '*'=>'gray');
643                                foreach ($BandsToGraph as $key => $band) {
644                                        if (!isset($keys[$band])) {
645                                                continue;
646                                        }
647                                        $PeakValue = max($Analysis[$keys[$band]]);
648                                        $thisColor = phpthumb_functions::ImageHexColorAllocate($gdHistTemp, phpthumb_functions::IsHexColor(@$Colors[$key]) ? $Colors[$key] : $DefaultColors[$band]);
649                                        for ($x = 0; $x < $HistogramTempWidth; $x++) {
650                                                ImageLine($gdHistTemp, $x, $HistogramTempHeight - 1, $x, $HistogramTempHeight - 1 - round(@$Analysis[$keys[$band]][$x] / $PeakValue * $HistogramTempHeight), $thisColor);
651                                        }
652                                        ImageLine($gdHistTemp, 0, $HistogramTempHeight - 1, $HistogramTempWidth - 1, $HistogramTempHeight - 1, $thisColor);
653                                        ImageLine($gdHistTemp, 0, $HistogramTempHeight - 2, $HistogramTempWidth - 1, $HistogramTempHeight - 2, $thisColor);
654                                }
655                                ImageCopyResampled($gdHist, $gdHistTemp, 0, 0, 0, 0, ImageSX($gdHist), ImageSY($gdHist), ImageSX($gdHistTemp), ImageSY($gdHistTemp));
656                                ImageDestroy($gdHistTemp);
657                        } else {
658                                return false;
659                        }
660
661                        phpthumb_filters::WatermarkOverlay($gdimg, $gdHist, $alignment, $opacity, $margin_x, $margin_y);
662                        ImageDestroy($gdHist);
663                        return true;
664                }
665                return false;
666        }
667
668
669        function ImageBorder(&$gdimg, $border_width, $radius_x, $radius_y, $hexcolor_border) {
670                $border_width = ($border_width ? $border_width : 1);
671                $radius_x     = ($radius_x     ? $radius_x     : 0);
672                $radius_y     = ($radius_y     ? $radius_y     : 0);
673
674                $output_width  = ImageSX($gdimg);
675                $output_height = ImageSY($gdimg);
676
677                list($new_width, $new_height) = phpthumb_functions::ProportionalResize($output_width, $output_height, $output_width - max($border_width * 2, $radius_x), $output_height - max($border_width * 2, $radius_y));
678                $offset_x = ($radius_x ? $output_width  - $new_width  - $radius_x : 0);
679                $offset_y = ($radius_y ? $output_height - $new_height - $radius_y : 0);
680
681//header('Content-Type: image/png');
682//ImagePNG($gdimg);
683//exit;
684                if ($gd_border_canvas = phpthumb_functions::ImageCreateFunction($output_width, $output_height)) {
685
686                        ImageSaveAlpha($gd_border_canvas, true);
687                        ImageAlphaBlending($gd_border_canvas, false);
688                        $color_background = phpthumb_functions::ImageColorAllocateAlphaSafe($gd_border_canvas, 255, 255, 255, 127);
689                        ImageFilledRectangle($gd_border_canvas, 0, 0, $output_width, $output_height, $color_background);
690
691                        $color_border = phpthumb_functions::ImageHexColorAllocate($gd_border_canvas, (phpthumb_functions::IsHexColor($hexcolor_border) ? $hexcolor_border : '000000'));
692
693                        for ($i = 0; $i < $border_width; $i++) {
694                                ImageLine($gd_border_canvas,             floor($offset_x / 2) + $radius_x,                      $i, $output_width - $radius_x - ceil($offset_x / 2),                         $i, $color_border); // top
695                                ImageLine($gd_border_canvas,             floor($offset_x / 2) + $radius_x, $output_height - 1 - $i, $output_width - $radius_x - ceil($offset_x / 2),    $output_height - 1 - $i, $color_border); // bottom
696                                ImageLine($gd_border_canvas,                    floor($offset_x / 2) + $i,               $radius_y,                      floor($offset_x / 2) +  $i, $output_height - $radius_y, $color_border); // left
697                                ImageLine($gd_border_canvas, $output_width - 1 - $i - ceil($offset_x / 2),               $radius_y,    $output_width - 1 - $i - ceil($offset_x / 2), $output_height - $radius_y, $color_border); // right
698                        }
699
700                        if ($radius_x && $radius_y) {
701
702                                // PHP bug: ImageArc() with thicknesses > 1 give bad/undesirable/unpredicatable results
703                                // Solution: Draw multiple 1px arcs side-by-side.
704
705                                // Problem: parallel arcs give strange/ugly antialiasing problems
706                                // Solution: draw non-parallel arcs, from one side of the line thickness at the start angle
707                                //   to the opposite edge of the line thickness at the terminating angle
708                                for ($thickness_offset = 0; $thickness_offset < $border_width; $thickness_offset++) {
709                                        ImageArc($gd_border_canvas, floor($offset_x / 2) + 1 +                 $radius_x,              $thickness_offset - 1 + $radius_y, $radius_x * 2, $radius_y * 2, 180, 270, $color_border); // top-left
710                                        ImageArc($gd_border_canvas,                     $output_width - $radius_x - 1 - ceil($offset_x / 2),              $thickness_offset - 1 + $radius_y, $radius_x * 2, $radius_y * 2, 270, 360, $color_border); // top-right
711                                        ImageArc($gd_border_canvas,                     $output_width - $radius_x - 1 - ceil($offset_x / 2), $output_height - $thickness_offset - $radius_y, $radius_x * 2, $radius_y * 2,   0,  90, $color_border); // bottom-right
712                                        ImageArc($gd_border_canvas, floor($offset_x / 2) + 1 +                 $radius_x, $output_height - $thickness_offset - $radius_y, $radius_x * 2, $radius_y * 2,  90, 180, $color_border); // bottom-left
713                                }
714                                if ($border_width > 1) {
715                                        for ($thickness_offset = 0; $thickness_offset < $border_width; $thickness_offset++) {
716                                                ImageArc($gd_border_canvas, floor($offset_x / 2) + $thickness_offset + $radius_x,                                      $radius_y, $radius_x * 2, $radius_y * 2, 180, 270, $color_border); // top-left
717                                                ImageArc($gd_border_canvas, $output_width - $thickness_offset - $radius_x - 1 - ceil($offset_x / 2),                                      $radius_y, $radius_x * 2, $radius_y * 2, 270, 360, $color_border); // top-right
718                                                ImageArc($gd_border_canvas, $output_width - $thickness_offset - $radius_x - 1 - ceil($offset_x / 2),                     $output_height - $radius_y, $radius_x * 2, $radius_y * 2,   0,  90, $color_border); // bottom-right
719                                                ImageArc($gd_border_canvas, floor($offset_x / 2) + $thickness_offset + $radius_x,                     $output_height - $radius_y, $radius_x * 2, $radius_y * 2,  90, 180, $color_border); // bottom-left
720                                        }
721                                }
722
723                        }
724                        $this->phpThumbObject->ImageResizeFunction($gd_border_canvas, $gdimg, floor(($output_width - $new_width) / 2), round(($output_height - $new_height) / 2), 0, 0, $new_width, $new_height, $output_width, $output_height);
725
726                        ImageDestroy($gdimg);
727                        $gdimg = phpthumb_functions::ImageCreateFunction($output_width, $output_height);
728                        ImageSaveAlpha($gdimg, true);
729                        ImageAlphaBlending($gdimg, false);
730                        $gdimg_color_background = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, 255, 255, 255, 127);
731                        ImageFilledRectangle($gdimg, 0, 0, $output_width, $output_height, $gdimg_color_background);
732
733                        ImageCopy($gdimg, $gd_border_canvas, 0, 0, 0, 0, $output_width, $output_height);
734                        //$gdimg = $gd_border_canvas;
735                        ImageDestroy($gd_border_canvas);
736                        return true;
737
738
739                } else {
740                        $this->DebugMessage('FAILED: $gd_border_canvas = phpthumb_functions::ImageCreateFunction('.$output_width.', '.$output_height.')', __FILE__, __LINE__);
741                }
742                return false;
743        }
744
745
746        function ImprovedImageRotate(&$gdimg_source, $rotate_angle=0, $config_background_hexcolor='FFFFFF', $bg=null) {
747                while ($rotate_angle < 0) {
748                        $rotate_angle += 360;
749                }
750                $rotate_angle = $rotate_angle % 360;
751                if ($rotate_angle != 0) {
752
753                        $background_color = phpthumb_functions::ImageHexColorAllocate($gdimg_source, $config_background_hexcolor);
754
755                        if ((phpthumb_functions::gd_version() >= 2) && !$bg && ($rotate_angle % 90)) {
756
757                                //$this->DebugMessage('Using alpha rotate', __FILE__, __LINE__);
758                                if ($gdimg_rotate_mask = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg_source), ImageSY($gdimg_source))) {
759
760                                        for ($i = 0; $i <= 255; $i++) {
761                                                $color_mask[$i] = ImageColorAllocate($gdimg_rotate_mask, $i, $i, $i);
762                                        }
763                                        ImageFilledRectangle($gdimg_rotate_mask, 0, 0, ImageSX($gdimg_rotate_mask), ImageSY($gdimg_rotate_mask), $color_mask[255]);
764                                        $imageX = ImageSX($gdimg_source);
765                                        $imageY = ImageSY($gdimg_source);
766                                        for ($x = 0; $x < $imageX; $x++) {
767                                                for ($y = 0; $y < $imageY; $y++) {
768                                                        $pixelcolor = phpthumb_functions::GetPixelColor($gdimg_source, $x, $y);
769                                                        ImageSetPixel($gdimg_rotate_mask, $x, $y, $color_mask[255 - round($pixelcolor['alpha'] * 255 / 127)]);
770                                                }
771                                        }
772                                        $gdimg_rotate_mask  = ImageRotate($gdimg_rotate_mask,  $rotate_angle, $color_mask[0]);
773                                        $gdimg_source = ImageRotate($gdimg_source, $rotate_angle, $background_color);
774
775                                        ImageAlphaBlending($gdimg_source, false);
776                                        ImageSaveAlpha($gdimg_source, true);
777                                        //$this->is_alpha = true;
778                                        $phpThumbFilters = new phpthumb_filters();
779                                        $phpThumbFilters->phpThumbObject = $this;
780                                        $phpThumbFilters->ApplyMask($gdimg_rotate_mask, $gdimg_source);
781
782                                        ImageDestroy($gdimg_rotate_mask);
783
784                                } else {
785                                        //$this->DebugMessage('ImageCreateFunction() failed', __FILE__, __LINE__);
786                                }
787
788                        } else {
789
790                                if (phpthumb_functions::gd_version() < 2) {
791                                        //$this->DebugMessage('Using non-alpha rotate because gd_version is "'.phpthumb_functions::gd_version().'"', __FILE__, __LINE__);
792                                } elseif ($bg) {
793                                        //$this->DebugMessage('Using non-alpha rotate because $this->bg is "'.$bg.'"', __FILE__, __LINE__);
794                                } elseif ($rotate_angle % 90) {
795                                        //$this->DebugMessage('Using non-alpha rotate because ($rotate_angle % 90) = "'.($rotate_angle % 90).'"', __FILE__, __LINE__);
796                                } else {
797                                        //$this->DebugMessage('Using non-alpha rotate because $this->thumbnailFormat is "'.$this->thumbnailFormat.'"', __FILE__, __LINE__);
798                                }
799
800                                if (ImageColorTransparent($gdimg_source) >= 0) {
801                                        // ImageRotate() forgets all about an image's transparency and sets the transparent color to black
802                                        // To compensate, flood-fill the transparent color of the source image with the specified background color first
803                                        // then rotate and the colors should match
804
805                                        if (!function_exists('ImageIsTrueColor') || !ImageIsTrueColor($gdimg_source)) {
806                                                // convert paletted image to true-color before rotating to prevent nasty aliasing artifacts
807
808                                                //$this->source_width  = ImageSX($gdimg_source);
809                                                //$this->source_height = ImageSY($gdimg_source);
810                                                $gdimg_newsrc = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg_source), ImageSY($gdimg_source));
811                                                $background_color = phpthumb_functions::ImageHexColorAllocate($gdimg_newsrc, $config_background_hexcolor);
812                                                ImageFilledRectangle($gdimg_newsrc, 0, 0, ImageSX($gdimg_source), ImageSY($gdimg_source), phpthumb_functions::ImageHexColorAllocate($gdimg_newsrc, $config_background_hexcolor));
813                                                ImageCopy($gdimg_newsrc, $gdimg_source, 0, 0, 0, 0, ImageSX($gdimg_source), ImageSY($gdimg_source));
814                                                ImageDestroy($gdimg_source);
815                                                unset($gdimg_source);
816                                                $gdimg_source = $gdimg_newsrc;
817                                                unset($gdimg_newsrc);
818
819                                        } else {
820
821                                                ImageColorSet(
822                                                        $gdimg_source,
823                                                        ImageColorTransparent($gdimg_source),
824                                                        hexdec(substr($config_background_hexcolor, 0, 2)),
825                                                        hexdec(substr($config_background_hexcolor, 2, 2)),
826                                                        hexdec(substr($config_background_hexcolor, 4, 2)));
827
828                                                ImageColorTransparent($gdimg_source, -1);
829
830                                        }
831                                }
832
833                                $gdimg_source = ImageRotate($gdimg_source, $rotate_angle, $background_color);
834
835                        }
836                }
837                return true;
838        }
839
840
841        function MeanRemoval(&$gdimg) {
842                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
843                        if (ImageFilter($gdimg, IMG_FILTER_MEAN_REMOVAL)) {
844                                return true;
845                        }
846                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_MEAN_REMOVAL)', __FILE__, __LINE__);
847                        // fall through and try it the hard way
848                }
849                // currently not implemented "the hard way"
850                $this->DebugMessage('FAILED: phpthumb_filters::MeanRemoval($gdimg) [function not implemented]', __FILE__, __LINE__);
851                return false;
852        }
853
854
855        function Negative(&$gdimg) {
856                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
857                        if (ImageFilter($gdimg, IMG_FILTER_NEGATE)) {
858                                return true;
859                        }
860                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_NEGATE)', __FILE__, __LINE__);
861                        // fall through and try it the hard way
862                }
863                $ImageSX = ImageSX($gdimg);
864                $ImageSY = ImageSY($gdimg);
865                for ($x = 0; $x < $ImageSX; $x++) {
866                        for ($y = 0; $y < $ImageSY; $y++) {
867                                $currentPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
868                                $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, (~$currentPixel['red'] & 0xFF), (~$currentPixel['green'] & 0xFF), (~$currentPixel['blue'] & 0xFF), $currentPixel['alpha']);
869                                ImageSetPixel($gdimg, $x, $y, $newColor);
870                        }
871                }
872                return true;
873        }
874
875
876        function RoundedImageCorners(&$gdimg, $radius_x, $radius_y) {
877                // generate mask at twice desired resolution and downsample afterwards for easy antialiasing
878                // mask is generated as a white double-size elipse on a triple-size black background and copy-paste-resampled
879                // onto a correct-size mask image as 4 corners due to errors when the entire mask is resampled at once (gray edges)
880                if ($gdimg_cornermask_triple = phpthumb_functions::ImageCreateFunction($radius_x * 6, $radius_y * 6)) {
881                        if ($gdimg_cornermask = phpthumb_functions::ImageCreateFunction(ImageSX($gdimg), ImageSY($gdimg))) {
882
883                                $color_transparent = ImageColorAllocate($gdimg_cornermask_triple, 255, 255, 255);
884                                ImageFilledEllipse($gdimg_cornermask_triple, $radius_x * 3, $radius_y * 3, $radius_x * 4, $radius_y * 4, $color_transparent);
885
886                                ImageFilledRectangle($gdimg_cornermask, 0, 0, ImageSX($gdimg), ImageSY($gdimg), $color_transparent);
887
888                                ImageCopyResampled($gdimg_cornermask, $gdimg_cornermask_triple,                           0,                           0,     $radius_x,     $radius_y, $radius_x, $radius_y, $radius_x * 2, $radius_y * 2);
889                                ImageCopyResampled($gdimg_cornermask, $gdimg_cornermask_triple,                           0, ImageSY($gdimg) - $radius_y,     $radius_x, $radius_y * 3, $radius_x, $radius_y, $radius_x * 2, $radius_y * 2);
890                                ImageCopyResampled($gdimg_cornermask, $gdimg_cornermask_triple, ImageSX($gdimg) - $radius_x, ImageSY($gdimg) - $radius_y, $radius_x * 3, $radius_y * 3, $radius_x, $radius_y, $radius_x * 2, $radius_y * 2);
891                                ImageCopyResampled($gdimg_cornermask, $gdimg_cornermask_triple, ImageSX($gdimg) - $radius_x,                           0, $radius_x * 3,     $radius_y, $radius_x, $radius_y, $radius_x * 2, $radius_y * 2);
892
893                                phpthumb_filters::ApplyMask($gdimg_cornermask, $gdimg);
894                                ImageDestroy($gdimg_cornermask);
895                                $this->DebugMessage('RoundedImageCorners('.$radius_x.', '.$radius_y.') succeeded', __FILE__, __LINE__);
896                                return true;
897
898                        } else {
899                                $this->DebugMessage('FAILED: $gdimg_cornermask = phpthumb_functions::ImageCreateFunction('.ImageSX($gdimg).', '.ImageSY($gdimg).')', __FILE__, __LINE__);
900                        }
901                        ImageDestroy($gdimg_cornermask_triple);
902
903                } else {
904                        $this->DebugMessage('FAILED: $gdimg_cornermask_triple = phpthumb_functions::ImageCreateFunction('.($radius_x * 6).', '.($radius_y * 6).')', __FILE__, __LINE__);
905                }
906                return false;
907        }
908
909
910        function Saturation(&$gdimg, $amount, $color='') {
911                if ($amount == 0) {
912                        return true;
913                } elseif ($amount > 0) {
914                        $amount = 0 - $amount;
915                } else {
916                        $amount = abs($amount);
917                }
918                return phpthumb_filters::Desaturate($gdimg, $amount, $color);
919        }
920
921
922        function Sepia(&$gdimg, $amount, $targetColor) {
923                $amount      = (is_numeric($amount) ? max(0, min(100, $amount)) : 50);
924                $amountPct   = $amount / 100;
925                $targetColor = (phpthumb_functions::IsHexColor($targetColor) ? $targetColor : 'A28065');
926
927                if ($amount == 0) {
928                        return true;
929                }
930
931                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
932                        if (ImageFilter($gdimg, IMG_FILTER_GRAYSCALE)) {
933
934                                $r = round($amountPct * hexdec(substr($targetColor, 0, 2)));
935                                $g = round($amountPct * hexdec(substr($targetColor, 2, 2)));
936                                $b = round($amountPct * hexdec(substr($targetColor, 4, 2)));
937                                if (ImageFilter($gdimg, IMG_FILTER_COLORIZE, $r, $g, $b)) {
938                                        return true;
939                                }
940                                $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_COLORIZE)', __FILE__, __LINE__);
941                                // fall through and try it the hard way
942
943                        } else {
944
945                                $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_GRAYSCALE)', __FILE__, __LINE__);
946                                // fall through and try it the hard way
947
948                        }
949                }
950
951                $TargetPixel['red']   = hexdec(substr($targetColor, 0, 2));
952                $TargetPixel['green'] = hexdec(substr($targetColor, 2, 2));
953                $TargetPixel['blue']  = hexdec(substr($targetColor, 4, 2));
954
955                $ImageSX = ImageSX($gdimg);
956                $ImageSY = ImageSY($gdimg);
957                for ($x = 0; $x < $ImageSX; $x++) {
958                        for ($y = 0; $y < $ImageSY; $y++) {
959                                $OriginalPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
960                                $GrayPixel = phpthumb_functions::GrayscalePixel($OriginalPixel);
961
962                                // http://www.gimpguru.org/Tutorials/SepiaToning/
963                                // "In the traditional sepia toning process, the tinting occurs most in
964                                // the mid-tones: the lighter and darker areas appear to be closer to B&W."
965                                $SepiaAmount = ((128 - abs($GrayPixel['red'] - 128)) / 128) * $amountPct;
966
967                                foreach ($TargetPixel as $key => $value) {
968                                        $NewPixel[$key] = round(max(0, min(255, $GrayPixel[$key] * (1 - $SepiaAmount) + ($TargetPixel[$key] * $SepiaAmount))));
969                                }
970                                $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, $NewPixel['red'], $NewPixel['green'], $NewPixel['blue'], $OriginalPixel['alpha']);
971                                ImageSetPixel($gdimg, $x, $y, $newColor);
972                        }
973                }
974                return true;
975        }
976
977
978        function Smooth(&$gdimg, $amount=6) {
979                $amount = min(25, max(0, $amount));
980                if ($amount == 0) {
981                        return true;
982                }
983                if (phpthumb_functions::version_compare_replacement(phpversion(), '5.0.0', '>=') && phpthumb_functions::gd_is_bundled()) {
984                        if (ImageFilter($gdimg, IMG_FILTER_SMOOTH, $amount)) {
985                                return true;
986                        }
987                        $this->DebugMessage('FAILED: ImageFilter($gdimg, IMG_FILTER_SMOOTH, '.$amount.')', __FILE__, __LINE__);
988                        // fall through and try it the hard way
989                }
990                // currently not implemented "the hard way"
991                $this->DebugMessage('FAILED: phpthumb_filters::Smooth($gdimg, '.$amount.') [function not implemented]', __FILE__, __LINE__);
992                return false;
993        }
994
995
996        function SourceTransparentColorMask(&$gdimg, $hexcolor, $min_limit=5, $max_limit=10) {
997                $width  = ImageSX($gdimg);
998                $height = ImageSY($gdimg);
999                if ($gdimg_mask = ImageCreateTrueColor($width, $height)) {
1000                        $R = hexdec(substr($hexcolor, 0, 2));
1001                        $G = hexdec(substr($hexcolor, 2, 2));
1002                        $B = hexdec(substr($hexcolor, 4, 2));
1003                        $targetPixel = array('red'=>$R, 'green'=>$G, 'blue'=>$B);
1004                        $cutoffRange = $max_limit - $min_limit;
1005                        for ($x = 0; $x < $width; $x++) {
1006                                for ($y = 0; $y < $height; $y++) {
1007                                        $currentPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
1008                                        $colorDiff = phpthumb_functions::PixelColorDifferencePercent($currentPixel, $targetPixel);
1009                                        $grayLevel = min($cutoffRange, MAX(0, -$min_limit + $colorDiff)) * (255 / MAX(1, $cutoffRange));
1010                                        $newColor = ImageColorAllocate($gdimg_mask, $grayLevel, $grayLevel, $grayLevel);
1011                                        ImageSetPixel($gdimg_mask, $x, $y, $newColor);
1012                                }
1013                        }
1014                        return $gdimg_mask;
1015                }
1016                return false;
1017        }
1018
1019
1020        function Threshold(&$gdimg, $cutoff) {
1021                $width  = ImageSX($gdimg);
1022                $height = ImageSY($gdimg);
1023                $cutoff = min(255, max(0, ($cutoff ? $cutoff : 128)));
1024                for ($x = 0; $x < $width; $x++) {
1025                        for ($y = 0; $y < $height; $y++) {
1026                                $currentPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
1027                                $grayPixel = phpthumb_functions::GrayscalePixel($currentPixel);
1028                                if ($grayPixel['red'] < $cutoff) {
1029                                        $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, 0x00, 0x00, 0x00, $currentPixel['alpha']);
1030                                } else {
1031                                        $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg, 0xFF, 0xFF, 0xFF, $currentPixel['alpha']);
1032                                }
1033                                ImageSetPixel($gdimg, $x, $y, $newColor);
1034                        }
1035                }
1036                return true;
1037        }
1038
1039
1040        function ImageTrueColorToPalette2(&$image, $dither, $ncolors) {
1041                // http://www.php.net/manual/en/function.imagetruecolortopalette.php
1042                // zmorris at zsculpt dot com (17-Aug-2004 06:58)
1043                $width  = ImageSX($image);
1044                $height = ImageSY($image);
1045                $image_copy = ImageCreateTrueColor($width, $height);
1046                //ImageCopyMerge($image_copy, $image, 0, 0, 0, 0, $width, $height, 100);
1047                ImageCopy($image_copy, $image, 0, 0, 0, 0, $width, $height);
1048                ImageTrueColorToPalette($image, $dither, $ncolors);
1049                ImageColorMatch($image_copy, $image);
1050                ImageDestroy($image_copy);
1051                return true;
1052        }
1053
1054        function ReduceColorDepth(&$gdimg, $colors=256, $dither=true) {
1055                $colors = max(min($colors, 256), 2);
1056                // ImageTrueColorToPalette usually makes ugly colors, the replacement is a bit better
1057                //ImageTrueColorToPalette($gdimg, $dither, $colors);
1058                phpthumb_filters::ImageTrueColorToPalette2($gdimg, $dither, $colors);
1059                return true;
1060        }
1061
1062
1063        function WhiteBalance(&$gdimg, $targetColor='') {
1064                if (phpthumb_functions::IsHexColor($targetColor)) {
1065                        $targetPixel = array(
1066                                'red'   => hexdec(substr($targetColor, 0, 2)),
1067                                'green' => hexdec(substr($targetColor, 2, 2)),
1068                                'blue'  => hexdec(substr($targetColor, 4, 2))
1069                        );
1070                } else {
1071                        $Analysis = phpthumb_filters::HistogramAnalysis($gdimg, false);
1072                        $targetPixel = array(
1073                                'red'   => max(array_keys($Analysis['red'])),
1074                                'green' => max(array_keys($Analysis['green'])),
1075                                'blue'  => max(array_keys($Analysis['blue']))
1076                        );
1077                }
1078                $grayValue = phpthumb_functions::GrayscaleValue($targetPixel['red'], $targetPixel['green'], $targetPixel['blue']);
1079                $scaleR = $grayValue / $targetPixel['red'];
1080                $scaleG = $grayValue / $targetPixel['green'];
1081                $scaleB = $grayValue / $targetPixel['blue'];
1082
1083                for ($x = 0; $x < ImageSX($gdimg); $x++) {
1084                        for ($y = 0; $y < ImageSY($gdimg); $y++) {
1085                                $currentPixel = phpthumb_functions::GetPixelColor($gdimg, $x, $y);
1086                                $newColor = phpthumb_functions::ImageColorAllocateAlphaSafe(
1087                                        $gdimg,
1088                                        max(0, min(255, round($currentPixel['red']   * $scaleR))),
1089                                        max(0, min(255, round($currentPixel['green'] * $scaleG))),
1090                                        max(0, min(255, round($currentPixel['blue']  * $scaleB))),
1091                                        $currentPixel['alpha']
1092                                );
1093                                ImageSetPixel($gdimg, $x, $y, $newColor);
1094                        }
1095                }
1096                return true;
1097        }
1098
1099
1100        function WatermarkText(&$gdimg, $text, $size, $alignment, $hex_color='000000', $ttffont='', $opacity=100, $margin=5, $angle=0, $bg_color=false, $bg_opacity=0, $fillextend='') {
1101                // text watermark requested
1102                if (!$text) {
1103                        return false;
1104                }
1105                ImageAlphaBlending($gdimg, true);
1106
1107                if (preg_match('#^([0-9\\.\\-]*)x([0-9\\.\\-]*)(@[LCR])?$#i', $alignment, $matches)) {
1108                        $originOffsetX = intval($matches[1]);
1109                        $originOffsetY = intval($matches[2]);
1110                        $alignment = (@$matches[4] ? $matches[4] : 'L');
1111                        $margin = 0;
1112                } else {
1113                        $originOffsetX = 0;
1114                        $originOffsetY = 0;
1115                }
1116
1117                $metaTextArray = array(
1118                        '^Fb' =>       $this->phpThumbObject->getimagesizeinfo['filesize'],
1119                        '^Fk' => round($this->phpThumbObject->getimagesizeinfo['filesize'] / 1024),
1120                        '^Fm' => round($this->phpThumbObject->getimagesizeinfo['filesize'] / 1048576),
1121                        '^X'  => $this->phpThumbObject->getimagesizeinfo[0],
1122                        '^Y'  => $this->phpThumbObject->getimagesizeinfo[1],
1123                        '^x'  => ImageSX($gdimg),
1124                        '^y'  => ImageSY($gdimg),
1125                        '^^'  => '^',
1126                );
1127                $text = strtr($text, $metaTextArray);
1128
1129                $text = str_replace("\r\n", "\n", $text);
1130                $text = str_replace("\r",   "\n", $text);
1131                $textlines = explode("\n", $text);
1132                $this->DebugMessage('Processing '.count($textlines).' lines of text', __FILE__, __LINE__);
1133
1134                if (@is_readable($ttffont) && is_file($ttffont)) {
1135
1136                        $opacity = 100 - intval(max(min($opacity, 100), 0));
1137                        $letter_color_text = phpthumb_functions::ImageHexColorAllocate($gdimg, $hex_color, false, $opacity * 1.27);
1138
1139                        $this->DebugMessage('Using TTF font "'.$ttffont.'"', __FILE__, __LINE__);
1140
1141                        $TTFbox = ImageTTFbBox($size, $angle, $ttffont, $text);
1142
1143                        $min_x = min($TTFbox[0], $TTFbox[2], $TTFbox[4], $TTFbox[6]);
1144                        $max_x = max($TTFbox[0], $TTFbox[2], $TTFbox[4], $TTFbox[6]);
1145                        //$text_width = round($max_x - $min_x + ($size * 0.5));
1146                        $text_width = round($max_x - $min_x);
1147
1148                        $min_y = min($TTFbox[1], $TTFbox[3], $TTFbox[5], $TTFbox[7]);
1149                        $max_y = max($TTFbox[1], $TTFbox[3], $TTFbox[5], $TTFbox[7]);
1150                        //$text_height = round($max_y - $min_y + ($size * 0.5));
1151                        $text_height = round($max_y - $min_y);
1152
1153                        $TTFboxChar = ImageTTFbBox($size, $angle, $ttffont, 'jH');
1154                        $char_min_y = min($TTFboxChar[1], $TTFboxChar[3], $TTFboxChar[5], $TTFboxChar[7]);
1155                        $char_max_y = max($TTFboxChar[1], $TTFboxChar[3], $TTFboxChar[5], $TTFboxChar[7]);
1156                        $char_height = round($char_max_y - $char_min_y);
1157
1158                        if ($alignment == '*') {
1159
1160                                $text_origin_y = $char_height + $margin;
1161                                while (($text_origin_y - $text_height) < ImageSY($gdimg)) {
1162                                        $text_origin_x = $margin;
1163                                        while ($text_origin_x < ImageSX($gdimg)) {
1164                                                ImageTTFtext($gdimg, $size, $angle, $text_origin_x, $text_origin_y, $letter_color_text, $ttffont, $text);
1165                                                $text_origin_x += ($text_width + $margin);
1166                                        }
1167                                        $text_origin_y += ($text_height + $margin);
1168                                }
1169
1170                        } else {
1171
1172                                // this block for background color only
1173
1174                                switch ($alignment) {
1175                                        case '*':
1176                                                // handled separately
1177                                                break;
1178
1179                                        case 'T':
1180                                                $text_origin_x = ($originOffsetX ? $originOffsetX - round($text_width / 2) : round((ImageSX($gdimg) - $text_width) / 2));
1181                                                $text_origin_y = $char_height + $margin + $originOffsetY;
1182                                                break;
1183
1184                                        case 'B':
1185                                                $text_origin_x = ($originOffsetX ? $originOffsetX - round($text_width / 2) : round((ImageSX($gdimg) - $text_width) / 2));
1186                                                $text_origin_y = ImageSY($gdimg) + $TTFbox[1] - $margin + $originOffsetY;
1187                                                break;
1188
1189                                        case 'L':
1190                                                $text_origin_x = $margin + $originOffsetX;
1191                                                $text_origin_y = ($originOffsetY ? $originOffsetY : round((ImageSY($gdimg) - $text_height) / 2) + $char_height);
1192                                                break;
1193
1194                                        case 'R':
1195                                                $text_origin_x = ($originOffsetX ? $originOffsetX - $text_width : ImageSX($gdimg) - $text_width  + $TTFbox[0] - $min_x + round($size * 0.25) - $margin);
1196                                                $text_origin_y = ($originOffsetY ? $originOffsetY : round((ImageSY($gdimg) - $text_height) / 2) + $char_height);
1197                                                break;
1198
1199                                        case 'C':
1200                                                $text_origin_x = ($originOffsetX ? $originOffsetX - round($text_width / 2) : round((ImageSX($gdimg) - $text_width) / 2));
1201                                                $text_origin_y = ($originOffsetY ? $originOffsetY : round((ImageSY($gdimg) - $text_height) / 2) + $char_height);
1202                                                break;
1203
1204                                        case 'TL':
1205                                                $text_origin_x = $margin + $originOffsetX;
1206                                                $text_origin_y = $char_height + $margin + $originOffsetY;
1207                                                break;
1208
1209                                        case 'TR':
1210                                                $text_origin_x = ($originOffsetX ? $originOffsetX - $text_width : ImageSX($gdimg) - $text_width  + $TTFbox[0] - $min_x + round($size * 0.25) - $margin);
1211                                                $text_origin_y = $char_height + $margin + $originOffsetY;
1212                                                break;
1213
1214                                        case 'BL':
1215                                                $text_origin_x = $margin + $originOffsetX;
1216                                                $text_origin_y = ImageSY($gdimg) + $TTFbox[1] - $margin + $originOffsetY;
1217                                                break;
1218
1219                                        case 'BR':
1220                                        default:
1221                                                $text_origin_x = ($originOffsetX ? $originOffsetX - $text_width : ImageSX($gdimg) - $text_width  + $TTFbox[0] - $min_x + round($size * 0.25) - $margin);
1222                                                $text_origin_y = ImageSY($gdimg) + $TTFbox[1] - $margin + $originOffsetY;
1223                                                break;
1224                                }
1225
1226                                //ImageRectangle($gdimg, $text_origin_x + $min_x, $text_origin_y + $TTFbox[1], $text_origin_x + $min_x + $text_width, $text_origin_y + $TTFbox[1] - $text_height, $letter_color_text);
1227                                if (phpthumb_functions::IsHexColor($bg_color)) {
1228                                        $text_background_alpha = round(127 * ((100 - min(max(0, $bg_opacity), 100)) / 100));
1229                                        $text_color_background = phpthumb_functions::ImageHexColorAllocate($gdimg, $bg_color, false, $text_background_alpha);
1230                                } else {
1231                                        $text_color_background = phpthumb_functions::ImageHexColorAllocate($gdimg, 'FFFFFF', false, 127);
1232                                }
1233                                $x1 = $text_origin_x + $min_x;
1234                                $y1 = $text_origin_y + $TTFbox[1];
1235                                $x2 = $text_origin_x + $min_x + $text_width;
1236                                $y2 = $text_origin_y + $TTFbox[1] - $text_height;
1237                                $x_TL = preg_match('#x#i', $fillextend) ?               0 : min($x1, $x2);
1238                                $y_TL = preg_match('#y#i', $fillextend) ?               0 : min($y1, $y2);
1239                                $x_BR = preg_match('#x#i', $fillextend) ? ImageSX($gdimg) : max($x1, $x2);
1240                                $y_BR = preg_match('#y#i', $fillextend) ? ImageSY($gdimg) : max($y1, $y2);
1241                                //while ($y_BR > ImageSY($gdimg)) {
1242                                //      $y_TL--;
1243                                //      $y_BR--;
1244                                //      $text_origin_y--;
1245                                //}
1246                                $this->DebugMessage('WatermarkText() calling ImageFilledRectangle($gdimg, '.$x_TL.', '.$y_TL.', '.$x_BR.', '.$y_BR.', $text_color_background)', __FILE__, __LINE__);
1247                                ImageFilledRectangle($gdimg, $x_TL, $y_TL, $x_BR, $y_BR, $text_color_background);
1248
1249                                // end block for background color only
1250
1251
1252                                $y_offset = 0;
1253                                foreach ($textlines as $dummy => $line) {
1254
1255                                        $TTFboxLine = ImageTTFbBox($size, $angle, $ttffont, $line);
1256                                        $min_x_line = min($TTFboxLine[0], $TTFboxLine[2], $TTFboxLine[4], $TTFboxLine[6]);
1257                                        $max_x_line = max($TTFboxLine[0], $TTFboxLine[2], $TTFboxLine[4], $TTFboxLine[6]);
1258                                        //$text_width = round($max_x - $min_x + ($size * 0.5));
1259                                        $text_width_line = round($max_x_line - $min_x_line);
1260
1261                                        $min_y_line = min($TTFboxLine[1], $TTFboxLine[3], $TTFboxLine[5], $TTFboxLine[7]);
1262                                        $max_y_line = max($TTFboxLine[1], $TTFboxLine[3], $TTFboxLine[5], $TTFboxLine[7]);
1263                                        //$text_height = round($max_y - $min_y + ($size * 0.5));
1264                                        $text_height_line = round($max_y_line - $min_y_line);
1265
1266                                        switch ($alignment) {
1267                                                // $text_origin_y set above, just re-set $text_origin_x here as needed
1268
1269                                                case 'L':
1270                                                case 'TL':
1271                                                case 'BL':
1272                                                        // no change neccesary
1273                                                        break;
1274
1275                                                case 'C':
1276                                                case 'T':
1277                                                case 'B':
1278                                                        $text_origin_x = ($originOffsetX ? $originOffsetX - round($text_width_line / 2) : round((ImageSX($gdimg) - $text_width_line) / 2));
1279                                                        break;
1280
1281                                                case 'R':
1282                                                case 'TR':
1283                                                case 'BR':
1284                                                        $text_origin_x = ($originOffsetX ? $originOffsetX - $text_width_line : ImageSX($gdimg) - $text_width_line  + $TTFbox[0] - $min_x + round($size * 0.25) - $margin);
1285                                                        break;
1286                                        }
1287
1288                                        //ImageTTFtext($gdimg, $size, $angle, $text_origin_x, $text_origin_y, $letter_color_text, $ttffont, $text);
1289                                        $this->DebugMessage('WatermarkText() calling ImageTTFtext($gdimg, '.$size.', '.$angle.', '.$text_origin_x.', '.($text_origin_y + $y_offset).', $letter_color_text, '.$ttffont.', '.$line.')', __FILE__, __LINE__);
1290                                        ImageTTFtext($gdimg, $size, $angle, $text_origin_x, $text_origin_y + $y_offset, $letter_color_text, $ttffont, $line);
1291
1292                                        $y_offset += $char_height;
1293                                }
1294
1295                        }
1296                        return true;
1297
1298                } else {
1299
1300                        $size = min(5, max(1, $size));
1301                        $this->DebugMessage('Using built-in font (size='.$size.') for text watermark'.($ttffont ? ' because $ttffont !is_readable('.$ttffont.')' : ''), __FILE__, __LINE__);
1302
1303                        $text_width  = 0;
1304                        $text_height = 0;
1305                        foreach ($textlines as $dummy => $line) {
1306                                $text_width   = max($text_width, ImageFontWidth($size) * strlen($line));
1307                                $text_height += ImageFontHeight($size);
1308                        }
1309                        if ($img_watermark = phpthumb_functions::ImageCreateFunction($text_width, $text_height)) {
1310                                ImageAlphaBlending($img_watermark, false);
1311                                if (phpthumb_functions::IsHexColor($bg_color)) {
1312                                        $text_background_alpha = round(127 * ((100 - min(max(0, $bg_opacity), 100)) / 100));
1313                                        $text_color_background = phpthumb_functions::ImageHexColorAllocate($img_watermark, $bg_color, false, $text_background_alpha);
1314                                } else {
1315                                        $text_color_background = phpthumb_functions::ImageHexColorAllocate($img_watermark, 'FFFFFF', false, 127);
1316                                }
1317                                $this->DebugMessage('WatermarkText() calling ImageFilledRectangle($img_watermark, 0, 0, '.ImageSX($img_watermark).', '.ImageSY($img_watermark).', $text_color_background)', __FILE__, __LINE__);
1318                                ImageFilledRectangle($img_watermark, 0, 0, ImageSX($img_watermark), ImageSY($img_watermark), $text_color_background);
1319
1320                                if ($angle && function_exists('ImageRotate')) {
1321                                        // using $img_watermark_mask is pointless if ImageRotate function isn't available
1322                                        if ($img_watermark_mask = phpthumb_functions::ImageCreateFunction($text_width, $text_height)) {
1323                                                $mask_color_background = ImageColorAllocate($img_watermark_mask, 0, 0, 0);
1324                                                ImageAlphaBlending($img_watermark_mask, false);
1325                                                ImageFilledRectangle($img_watermark_mask, 0, 0, ImageSX($img_watermark_mask), ImageSY($img_watermark_mask), $mask_color_background);
1326                                                $mask_color_watermark = ImageColorAllocate($img_watermark_mask, 255, 255, 255);
1327                                        }
1328                                }
1329
1330                                $text_color_watermark = phpthumb_functions::ImageHexColorAllocate($img_watermark, $hex_color);
1331                                foreach ($textlines as $key => $line) {
1332                                        switch ($alignment) {
1333                                                case 'C':
1334                                                        $x_offset = round(($text_width - (ImageFontWidth($size) * strlen($line))) / 2);
1335                                                        $originOffsetX = (ImageSX($gdimg) - ImageSX($img_watermark)) / 2;
1336                                                        $originOffsetY = (ImageSY($gdimg) - ImageSY($img_watermark)) / 2;
1337                                                        break;
1338
1339                                                case 'T':
1340                                                        $x_offset = round(($text_width - (ImageFontWidth($size) * strlen($line))) / 2);
1341                                                        $originOffsetX = (ImageSX($gdimg) - ImageSX($img_watermark)) / 2;
1342                                                        $originOffsetY = $margin;
1343                                                        break;
1344
1345                                                case 'B':
1346                                                        $x_offset = round(($text_width - (ImageFontWidth($size) * strlen($line))) / 2);
1347                                                        $originOffsetX = (ImageSX($gdimg) - ImageSX($img_watermark)) / 2;
1348                                                        $originOffsetY = ImageSY($gdimg) - ImageSY($img_watermark) - $margin;
1349                                                        break;
1350
1351                                                case 'L':
1352                                                        $x_offset = 0;
1353                                                        $originOffsetX = $margin;
1354                                                        $originOffsetY = (ImageSY($gdimg) - ImageSY($img_watermark)) / 2;
1355                                                        break;
1356
1357                                                case 'TL':
1358                                                        $x_offset = 0;
1359                                                        $originOffsetX = $margin;
1360                                                        $originOffsetY = $margin;
1361                                                        break;
1362
1363                                                case 'BL':
1364                                                        $x_offset = 0;
1365                                                        $originOffsetX = $margin;
1366                                                        $originOffsetY = ImageSY($gdimg) - ImageSY($img_watermark) - $margin;
1367                                                        break;
1368
1369                                                case 'R':
1370                                                        $x_offset = $text_width - (ImageFontWidth($size) * strlen($line));
1371                                                        $originOffsetX = ImageSX($gdimg) - ImageSX($img_watermark) - $margin;
1372                                                        $originOffsetY = (ImageSY($gdimg) - ImageSY($img_watermark)) / 2;
1373                                                        break;
1374
1375                                                case 'TR':
1376                                                        $x_offset = $text_width - (ImageFontWidth($size) * strlen($line));
1377                                                        $originOffsetX = ImageSX($gdimg) - ImageSX($img_watermark) - $margin;
1378                                                        $originOffsetY = $margin;
1379                                                        break;
1380
1381                                                case 'BR':
1382                                                default:
1383                                                        $x_offset = $text_width - (ImageFontWidth($size) * strlen($line));
1384                                                        $originOffsetX = ImageSX($gdimg) - ImageSX($img_watermark) - $margin;
1385                                                        $originOffsetY = ImageSY($gdimg) - ImageSY($img_watermark) - $margin;
1386                                                        break;
1387                                        }
1388                                        $this->DebugMessage('WatermarkText() calling ImageString($img_watermark, '.$size.', '.$x_offset.', '.($key * ImageFontHeight($size)).', '.$line.', $text_color_watermark)', __FILE__, __LINE__);
1389                                        ImageString($img_watermark, $size, $x_offset, $key * ImageFontHeight($size), $line, $text_color_watermark);
1390                                        if ($angle && $img_watermark_mask) {
1391                                                $this->DebugMessage('WatermarkText() calling ImageString($img_watermark_mask, '.$size.', '.$x_offset.', '.($key * ImageFontHeight($size)).', '.$text.', $mask_color_watermark)', __FILE__, __LINE__);
1392                                                ImageString($img_watermark_mask, $size, $x_offset, $key * ImageFontHeight($size), $text, $mask_color_watermark);
1393                                        }
1394                                }
1395                                if ($angle && $img_watermark_mask) {
1396                                        $img_watermark      = ImageRotate($img_watermark,      $angle, $text_color_background);
1397                                        $img_watermark_mask = ImageRotate($img_watermark_mask, $angle, $mask_color_background);
1398                                        phpthumb_filters::ApplyMask($img_watermark_mask, $img_watermark);
1399                                }
1400                                //phpthumb_filters::WatermarkOverlay($gdimg, $img_watermark, $alignment, $opacity, $margin);
1401                                $this->DebugMessage('WatermarkText() calling phpthumb_filters::WatermarkOverlay($gdimg, $img_watermark, '.($originOffsetX.'x'.$originOffsetY).', '.$opacity.', 0)', __FILE__, __LINE__);
1402                                phpthumb_filters::WatermarkOverlay($gdimg, $img_watermark, $originOffsetX.'x'.$originOffsetY, $opacity, 0);
1403                                ImageDestroy($img_watermark);
1404                                return true;
1405                        }
1406
1407                }
1408                return false;
1409        }
1410
1411
1412        function WatermarkOverlay(&$gdimg_dest, &$img_watermark, $alignment='*', $opacity=50, $margin_x=5, $margin_y=null) {
1413
1414                if (is_resource($gdimg_dest) && is_resource($img_watermark)) {
1415                        $watermark_source_x        = 0;
1416                        $watermark_source_y        = 0;
1417                        $img_source_width          = ImageSX($gdimg_dest);
1418                        $img_source_height         = ImageSY($gdimg_dest);
1419                        $watermark_source_width    = ImageSX($img_watermark);
1420                        $watermark_source_height   = ImageSY($img_watermark);
1421                        $watermark_opacity_percent = max(0, min(100, $opacity));
1422                        $margin_y = (is_null($margin_y) ? $margin_x : $margin_y);
1423                        $watermark_margin_x = ((($margin_x > 0) && ($margin_x < 1)) ? round((1 - $margin_x) * $img_source_width)  : $margin_x);
1424                        $watermark_margin_y = ((($margin_y > 0) && ($margin_y < 1)) ? round((1 - $margin_y) * $img_source_height) : $margin_y);
1425                        if (preg_match('#^([0-9\\.\\-]*)x([0-9\\.\\-]*)$#i', $alignment, $matches)) {
1426                                $watermark_destination_x = intval($matches[1]);
1427                                $watermark_destination_y = intval($matches[2]);
1428                        } else {
1429                                switch ($alignment) {
1430                                        case '*':
1431                                                if ($gdimg_tiledwatermark = phpthumb_functions::ImageCreateFunction($img_source_width, $img_source_height)) {
1432
1433                                                        ImageAlphaBlending($gdimg_tiledwatermark, false);
1434                                                        ImageSaveAlpha($gdimg_tiledwatermark, true);
1435                                                        $text_color_transparent = phpthumb_functions::ImageColorAllocateAlphaSafe($gdimg_tiledwatermark, 255, 0, 255, 127);
1436                                                        ImageFill($gdimg_tiledwatermark, 0, 0, $text_color_transparent);
1437
1438                                                        // set the tiled image transparent color to whatever the untiled image transparency index is
1439        //                                              ImageColorTransparent($gdimg_tiledwatermark, ImageColorTransparent($img_watermark));
1440
1441                                                        // a "cleaner" way of doing it, but can't handle the margin feature :(
1442        //                                              ImageSetTile($gdimg_tiledwatermark, $img_watermark);
1443        //                                              ImageFill($gdimg_tiledwatermark, 0, 0, IMG_COLOR_TILED);
1444        //                                              break;
1445
1446        //                                              ImageFill($gdimg_tiledwatermark, 0, 0, ImageColorTransparent($gdimg_tiledwatermark));
1447                                                        // tile the image as many times as can fit
1448                                                        for ($x = $watermark_margin_x; $x < ($img_source_width + $watermark_source_width); $x += ($watermark_source_width + $watermark_margin_x)) {
1449                                                                for ($y = $watermark_margin_y; $y < ($img_source_height + $watermark_source_height); $y += ($watermark_source_height + $watermark_margin_y)) {
1450                                                                        ImageCopy(
1451                                                                                $gdimg_tiledwatermark,
1452                                                                                $img_watermark,
1453                                                                                $x,
1454                                                                                $y,
1455                                                                                0,
1456                                                                                0,
1457                                                                                min($watermark_source_width,  $img_source_width  - $x - $watermark_margin_x),
1458                                                                                min($watermark_source_height, $img_source_height - $y - $watermark_margin_y)
1459                                                                        );
1460                                                                }
1461                                                        }
1462
1463                                                        $watermark_source_width  = ImageSX($gdimg_tiledwatermark);
1464                                                        $watermark_source_height = ImageSY($gdimg_tiledwatermark);
1465                                                        $watermark_destination_x = 0;
1466                                                        $watermark_destination_y = 0;
1467
1468                                                        ImageDestroy($img_watermark);
1469                                                        $img_watermark = $gdimg_tiledwatermark;
1470                                                }
1471                                                break;
1472
1473                                        case 'T':
1474                                                $watermark_destination_x = round((($img_source_width  / 2) - ($watermark_source_width / 2)) + $watermark_margin_x);
1475                                                $watermark_destination_y = $watermark_margin_y;
1476                                                break;
1477
1478                                        case 'B':
1479                                                $watermark_destination_x = round((($img_source_width  / 2) - ($watermark_source_width / 2)) + $watermark_margin_x);
1480                                                $watermark_destination_y = $img_source_height - $watermark_source_height - $watermark_margin_y;
1481                                                break;
1482
1483                                        case 'L':
1484                                                $watermark_destination_x = $watermark_margin_x;
1485                                                $watermark_destination_y = round((($img_source_height / 2) - ($watermark_source_height / 2)) + $watermark_margin_y);
1486                                                break;
1487
1488                                        case 'R':
1489                                                $watermark_destination_x = $img_source_width - $watermark_source_width - $watermark_margin_x;
1490                                                $watermark_destination_y = round((($img_source_height / 2) - ($watermark_source_height / 2)) + $watermark_margin_y);
1491                                                break;
1492
1493                                        case 'C':
1494                                                $watermark_destination_x = round(($img_source_width  / 2) - ($watermark_source_width  / 2));
1495                                                $watermark_destination_y = round(($img_source_height / 2) - ($watermark_source_height / 2));
1496                                                break;
1497
1498                                        case 'TL':
1499                                                $watermark_destination_x = $watermark_margin_x;
1500                                                $watermark_destination_y = $watermark_margin_y;
1501                                                break;
1502
1503                                        case 'TR':
1504                                                $watermark_destination_x = $img_source_width - $watermark_source_width - $watermark_margin_x;
1505                                                $watermark_destination_y = $watermark_margin_y;
1506                                                break;
1507
1508                                        case 'BL':
1509        //echo '<pre>';
1510        ////var_dump($watermark_destination_x);
1511        ////var_dump($watermark_destination_y);
1512        //var_dump($watermark_margin_x);
1513        //var_dump($img_source_height);
1514        //var_dump($watermark_source_height);
1515        //var_dump($watermark_margin_y);
1516                                                $watermark_destination_x = $watermark_margin_x;
1517                                                $watermark_destination_y = $img_source_height - $watermark_source_height - $watermark_margin_y;
1518                                                break;
1519
1520                                        case 'BR':
1521                                        default:
1522                                                $watermark_destination_x = $img_source_width  - $watermark_source_width  - $watermark_margin_x;
1523                                                $watermark_destination_y = $img_source_height - $watermark_source_height - $watermark_margin_y;
1524                                                break;
1525                                }
1526                        }
1527                        ImageAlphaBlending($gdimg_dest, false);
1528                        ImageSaveAlpha($gdimg_dest, true);
1529                        ImageSaveAlpha($img_watermark, true);
1530                        phpthumb_functions::ImageCopyRespectAlpha($gdimg_dest, $img_watermark, $watermark_destination_x, $watermark_destination_y, 0, 0, $watermark_source_width, $watermark_source_height, $watermark_opacity_percent);
1531
1532                        return true;
1533                }
1534                return false;
1535        }
1536
1537
1538        function DebugMessage($message, $file='', $line='') {
1539                if (is_object($this->phpThumbObject)) {
1540                        return $this->phpThumbObject->DebugMessage($message, $file, $line);
1541                }
1542                return false;
1543        }
1544}
1545
1546?>
Note: See TracBrowser for help on using the repository browser.