|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
/** |
|
4
|
|
|
* This file deals with low-level graphics operations performed on images, |
|
5
|
|
|
* specially as needed for avatars (uploaded avatars), attachments, or |
|
6
|
|
|
* visual verification images. |
|
7
|
|
|
* |
|
8
|
|
|
* @name ElkArte Forum |
|
9
|
|
|
* @copyright ElkArte Forum contributors |
|
10
|
|
|
* @license BSD http://opensource.org/licenses/BSD-3-Clause |
|
11
|
|
|
* |
|
12
|
|
|
* This file contains code covered by: |
|
13
|
|
|
* copyright: 2011 Simple Machines (http://www.simplemachines.org) |
|
14
|
|
|
* license: BSD, See included LICENSE.TXT for terms and conditions. |
|
15
|
|
|
* |
|
16
|
|
|
* @version 1.1.9 |
|
17
|
|
|
* |
|
18
|
|
|
*/ |
|
19
|
|
|
|
|
20
|
|
|
/** |
|
21
|
|
|
* Create a thumbnail of the given source. |
|
22
|
|
|
* |
|
23
|
|
|
* @uses resizeImageFile() function to achieve the resize. |
|
24
|
|
|
* @package Graphics |
|
25
|
|
|
* |
|
26
|
|
|
* @param string $source The name of the source image |
|
27
|
|
|
* @param int $max_width The maximum allowed width |
|
28
|
|
|
* @param int $max_height The maximum allowed height |
|
29
|
|
|
* |
|
30
|
|
|
* @return boolean whether the thumbnail creation was successful. |
|
31
|
|
|
*/ |
|
32
|
|
|
function createThumbnail($source, $max_width, $max_height) |
|
33
|
|
|
{ |
|
34
|
|
|
$destName = $source . '_thumb.tmp'; |
|
35
|
|
|
$max_width = max(16, $max_width); |
|
36
|
|
|
$max_height = max(16, $max_height); |
|
37
|
|
|
|
|
38
|
|
|
// Do the actual resize, thumbnails by default strip EXIF data to save space |
|
39
|
|
|
$format = setDefaultFormat($source); |
|
40
|
|
|
$success = resizeImageFile($source, $destName, $max_width, $max_height, $format, true); |
|
41
|
|
|
|
|
42
|
|
|
// Okay, we're done with the temporary stuff. |
|
43
|
|
|
$destName = substr($destName, 0, -4); |
|
44
|
|
|
|
|
45
|
|
|
if ($success && @rename($destName . '.tmp', $destName)) |
|
46
|
|
|
return true; |
|
47
|
|
|
else |
|
48
|
|
|
{ |
|
49
|
|
|
@unlink($destName . '.tmp'); |
|
|
|
|
|
|
50
|
|
|
@touch($destName); |
|
|
|
|
|
|
51
|
|
|
return false; |
|
52
|
|
|
} |
|
53
|
|
|
} |
|
54
|
|
|
|
|
55
|
|
|
/** |
|
56
|
|
|
* Used to re-encodes an image to a specified image format |
|
57
|
|
|
* |
|
58
|
|
|
* What it does: |
|
59
|
|
|
* |
|
60
|
|
|
* - creates a copy of the file at the same location as fileName. |
|
61
|
|
|
* - the file would have the format preferred_format if possible, otherwise the default format is jpeg. |
|
62
|
|
|
* - the function makes sure that all non-essential image contents are disposed. |
|
63
|
|
|
* |
|
64
|
|
|
* @package Graphics |
|
65
|
|
|
* @param string $fileName The path to the file |
|
66
|
|
|
* @param int $preferred_format The preferred format |
|
67
|
|
|
* - 0 to automatically determine |
|
68
|
|
|
* - 1 for gif |
|
69
|
|
|
* - 2 for jpg |
|
70
|
|
|
* - 3 for png |
|
71
|
|
|
* - 6 for bmp |
|
72
|
|
|
* - 15 for wbmp |
|
73
|
|
|
* - 18 for webp |
|
74
|
|
|
* |
|
75
|
|
|
* @return boolean true on success, false on failure. |
|
76
|
|
|
*/ |
|
77
|
|
|
function reencodeImage($fileName, $preferred_format = 0) |
|
78
|
|
|
{ |
|
79
|
|
|
if (!resizeImageFile($fileName, $fileName . '.tmp', null, null, $preferred_format, true)) |
|
80
|
|
|
{ |
|
81
|
|
|
if (file_exists($fileName . '.tmp')) |
|
82
|
|
|
unlink($fileName . '.tmp'); |
|
83
|
|
|
|
|
84
|
|
|
return false; |
|
85
|
|
|
} |
|
86
|
|
|
|
|
87
|
|
|
if (!unlink($fileName)) |
|
88
|
|
|
return false; |
|
89
|
|
|
|
|
90
|
|
|
return rename($fileName . '.tmp', $fileName); |
|
91
|
|
|
} |
|
92
|
|
|
|
|
93
|
|
|
/** |
|
94
|
|
|
* Searches through the file to see if there's potentially harmful non-binary content. |
|
95
|
|
|
* |
|
96
|
|
|
* What it does: |
|
97
|
|
|
* |
|
98
|
|
|
* - if extensiveCheck is true, searches for asp/php short tags as well. |
|
99
|
|
|
* |
|
100
|
|
|
* @package Graphics |
|
101
|
|
|
* |
|
102
|
|
|
* @param string $fileName The path to the file |
|
103
|
|
|
* @param bool $extensiveCheck = false if it should perform extensive checks |
|
104
|
|
|
* |
|
105
|
|
|
* @return bool Whether the image appears to be safe |
|
106
|
|
|
* @throws Elk_Exception attach_timeout |
|
107
|
|
|
*/ |
|
108
|
|
|
function checkImageContents($fileName, $extensiveCheck = false) |
|
109
|
|
|
{ |
|
110
|
|
|
$fp = fopen($fileName, 'rb'); |
|
111
|
|
|
if (!$fp) |
|
|
|
|
|
|
112
|
|
|
{ |
|
113
|
|
|
loadLanguage('Post'); |
|
114
|
|
|
throw new Elk_Exception('attach_timeout'); |
|
115
|
|
|
} |
|
116
|
|
|
|
|
117
|
|
|
$prev_chunk = ''; |
|
118
|
|
|
while (!feof($fp)) |
|
119
|
|
|
{ |
|
120
|
|
|
$cur_chunk = fread($fp, 8192); |
|
121
|
|
|
$test_chunk = $prev_chunk . $cur_chunk; |
|
122
|
|
|
|
|
123
|
|
|
// Though not exhaustive lists, better safe than sorry. |
|
124
|
|
|
if (!empty($extensiveCheck)) |
|
125
|
|
|
{ |
|
126
|
|
|
// Paranoid check. Some like it that way. |
|
127
|
|
|
if (preg_match('~<\\?php|<script\W|(?-i)[CFZ]WS[\x01-\x0E]~i', $test_chunk) === 1) |
|
128
|
|
|
{ |
|
129
|
|
|
fclose($fp); |
|
130
|
|
|
return false; |
|
131
|
|
|
} |
|
132
|
|
|
} |
|
133
|
|
|
else |
|
134
|
|
|
{ |
|
135
|
|
|
// Check for potential php injection |
|
136
|
|
|
if (preg_match('~<\\?php|<script\s+language\s*=\s*(?:php|"php"|\'php\')\s*>~i', $test_chunk) === 1) |
|
137
|
|
|
{ |
|
138
|
|
|
fclose($fp); |
|
139
|
|
|
return false; |
|
140
|
|
|
} |
|
141
|
|
|
} |
|
142
|
|
|
|
|
143
|
|
|
$prev_chunk = $cur_chunk; |
|
144
|
|
|
} |
|
145
|
|
|
|
|
146
|
|
|
fclose($fp); |
|
147
|
|
|
|
|
148
|
|
|
return true; |
|
149
|
|
|
} |
|
150
|
|
|
|
|
151
|
|
|
/** |
|
152
|
|
|
* Sets a global $gd2 variable needed by some functions to determine |
|
153
|
|
|
* whether the GD2 library is present. |
|
154
|
|
|
* |
|
155
|
|
|
* @package Graphics |
|
156
|
|
|
* |
|
157
|
|
|
* @return bool Whether or not GD is available. |
|
158
|
|
|
*/ |
|
159
|
|
|
function checkGD() |
|
160
|
|
|
{ |
|
161
|
|
|
global $gd2; |
|
162
|
|
|
|
|
163
|
|
|
// Check to see if GD is installed and what version. |
|
164
|
|
|
if (($extensionFunctions = get_extension_funcs('gd')) === false) |
|
165
|
|
|
return false; |
|
166
|
|
|
|
|
167
|
|
|
// Also determine if GD2 is installed and store it in a global. |
|
168
|
|
|
$gd2 = in_array('imagecreatetruecolor', $extensionFunctions) && function_exists('imagecreatetruecolor'); |
|
169
|
|
|
|
|
170
|
|
|
return true; |
|
171
|
|
|
} |
|
172
|
|
|
|
|
173
|
|
|
/** |
|
174
|
|
|
* Checks whether the Imagick class is present. |
|
175
|
|
|
* |
|
176
|
|
|
* @package Graphics |
|
177
|
|
|
* |
|
178
|
|
|
* @return bool Whether or not the Imagick extension is available. |
|
179
|
|
|
*/ |
|
180
|
|
|
function checkImagick() |
|
181
|
|
|
{ |
|
182
|
|
|
return class_exists('Imagick', false); |
|
183
|
|
|
} |
|
184
|
|
|
|
|
185
|
|
|
/** |
|
186
|
|
|
* Check if the system supports webP |
|
187
|
|
|
* |
|
188
|
|
|
* @return bool |
|
189
|
|
|
*/ |
|
190
|
|
|
function hasWebpSupport($type = false) |
|
191
|
|
|
{ |
|
192
|
|
|
$check_im = false; |
|
193
|
|
|
$check_gd = false; |
|
194
|
|
|
|
|
195
|
|
|
if (checkImagick()) |
|
196
|
|
|
{ |
|
197
|
|
|
$check = Imagick::queryformats(); |
|
198
|
|
|
$check_im = in_array('WEBP', $check); |
|
199
|
|
|
} |
|
200
|
|
|
|
|
201
|
|
|
if (checkGD()) |
|
202
|
|
|
{ |
|
203
|
|
|
$check = gd_info(); |
|
204
|
|
|
$check_gd = !empty($check['WebP Support']); |
|
205
|
|
|
} |
|
206
|
|
|
|
|
207
|
|
|
if ($type) |
|
208
|
|
|
{ |
|
209
|
|
|
return $check_im ? 'im' : ($check_gd ? 'gd' : ''); |
|
|
|
|
|
|
210
|
|
|
} |
|
211
|
|
|
|
|
212
|
|
|
return $check_gd || $check_im; |
|
213
|
|
|
} |
|
214
|
|
|
|
|
215
|
|
|
/** |
|
216
|
|
|
* See if we have enough memory to thumbnail an image |
|
217
|
|
|
* |
|
218
|
|
|
* @package Graphics |
|
219
|
|
|
* @param int[] $sizes image size |
|
220
|
|
|
* |
|
221
|
|
|
* @return bool Whether or not the memory is available. |
|
222
|
|
|
*/ |
|
223
|
|
|
function imageMemoryCheck($sizes) |
|
224
|
|
|
{ |
|
225
|
|
|
global $modSettings; |
|
226
|
|
|
|
|
227
|
|
|
// Just to be sure |
|
228
|
|
|
if (!is_array($sizes) || $sizes[0] === -1) |
|
|
|
|
|
|
229
|
|
|
{ |
|
230
|
|
|
return true; |
|
231
|
|
|
} |
|
232
|
|
|
|
|
233
|
|
|
// Doing the old 'set it and hope' way? |
|
234
|
|
|
if (empty($modSettings['attachment_thumb_memory'])) |
|
235
|
|
|
{ |
|
236
|
|
|
detectServer()->setMemoryLimit('128M'); |
|
237
|
|
|
return true; |
|
238
|
|
|
} |
|
239
|
|
|
|
|
240
|
|
|
// Determine the memory requirements for this image, note: if you want to use an image formula |
|
241
|
|
|
// W x H x bits/8 x channels x Overhead factor |
|
242
|
|
|
// You will need to account for single bit images as GD expands them to an 8 bit and will greatly |
|
243
|
|
|
// overun the calculated value. |
|
244
|
|
|
// The 5 below is simply a shortcut of 8bpp, 3 channels, 1.66 overhead |
|
245
|
|
|
$needed_memory = ($sizes[0] * $sizes[1] * 5); |
|
246
|
|
|
|
|
247
|
|
|
// If we need more, lets try to get it |
|
248
|
|
|
return detectServer()->setMemoryLimit($needed_memory, true); |
|
249
|
|
|
} |
|
250
|
|
|
|
|
251
|
|
|
/** |
|
252
|
|
|
* Resize an image from a remote location or a local file. |
|
253
|
|
|
* |
|
254
|
|
|
* What it does: |
|
255
|
|
|
* |
|
256
|
|
|
* - Puts the resized image at the destination location. |
|
257
|
|
|
* - The file would have the format preferred_format if possible, |
|
258
|
|
|
* otherwise the default format is jpeg. |
|
259
|
|
|
* |
|
260
|
|
|
* @package Graphics |
|
261
|
|
|
* |
|
262
|
|
|
* @param string $source The name of the source image |
|
263
|
|
|
* @param string $destination The name of the destination image |
|
264
|
|
|
* @param int $max_width The maximum allowed width |
|
265
|
|
|
* @param int $max_height The maximum allowed height |
|
266
|
|
|
* @param int $preferred_format Used by Imagick/resizeImage |
|
267
|
|
|
* @param bool $strip Allow IM to remove exif data as GD always will |
|
268
|
|
|
* @param bool $force_resize Always resize the image (force scale up) |
|
269
|
|
|
* |
|
270
|
|
|
* @return boolean Whether the thumbnail creation was successful. |
|
271
|
|
|
*/ |
|
272
|
|
|
function resizeImageFile($source, $destination, $max_width, $max_height, $preferred_format = 0, $strip = false, $force_resize = true) |
|
273
|
|
|
{ |
|
274
|
|
|
global $modSettings; |
|
275
|
|
|
|
|
276
|
|
|
// Nothing to do without GD or IM |
|
277
|
|
|
if (!checkGD() && !checkImagick()) |
|
278
|
|
|
return false; |
|
279
|
|
|
|
|
280
|
|
|
if (!file_exists($source) && substr($source, 0, 7) !== 'http://' && substr($source, 0, 8) !== 'https://') |
|
281
|
|
|
{ |
|
282
|
|
|
return false; |
|
283
|
|
|
} |
|
284
|
|
|
|
|
285
|
|
|
$default_formats = array( |
|
286
|
|
|
1 => 'gif', |
|
287
|
|
|
2 => 'jpeg', |
|
288
|
|
|
3 => 'png', |
|
289
|
|
|
6 => 'bmp', |
|
290
|
|
|
15 => 'wbmp', |
|
291
|
|
|
18 => 'webp' |
|
292
|
|
|
); |
|
293
|
|
|
|
|
294
|
|
|
require_once(SUBSDIR . '/Package.subs.php'); |
|
295
|
|
|
require_once(SUBSDIR . '/Attachments.subs.php'); |
|
296
|
|
|
|
|
297
|
|
|
// Get the image file, we have to work with something after all |
|
298
|
|
|
$fp_destination = fopen($destination, 'wb'); |
|
299
|
|
|
if ($fp_destination && (substr($source, 0, 7) === 'http://' || substr($source, 0, 8) === 'https://')) |
|
|
|
|
|
|
300
|
|
|
{ |
|
301
|
|
|
$fileContents = fetch_web_data($source); |
|
302
|
|
|
|
|
303
|
|
|
fwrite($fp_destination, $fileContents); |
|
304
|
|
|
fclose($fp_destination); |
|
305
|
|
|
|
|
306
|
|
|
$sizes = elk_getimagesize($destination); |
|
307
|
|
|
} |
|
308
|
|
|
elseif ($fp_destination) |
|
|
|
|
|
|
309
|
|
|
{ |
|
310
|
|
|
$sizes = elk_getimagesize($source); |
|
311
|
|
|
|
|
312
|
|
|
$fp_source = fopen($source, 'rb'); |
|
313
|
|
|
if ($fp_source !== false) |
|
314
|
|
|
{ |
|
315
|
|
|
while (!feof($fp_source)) |
|
316
|
|
|
{ |
|
317
|
|
|
fwrite($fp_destination, fread($fp_source, 8192)); |
|
318
|
|
|
} |
|
319
|
|
|
fclose($fp_source); |
|
320
|
|
|
} |
|
321
|
|
|
else |
|
322
|
|
|
$sizes = array(-1, -1, -1); |
|
323
|
|
|
|
|
324
|
|
|
fclose($fp_destination); |
|
325
|
|
|
} |
|
326
|
|
|
// We can't get to the file. |
|
327
|
|
|
else |
|
328
|
|
|
$sizes = array(-1, -1, -1); |
|
329
|
|
|
|
|
330
|
|
|
if ($sizes[0] === -1) |
|
331
|
|
|
return false; |
|
332
|
|
|
|
|
333
|
|
|
// See if we have -or- can get the needed memory for this operation |
|
334
|
|
|
if (checkGD() && !imageMemoryCheck($sizes)) |
|
335
|
|
|
return false; |
|
336
|
|
|
|
|
337
|
|
|
$webp_support = hasWebpSupport(true); |
|
338
|
|
|
|
|
339
|
|
|
// Not allowed to save webp or can't support webp input |
|
340
|
|
|
if ((empty($modSettings['attachment_webp_enable']) && $preferred_format == 18) || ($sizes[2] == 18 && empty($webp_support))) |
|
341
|
|
|
return false; |
|
342
|
|
|
|
|
343
|
|
|
// A known and supported format? |
|
344
|
|
|
if (checkImagick() && isset($default_formats[$sizes[2]]) |
|
345
|
|
|
&& ($sizes[2] != 18 || $webp_support === 'im')) |
|
346
|
|
|
{ |
|
347
|
|
|
return resizeImage(null, $destination, null, null, $max_width, $max_height, $force_resize, $preferred_format, $strip); |
|
348
|
|
|
} |
|
349
|
|
|
elseif (checkGD() && isset($default_formats[$sizes[2]]) |
|
350
|
|
|
&& ($sizes[2] != 18 || $webp_support === 'gd') |
|
351
|
|
|
&& function_exists('imagecreatefrom' . $default_formats[$sizes[2]])) |
|
352
|
|
|
{ |
|
353
|
|
|
try |
|
354
|
|
|
{ |
|
355
|
|
|
$imagecreatefrom = 'imagecreatefrom' . $default_formats[$sizes[2]]; |
|
356
|
|
|
$src_img = $imagecreatefrom($destination); |
|
357
|
|
|
return resizeImage($src_img, $destination, imagesx($src_img), imagesy($src_img), $max_width === null ? imagesx($src_img) : $max_width, $max_height === null ? imagesy($src_img) : $max_height, $force_resize, $preferred_format, $strip, true); |
|
|
|
|
|
|
358
|
|
|
} |
|
359
|
|
|
catch (\Exception $e) |
|
360
|
|
|
{ |
|
361
|
|
|
return false; |
|
362
|
|
|
} |
|
363
|
|
|
} |
|
364
|
|
|
|
|
365
|
|
|
return false; |
|
366
|
|
|
} |
|
367
|
|
|
|
|
368
|
|
|
/** |
|
369
|
|
|
* Resize an image proportionally to fit within the defined max_width and max_height limits |
|
370
|
|
|
* |
|
371
|
|
|
* What it does: |
|
372
|
|
|
* |
|
373
|
|
|
* - Will do nothing to the image if the file fits within the size limits |
|
374
|
|
|
* - If Image Magick is present it will use those function over any GD solutions |
|
375
|
|
|
* - If GD2 is present, it'll use it to achieve better quality (imagecopyresampled) |
|
376
|
|
|
* - Saves the new image to destination_filename, in the preferred_format |
|
377
|
|
|
* if possible, default is jpeg. |
|
378
|
|
|
* |
|
379
|
|
|
* @uses GD |
|
380
|
|
|
* @uses Imagick |
|
381
|
|
|
* |
|
382
|
|
|
* @package Graphics |
|
383
|
|
|
* @param resource|null $src_img null for Imagick images, resource form imagecreatefrom for GD |
|
384
|
|
|
* @param string $destName |
|
385
|
|
|
* @param int $src_width The width of the source image |
|
386
|
|
|
* @param int $src_height The height of the source image |
|
387
|
|
|
* @param int $max_width The maximum allowed width |
|
388
|
|
|
* @param int $max_height The maximum allowed height |
|
389
|
|
|
* @param bool $force_resize = false Whether to override defaults and resize it |
|
390
|
|
|
* @param int $preferred_format - The preferred format |
|
391
|
|
|
* - 0 to use jpeg |
|
392
|
|
|
* - 1 for gif |
|
393
|
|
|
* - 2 to force jpeg |
|
394
|
|
|
* - 3 for png |
|
395
|
|
|
* - 6 for bmp |
|
396
|
|
|
* - 15 for wbmp |
|
397
|
|
|
* - 18 for webp |
|
398
|
|
|
* @param bool $strip Whether to have IM strip EXIF data as GD will |
|
399
|
|
|
* @param bool $force_gd Whether to force GD processing over IM |
|
400
|
|
|
* |
|
401
|
|
|
* @return bool Whether resize was successful. |
|
402
|
|
|
*/ |
|
403
|
|
|
function resizeImage($src_img, $destName, $src_width, $src_height, $max_width, $max_height, $force_resize = false, $preferred_format = 0, $strip = false, $force_gd = false) |
|
404
|
|
|
{ |
|
405
|
|
|
global $gd2, $modSettings; |
|
406
|
|
|
|
|
407
|
|
|
if (checkImagick() && !$force_gd) |
|
408
|
|
|
{ |
|
409
|
|
|
// These are the file formats we know about |
|
410
|
|
|
$default_formats = array( |
|
411
|
|
|
1 => 'gif', |
|
412
|
|
|
2 => 'jpeg', |
|
413
|
|
|
3 => 'png', |
|
414
|
|
|
6 => 'bmp', |
|
415
|
|
|
15 => 'wbmp', |
|
416
|
|
|
18 => 'webp' |
|
417
|
|
|
); |
|
418
|
|
|
|
|
419
|
|
|
// Just to be sure, if the admin does not want webp |
|
420
|
|
|
if (empty($modSettings['attachment_webp_enable'])) |
|
421
|
|
|
unset($default_formats[18]); |
|
422
|
|
|
|
|
423
|
|
|
$preferred_format = empty($preferred_format) || !isset($default_formats[$preferred_format]) ? 2 : $preferred_format; |
|
424
|
|
|
|
|
425
|
|
|
// Since Imagick can throw exceptions, lets catch them |
|
426
|
|
|
try |
|
427
|
|
|
{ |
|
428
|
|
|
// Get a new instance of Imagick for use |
|
429
|
|
|
$imagick = new Imagick($destName); |
|
430
|
|
|
$imagick->setFirstIterator(); |
|
431
|
|
|
|
|
432
|
|
|
// Set the input and output image size |
|
433
|
|
|
$src_width = empty($src_width) ? $imagick->getImageWidth() : $src_width; |
|
434
|
|
|
$src_height = empty($src_height) ? $imagick->getImageHeight() : $src_height; |
|
435
|
|
|
|
|
436
|
|
|
// The behavior of bestfit changed in Imagick 3.0.0 and it will now scale up, we prevent that |
|
437
|
|
|
$dest_width = empty($max_width) ? $src_width : ($force_resize ? $max_width : min($max_width, $src_width)); |
|
438
|
|
|
$dest_height = empty($max_height) ? $src_height : ($force_resize ? $max_height : min($max_height, $src_height)); |
|
439
|
|
|
|
|
440
|
|
|
// Set jpeg image quality to 80 |
|
441
|
|
|
if ($default_formats[$preferred_format] === 'jpeg') |
|
442
|
|
|
{ |
|
443
|
|
|
$imagick->borderImage('white', 0, 0); |
|
444
|
|
|
$imagick->setImageCompression(Imagick::COMPRESSION_JPEG); |
|
445
|
|
|
$imagick->setImageCompressionQuality(80); |
|
446
|
|
|
} |
|
447
|
|
|
|
|
448
|
|
|
// With PNG Save a few bytes the only way, realistically, we can |
|
449
|
|
|
if ($default_formats[$preferred_format] === 'png') |
|
450
|
|
|
{ |
|
451
|
|
|
$imagick->setOption('png:compression-level', '9'); |
|
452
|
|
|
$imagick->setOption('png:exclude-chunk', 'all'); |
|
453
|
|
|
} |
|
454
|
|
|
|
|
455
|
|
|
// Webp |
|
456
|
|
|
if ($default_formats[$preferred_format] === 'webp') |
|
457
|
|
|
{ |
|
458
|
|
|
$imagick->setImageCompressionQuality(80); |
|
459
|
|
|
} |
|
460
|
|
|
|
|
461
|
|
|
// Create a new image in our preferred format and resize it if needed |
|
462
|
|
|
$imagick->setImageFormat($default_formats[$preferred_format]); |
|
463
|
|
|
if (substr($destName, -6) === '_thumb') |
|
464
|
|
|
$imagick->thumbnailImage($dest_width, $dest_height, true); |
|
465
|
|
|
else |
|
466
|
|
|
$imagick->resizeImage($dest_width, $dest_height, imagick::FILTER_LANCZOS, 1, true); |
|
467
|
|
|
|
|
468
|
|
|
// Remove EXIF / ICC data? |
|
469
|
|
|
if ($strip) |
|
470
|
|
|
{ |
|
471
|
|
|
$imagick->stripImage(); |
|
472
|
|
|
} |
|
473
|
|
|
|
|
474
|
|
|
// Save the new image in the destination location |
|
475
|
|
|
if ($preferred_format === IMAGETYPE_GIF && $imagick->getNumberImages() !== 0) |
|
476
|
|
|
$success = $imagick->writeImages($destName, true); |
|
477
|
|
|
else |
|
478
|
|
|
$success = $imagick->writeImage($destName); |
|
479
|
|
|
|
|
480
|
|
|
// Free resources associated with the Imagick object |
|
481
|
|
|
$imagick->clear(); |
|
482
|
|
|
} |
|
483
|
|
|
catch (Exception $e) |
|
484
|
|
|
{ |
|
485
|
|
|
$success = false; |
|
486
|
|
|
} |
|
487
|
|
|
|
|
488
|
|
|
return !empty($success); |
|
489
|
|
|
} |
|
490
|
|
|
elseif (checkGD()) |
|
491
|
|
|
{ |
|
492
|
|
|
$success = false; |
|
493
|
|
|
|
|
494
|
|
|
// Determine whether to resize to max width or to max height (depending on the limits.) |
|
495
|
|
|
if (!empty($max_width) || !empty($max_height)) |
|
496
|
|
|
{ |
|
497
|
|
|
if (!empty($max_width) && (empty($max_height) || $src_height * $max_width / $src_width <= $max_height)) |
|
498
|
|
|
{ |
|
499
|
|
|
$dst_width = $max_width; |
|
500
|
|
|
$dst_height = floor($src_height * $max_width / $src_width); |
|
501
|
|
|
} |
|
502
|
|
|
elseif (!empty($max_height)) |
|
503
|
|
|
{ |
|
504
|
|
|
$dst_width = floor($src_width * $max_height / $src_height); |
|
505
|
|
|
$dst_height = $max_height; |
|
506
|
|
|
} |
|
507
|
|
|
|
|
508
|
|
|
// Don't bother resizing if it's already smaller... |
|
509
|
|
|
if (!empty($dst_width) && !empty($dst_height) && ($dst_width < $src_width || $dst_height < $src_height || $force_resize)) |
|
510
|
|
|
{ |
|
511
|
|
|
// (make a true color image, because it just looks better for resizing.) |
|
512
|
|
|
if ($gd2) |
|
513
|
|
|
{ |
|
514
|
|
|
$dst_img = imagecreatetruecolor($dst_width, $dst_height); |
|
515
|
|
|
|
|
516
|
|
|
// Make a true color image, because it just looks better for resizing. |
|
517
|
|
|
imagesavealpha($dst_img, true); |
|
518
|
|
|
$color = imagecolorallocatealpha($dst_img, 255, 255, 255, 127); |
|
519
|
|
|
imagefill($dst_img, 0, 0, $color); |
|
520
|
|
|
|
|
521
|
|
|
// Resize it! |
|
522
|
|
|
imagecopyresampled($dst_img, $src_img, 0, 0, 0, 0, $dst_width, $dst_height, $src_width, $src_height); |
|
523
|
|
|
} |
|
524
|
|
|
else |
|
525
|
|
|
{ |
|
526
|
|
|
$dst_img = imagecreate($dst_width, $dst_height); |
|
527
|
|
|
imagecopyresamplebicubic($dst_img, $src_img, 0, 0, 0, 0, $dst_width, $dst_height, $src_width, $src_height); |
|
|
|
|
|
|
528
|
|
|
} |
|
529
|
|
|
} |
|
530
|
|
|
else |
|
531
|
|
|
$dst_img = $src_img; |
|
532
|
|
|
} |
|
533
|
|
|
else |
|
534
|
|
|
$dst_img = $src_img; |
|
535
|
|
|
|
|
536
|
|
|
// Save the image as ... |
|
537
|
|
|
if (!empty($preferred_format) && ($preferred_format == 3) && function_exists('imagepng')) |
|
538
|
|
|
$success = imagepng($dst_img, $destName, 9, PNG_ALL_FILTERS); |
|
539
|
|
|
elseif (!empty($preferred_format) && ($preferred_format == 1) && function_exists('imagegif')) |
|
540
|
|
|
$success = imagegif($dst_img, $destName); |
|
541
|
|
|
elseif (!empty($preferred_format) && $preferred_format == 18 && function_exists('imagewebp')) |
|
542
|
|
|
$success = imagewebp($dst_img, $destName, 80); |
|
543
|
|
|
elseif (function_exists('imagejpeg')) |
|
544
|
|
|
$success = imagejpeg($dst_img, $destName, 80); |
|
545
|
|
|
|
|
546
|
|
|
// Free the memory. |
|
547
|
|
|
imagedestroy($src_img); |
|
548
|
|
|
if ($dst_img != $src_img) |
|
549
|
|
|
imagedestroy($dst_img); |
|
550
|
|
|
|
|
551
|
|
|
return $success; |
|
552
|
|
|
} |
|
553
|
|
|
// Without Imagick or GD, no image resizing at all. |
|
554
|
|
|
else |
|
555
|
|
|
return false; |
|
556
|
|
|
} |
|
557
|
|
|
|
|
558
|
|
|
/* |
|
559
|
|
|
* Determines if an image has any alpha pixels |
|
560
|
|
|
* |
|
561
|
|
|
* @param string $fileName |
|
562
|
|
|
* @return bool |
|
563
|
|
|
*/ |
|
564
|
|
|
function hasTransparency($fileName, $png = true) |
|
565
|
|
|
{ |
|
566
|
|
|
if (empty($fileName) || !file_exists($fileName)) |
|
567
|
|
|
return false; |
|
568
|
|
|
|
|
569
|
|
|
$header = file_get_contents($fileName, false, null, 0, 26); |
|
570
|
|
|
|
|
571
|
|
|
// Does it even claim to have been saved with transparency |
|
572
|
|
|
if ($png && !ord($header[25]) & 4) |
|
573
|
|
|
return false; |
|
574
|
|
|
|
|
575
|
|
|
// Webp has its own |
|
576
|
|
|
if (!$png) |
|
577
|
|
|
{ |
|
578
|
|
|
if (($header[15] === 'L' && !(ord($header[24]) & 16)) || ($header[15] === 'X' && !(ord($header[20]) & 16))) |
|
579
|
|
|
{ |
|
580
|
|
|
return false; |
|
581
|
|
|
} |
|
582
|
|
|
} |
|
583
|
|
|
|
|
584
|
|
|
// Saved with transparency is only a start, now Pixel inspection |
|
585
|
|
|
$webp_support = hasWebpSupport(true); |
|
586
|
|
|
if (checkImagick() && ($png || $webp_support === 'im')) |
|
587
|
|
|
{ |
|
588
|
|
|
$transparency = false; |
|
589
|
|
|
try |
|
590
|
|
|
{ |
|
591
|
|
|
$image = new Imagick($fileName); |
|
592
|
|
|
if ($image->getImageWidth() > 1024 || $image->getImageHeight() > 1024) |
|
593
|
|
|
{ |
|
594
|
|
|
// Used to look for transparency, it is not intended to be a quality image. |
|
595
|
|
|
$scaleValue = getImageScaleFactor($image->getImageWidth(), $image->getImageHeight()); |
|
596
|
|
|
$image->scaleImage($scaleValue[0], $scaleValue[1], true); |
|
597
|
|
|
} |
|
598
|
|
|
|
|
599
|
|
|
$pixel_iterator = $image->getPixelIterator(); |
|
600
|
|
|
|
|
601
|
|
|
// Look at each one, or until we find the first alpha pixel |
|
602
|
|
|
foreach ($pixel_iterator as $pixels) |
|
603
|
|
|
{ |
|
604
|
|
|
foreach ($pixels as $pixel) |
|
605
|
|
|
{ |
|
606
|
|
|
$color = $pixel->getColor(); |
|
607
|
|
|
if ($color['a'] < 1) |
|
608
|
|
|
{ |
|
609
|
|
|
$transparency = true; |
|
610
|
|
|
break 2; |
|
611
|
|
|
} |
|
612
|
|
|
} |
|
613
|
|
|
} |
|
614
|
|
|
} |
|
615
|
|
|
catch (\ImagickException $e) |
|
616
|
|
|
{ |
|
617
|
|
|
// We don't know what it is, so don't mess with it |
|
618
|
|
|
unset($image); |
|
619
|
|
|
return true; |
|
620
|
|
|
} |
|
621
|
|
|
|
|
622
|
|
|
unset($image); |
|
623
|
|
|
|
|
624
|
|
|
return $transparency; |
|
625
|
|
|
} |
|
626
|
|
|
|
|
627
|
|
|
if (checkGD() && ($png || $webp_support === 'gd')) |
|
628
|
|
|
{ |
|
629
|
|
|
// Go through the image pixel by pixel until we find a transparent pixel |
|
630
|
|
|
$transparency = false; |
|
631
|
|
|
list ($width, $height, $type) = elk_getimagesize($fileName); |
|
632
|
|
|
|
|
633
|
|
|
if ($type === 18 && $webp_support === 'gd') |
|
|
|
|
|
|
634
|
|
|
$image = imagecreatefromwebp($fileName); |
|
635
|
|
|
elseif ($type === 3) |
|
636
|
|
|
$image = imagecreatefrompng($fileName); |
|
637
|
|
|
else |
|
638
|
|
|
return false; |
|
639
|
|
|
|
|
640
|
|
|
// Large image, scale down to reduce processing time |
|
641
|
|
|
if ($width > 1024 || $height > 1024) |
|
642
|
|
|
{ |
|
643
|
|
|
// Single pass scale down, not looking for quality here |
|
644
|
|
|
$scaleValue = getImageScaleFactor($width, $height); |
|
645
|
|
|
$image = imagescale($image, $scaleValue[0], $scaleValue[1], IMG_NEAREST_NEIGHBOUR); |
|
646
|
|
|
if (!$image) |
|
647
|
|
|
{ |
|
648
|
|
|
return true; |
|
649
|
|
|
} |
|
650
|
|
|
} |
|
651
|
|
|
|
|
652
|
|
|
$x = imagesx($image); |
|
653
|
|
|
$y = imagesy($image); |
|
654
|
|
|
for ($i = 0; $i < $x; $i++) |
|
655
|
|
|
{ |
|
656
|
|
|
for ($j = 0; $j < $y; $j++) |
|
657
|
|
|
{ |
|
658
|
|
|
if (imagecolorat($image, $i, $j) & 0x7F000000) |
|
659
|
|
|
{ |
|
660
|
|
|
$transparency = true; |
|
661
|
|
|
break 2; |
|
662
|
|
|
} |
|
663
|
|
|
} |
|
664
|
|
|
} |
|
665
|
|
|
|
|
666
|
|
|
unset($image); |
|
667
|
|
|
|
|
668
|
|
|
return $transparency; |
|
669
|
|
|
} |
|
670
|
|
|
|
|
671
|
|
|
// Don't know so assume true |
|
672
|
|
|
return true; |
|
673
|
|
|
} |
|
674
|
|
|
|
|
675
|
|
|
/** |
|
676
|
|
|
* Provides image scaling factors that maintain existing aspect ratio |
|
677
|
|
|
* |
|
678
|
|
|
* @param int $width current width |
|
679
|
|
|
* @param int $height current height |
|
680
|
|
|
* @param int $limit desired width/height limit |
|
681
|
|
|
* @return int[] |
|
682
|
|
|
*/ |
|
683
|
|
|
function getImageScaleFactor($width, $height, $limit = 800) |
|
684
|
|
|
{ |
|
685
|
|
|
$thumb_w = $limit; |
|
686
|
|
|
$thumb_h = $limit; |
|
687
|
|
|
|
|
688
|
|
|
// Landscape |
|
689
|
|
|
if ($width > $height) |
|
690
|
|
|
{ |
|
691
|
|
|
$thumb_h = max (1, $height * ($limit / $width)); |
|
692
|
|
|
} |
|
693
|
|
|
// Portrait |
|
694
|
|
|
elseif ($width < $height) |
|
695
|
|
|
{ |
|
696
|
|
|
$thumb_w = max(1, $width * ($limit / $height)); |
|
697
|
|
|
} |
|
698
|
|
|
|
|
699
|
|
|
return array((int) $thumb_w, (int) $thumb_h); |
|
700
|
|
|
} |
|
701
|
|
|
|
|
702
|
|
|
/** |
|
703
|
|
|
* Sets the best output format for a given image's thumbnail |
|
704
|
|
|
* |
|
705
|
|
|
* - If webP is on, and supported, use that as it gives the smallest size |
|
706
|
|
|
* - If webP support is available, but not on, save as png if it has alpha channel pixels |
|
707
|
|
|
* - If the image has alpha, we preserve it as PNG |
|
708
|
|
|
* - Finally good ol' jpeg |
|
709
|
|
|
* |
|
710
|
|
|
* @return int 2, 3, or 18 |
|
711
|
|
|
*/ |
|
712
|
|
|
function setDefaultFormat($fileName = '') |
|
713
|
|
|
{ |
|
714
|
|
|
global $modSettings; |
|
715
|
|
|
|
|
716
|
|
|
// Webp is the best choice if server supports |
|
717
|
|
|
if (!empty($modSettings['attachment_webp_enable']) && hasWebpSupport()) |
|
718
|
|
|
{ |
|
719
|
|
|
return 18; |
|
720
|
|
|
} |
|
721
|
|
|
|
|
722
|
|
|
$mime = getMimeType($fileName); |
|
723
|
|
|
|
|
724
|
|
|
// They uploaded a webp image, but ACP does not allow saving webp images, then |
|
725
|
|
|
// if the server supports and its alpha save it as a png |
|
726
|
|
|
if ($mime === 'image/webp' && hasWebpSupport() && hasTransparency($fileName, false)) |
|
727
|
|
|
{ |
|
728
|
|
|
return 3; |
|
729
|
|
|
} |
|
730
|
|
|
|
|
731
|
|
|
// If you have alpha channels, best keep them with PNG |
|
732
|
|
|
if ($mime === 'image/png' && hasTransparency($fileName)) |
|
733
|
|
|
{ |
|
734
|
|
|
return 3; |
|
735
|
|
|
} |
|
736
|
|
|
|
|
737
|
|
|
// The default, JPG |
|
738
|
|
|
return 2; |
|
739
|
|
|
} |
|
740
|
|
|
|
|
741
|
|
|
/** |
|
742
|
|
|
* Best determination of the mime type. |
|
743
|
|
|
* |
|
744
|
|
|
* @return string |
|
745
|
|
|
*/ |
|
746
|
|
|
function getMimeType($fileName) |
|
747
|
|
|
{ |
|
748
|
|
|
// Try Exif which reads the file headers, most accurate for images |
|
749
|
|
|
if (function_exists('exif_imagetype')) |
|
750
|
|
|
{ |
|
751
|
|
|
return image_type_to_mime_type(exif_imagetype($fileName)); |
|
752
|
|
|
} |
|
753
|
|
|
|
|
754
|
|
|
return get_finfo_mime($fileName); |
|
|
|
|
|
|
755
|
|
|
} |
|
756
|
|
|
|
|
757
|
|
|
/** |
|
758
|
|
|
* Calls GD or ImageMagick functions to correct an images orientation |
|
759
|
|
|
* based on the EXIF orientation flag |
|
760
|
|
|
* |
|
761
|
|
|
* @param string $image_name |
|
762
|
|
|
*/ |
|
763
|
|
|
function autoRotateImage($image_name) |
|
764
|
|
|
{ |
|
765
|
|
|
if (checkImagick()) |
|
766
|
|
|
{ |
|
767
|
|
|
autoRotateImageWithIM($image_name); |
|
768
|
|
|
} |
|
769
|
|
|
elseif (checkGD()) |
|
770
|
|
|
{ |
|
771
|
|
|
autoRotateImageWithGD($image_name); |
|
772
|
|
|
} |
|
773
|
|
|
} |
|
774
|
|
|
|
|
775
|
|
|
/** |
|
776
|
|
|
* Autorotate an image based on its EXIF Orientation tag. |
|
777
|
|
|
* |
|
778
|
|
|
* What it does: |
|
779
|
|
|
* |
|
780
|
|
|
* - GD only |
|
781
|
|
|
* - Checks exif data for orientation flag and rotates image so its proper |
|
782
|
|
|
* - Does not update orientation flag as GD removes EXIF data |
|
783
|
|
|
* - Only works with jpeg images, could add TIFF as well |
|
784
|
|
|
* - Writes the update image back to $image_name |
|
785
|
|
|
* |
|
786
|
|
|
* @package Graphics |
|
787
|
|
|
* @uses GD |
|
788
|
|
|
* @param string $image_name full location of the file |
|
789
|
|
|
*/ |
|
790
|
|
|
function autoRotateImageWithGD($image_name) |
|
791
|
|
|
{ |
|
792
|
|
|
// Read the EXIF data |
|
793
|
|
|
$exif = function_exists('exif_read_data') ? @exif_read_data($image_name) : array(); |
|
794
|
|
|
|
|
795
|
|
|
// We're only interested in the exif orientation |
|
796
|
|
|
$orientation = isset($exif['Orientation']) ? $exif['Orientation'] : 0; |
|
797
|
|
|
|
|
798
|
|
|
// For now we only process jpeg images, so check that we have one |
|
799
|
|
|
$sizes = elk_getimagesize($image_name); |
|
800
|
|
|
|
|
801
|
|
|
// Not a jpeg or not rotated, done! |
|
802
|
|
|
if ($sizes[2] !== 2 || $orientation === 0 || !imageMemoryCheck($sizes)) |
|
803
|
|
|
{ |
|
804
|
|
|
return false; |
|
805
|
|
|
} |
|
806
|
|
|
|
|
807
|
|
|
// Load the image object so we can begin the transformation(s) |
|
808
|
|
|
$source = imagecreatefromjpeg($image_name); |
|
809
|
|
|
|
|
810
|
|
|
// Time to spin and mirror as needed |
|
811
|
|
|
switch ($orientation) |
|
812
|
|
|
{ |
|
813
|
|
|
// 0 & 1 Not set or Normal |
|
814
|
|
|
case 0: |
|
815
|
|
|
case 1: |
|
816
|
|
|
break; |
|
817
|
|
|
// 2 Mirror image, Normal orientation |
|
818
|
|
|
case 2: |
|
819
|
|
|
$source = flopImageGD($source, $sizes); |
|
|
|
|
|
|
820
|
|
|
break; |
|
821
|
|
|
// 3 Normal image, rotated 180 |
|
822
|
|
|
case 3: |
|
823
|
|
|
$source = rotateImageGD($source, 180); |
|
|
|
|
|
|
824
|
|
|
break; |
|
825
|
|
|
// 4 Mirror image, rotated 180 |
|
826
|
|
|
case 4: |
|
827
|
|
|
$source = flipImageGD($source, $sizes); |
|
|
|
|
|
|
828
|
|
|
break; |
|
829
|
|
|
// 5 Mirror image, rotated 90 CCW |
|
830
|
|
|
case 5: |
|
831
|
|
|
$source = flopImageGD($source, $sizes); |
|
832
|
|
|
$source = rotateImageGD($source, 90); |
|
833
|
|
|
break; |
|
834
|
|
|
// 6 Normal image, rotated 90 CCW |
|
835
|
|
|
case 6: |
|
836
|
|
|
$source = rotateImageGD($source, -90); |
|
837
|
|
|
break; |
|
838
|
|
|
// 7 Mirror image, rotated 90 CW |
|
839
|
|
|
case 7: |
|
840
|
|
|
$source = flopImageGD($source, $sizes); |
|
841
|
|
|
$source = rotateImageGD($source, -90); |
|
842
|
|
|
break; |
|
843
|
|
|
// 8 Normal image, rotated 90 CW |
|
844
|
|
|
case 8: |
|
845
|
|
|
$source = rotateImageGD($source, 90); |
|
846
|
|
|
break; |
|
847
|
|
|
default: |
|
848
|
|
|
$orientation = 1; |
|
849
|
|
|
break; |
|
850
|
|
|
} |
|
851
|
|
|
|
|
852
|
|
|
// Save the updated image, free resources |
|
853
|
|
|
if ($orientation >= 2) |
|
854
|
|
|
{ |
|
855
|
|
|
imagejpeg($source, $image_name); |
|
856
|
|
|
} |
|
857
|
|
|
|
|
858
|
|
|
imagedestroy($source); |
|
859
|
|
|
|
|
860
|
|
|
return true; |
|
861
|
|
|
} |
|
862
|
|
|
|
|
863
|
|
|
/** |
|
864
|
|
|
* Autorotate an image based on its EXIF Orientation tag. |
|
865
|
|
|
* |
|
866
|
|
|
* What it does: |
|
867
|
|
|
* |
|
868
|
|
|
* - ImageMagick only |
|
869
|
|
|
* - Checks exif data for orientation flag and rotates image so its proper |
|
870
|
|
|
* - Updates orientation flag if rotation was required |
|
871
|
|
|
* - Writes the update image back to $image_name |
|
872
|
|
|
* |
|
873
|
|
|
* @uses Imagick |
|
874
|
|
|
* @param string $image_name |
|
875
|
|
|
*/ |
|
876
|
|
|
function autoRotateImageWithIM($image_name) |
|
877
|
|
|
{ |
|
878
|
|
|
// We only process jpeg images |
|
879
|
|
|
$sizes = elk_getimagesize($image_name); |
|
880
|
|
|
|
|
881
|
|
|
// Not a jpeg, no need to process |
|
882
|
|
|
if ($sizes[2] !== IMAGETYPE_JPEG) |
|
883
|
|
|
{ |
|
884
|
|
|
return false; |
|
885
|
|
|
} |
|
886
|
|
|
|
|
887
|
|
|
try |
|
888
|
|
|
{ |
|
889
|
|
|
// Get a new instance of Imagick for use |
|
890
|
|
|
$image = new Imagick($image_name); |
|
891
|
|
|
|
|
892
|
|
|
// This method should exist if Imagick has been compiled against ImageMagick version |
|
893
|
|
|
// 6.3.0 or higher which is forever ago, but we check anyway ;) |
|
894
|
|
|
if (!method_exists($image, 'getImageOrientation')) |
|
895
|
|
|
{ |
|
896
|
|
|
return false; |
|
897
|
|
|
} |
|
898
|
|
|
|
|
899
|
|
|
$orientation = $image->getImageOrientation(); |
|
900
|
|
|
switch ($orientation) |
|
901
|
|
|
{ |
|
902
|
|
|
// 0 & 1 Not set or Normal |
|
903
|
|
|
case Imagick::ORIENTATION_UNDEFINED: |
|
904
|
|
|
case Imagick::ORIENTATION_TOPLEFT: |
|
905
|
|
|
break; |
|
906
|
|
|
// 2 Mirror image, Normal orientation |
|
907
|
|
|
case Imagick::ORIENTATION_TOPRIGHT: |
|
908
|
|
|
$image->flopImage(); |
|
909
|
|
|
break; |
|
910
|
|
|
// 3 Normal image, rotated 180 |
|
911
|
|
|
case Imagick::ORIENTATION_BOTTOMRIGHT: |
|
912
|
|
|
$image->rotateImage('#000', 180); |
|
913
|
|
|
break; |
|
914
|
|
|
// 4 Mirror image, rotated 180 |
|
915
|
|
|
case Imagick::ORIENTATION_BOTTOMLEFT: |
|
916
|
|
|
$image->flipImage(); |
|
917
|
|
|
break; |
|
918
|
|
|
// 5 Mirror image, rotated 90 CCW |
|
919
|
|
|
case Imagick::ORIENTATION_LEFTTOP: |
|
920
|
|
|
$image->rotateImage('#000', 90); |
|
921
|
|
|
$image->flopImage(); |
|
922
|
|
|
break; |
|
923
|
|
|
// 6 Normal image, rotated 90 CCW |
|
924
|
|
|
case Imagick::ORIENTATION_RIGHTTOP: |
|
925
|
|
|
$image->rotateImage('#000', 90); |
|
926
|
|
|
break; |
|
927
|
|
|
// 7 Mirror image, rotated 90 CW |
|
928
|
|
|
case Imagick::ORIENTATION_RIGHTBOTTOM: |
|
929
|
|
|
$image->rotateImage('#000', -90); |
|
930
|
|
|
$image->flopImage(); |
|
931
|
|
|
break; |
|
932
|
|
|
// 8 Normal image, rotated 90 CW |
|
933
|
|
|
case Imagick::ORIENTATION_LEFTBOTTOM: |
|
934
|
|
|
$image->rotateImage('#000', -90); |
|
935
|
|
|
break; |
|
936
|
|
|
default: |
|
937
|
|
|
$orientation = 1; |
|
938
|
|
|
break; |
|
939
|
|
|
} |
|
940
|
|
|
|
|
941
|
|
|
// Now that it's auto-rotated, make sure the EXIF data is correctly updated |
|
942
|
|
|
if ($orientation >= 2) |
|
943
|
|
|
{ |
|
944
|
|
|
$image->setImageOrientation(Imagick::ORIENTATION_TOPLEFT); |
|
945
|
|
|
|
|
946
|
|
|
// Save the new image in the destination location |
|
947
|
|
|
$image->writeImage($image_name); |
|
948
|
|
|
} |
|
949
|
|
|
|
|
950
|
|
|
// Free resources associated with the Imagick object |
|
951
|
|
|
$image->clear(); |
|
952
|
|
|
} |
|
953
|
|
|
catch (\ImagickException $e) |
|
954
|
|
|
{ |
|
955
|
|
|
// pass through; |
|
956
|
|
|
} |
|
957
|
|
|
|
|
958
|
|
|
return true; |
|
959
|
|
|
} |
|
960
|
|
|
|
|
961
|
|
|
/** |
|
962
|
|
|
* Rotate an image by X degrees, GD function |
|
963
|
|
|
* |
|
964
|
|
|
* @param resource $image |
|
965
|
|
|
* @param int $degrees |
|
966
|
|
|
* |
|
967
|
|
|
* @package Graphics |
|
968
|
|
|
* @uses GD |
|
969
|
|
|
* @return resource |
|
970
|
|
|
*/ |
|
971
|
|
|
function rotateImageGD($image, $degrees) |
|
972
|
|
|
{ |
|
973
|
|
|
// Kind of need this to do anything |
|
974
|
|
|
if (function_exists('imagerotate')) |
|
975
|
|
|
{ |
|
976
|
|
|
// Use positive degrees so GD does not get confused |
|
977
|
|
|
$degrees -= floor($degrees / 360) * 360; |
|
978
|
|
|
|
|
979
|
|
|
// Rotate away |
|
980
|
|
|
$background = imagecolorallocatealpha($image, 255, 255, 255, 127); |
|
981
|
|
|
$image = imagerotate($image, $degrees, $background); |
|
982
|
|
|
} |
|
983
|
|
|
|
|
984
|
|
|
return $image; |
|
|
|
|
|
|
985
|
|
|
} |
|
986
|
|
|
|
|
987
|
|
|
/** |
|
988
|
|
|
* Flop an image using GD functions by copying top to bottom / flop |
|
989
|
|
|
* |
|
990
|
|
|
* @param resource $image |
|
991
|
|
|
* @param array $sizes populated with getimagesize results |
|
992
|
|
|
* |
|
993
|
|
|
* @package Graphics |
|
994
|
|
|
* @uses GD |
|
995
|
|
|
* @return resource |
|
996
|
|
|
*/ |
|
997
|
|
|
function flopImageGD($image, $sizes) |
|
998
|
|
|
{ |
|
999
|
|
|
return flipImageGD($image, $sizes, 'horizontal'); |
|
1000
|
|
|
} |
|
1001
|
|
|
|
|
1002
|
|
|
/** |
|
1003
|
|
|
* Flip an image using GD function by copying top to bottom / flip vertical |
|
1004
|
|
|
* |
|
1005
|
|
|
* @param resource $image |
|
1006
|
|
|
* @param array $sizes populated with getimagesize results |
|
1007
|
|
|
* @param string $axis vertical for flip about vertical otherwise horizontal flip |
|
1008
|
|
|
* |
|
1009
|
|
|
* @package Graphics |
|
1010
|
|
|
* @uses GD |
|
1011
|
|
|
* @return resource |
|
1012
|
|
|
*/ |
|
1013
|
|
|
function flipImageGD($image, $sizes, $axis = 'vertical') |
|
1014
|
|
|
{ |
|
1015
|
|
|
// If the built in function (php 5.5) is available, use it |
|
1016
|
|
|
if (function_exists('imageflip')) |
|
1017
|
|
|
{ |
|
1018
|
|
|
imageflip($image, $axis === 'vertical' ? IMG_FLIP_VERTICAL : IMG_FLIP_HORIZONTAL); |
|
1019
|
|
|
} |
|
1020
|
|
|
// Pixel mapping then |
|
1021
|
|
|
else |
|
1022
|
|
|
{ |
|
1023
|
|
|
$new = imagecreatetruecolor($sizes[0], $sizes[1]); |
|
1024
|
|
|
imagealphablending($new, false); |
|
1025
|
|
|
imagesavealpha($new, true); |
|
1026
|
|
|
|
|
1027
|
|
|
if ($axis === 'vertical') |
|
1028
|
|
|
{ |
|
1029
|
|
|
for ($y = 0; $y < $sizes[1]; $y++) |
|
1030
|
|
|
{ |
|
1031
|
|
|
imagecopy($new, $image, 0, $y, 0, $sizes[1] - $y - 1, $sizes[0], 1); |
|
1032
|
|
|
} |
|
1033
|
|
|
} |
|
1034
|
|
|
else |
|
1035
|
|
|
{ |
|
1036
|
|
|
for ($x = 0; $x < $sizes[0]; $x++) |
|
1037
|
|
|
{ |
|
1038
|
|
|
imagecopy($new, $image, $x, 0, $sizes[0] - $x - 1, 0, 1, $sizes[1]); |
|
1039
|
|
|
} |
|
1040
|
|
|
} |
|
1041
|
|
|
|
|
1042
|
|
|
$image = $new; |
|
1043
|
|
|
unset($new); |
|
1044
|
|
|
} |
|
1045
|
|
|
|
|
1046
|
|
|
return $image; |
|
|
|
|
|
|
1047
|
|
|
} |
|
1048
|
|
|
|
|
1049
|
|
|
/** |
|
1050
|
|
|
* Copy / resize an image using GD bicubic methods |
|
1051
|
|
|
* |
|
1052
|
|
|
* What it does: |
|
1053
|
|
|
* |
|
1054
|
|
|
* - Used when imagecopyresample() is not available |
|
1055
|
|
|
* - Uses bicubic resizing methods which are lower quality then imagecopyresample |
|
1056
|
|
|
* |
|
1057
|
|
|
* @package Graphics |
|
1058
|
|
|
* @param resource $dst_img The destination image - a GD image resource |
|
1059
|
|
|
* @param resource $src_img The source image - a GD image resource |
|
1060
|
|
|
* @param int $dst_x The "x" coordinate of the destination image |
|
1061
|
|
|
* @param int $dst_y The "y" coordinate of the destination image |
|
1062
|
|
|
* @param int $src_x The "x" coordinate of the source image |
|
1063
|
|
|
* @param int $src_y The "y" coordinate of the source image |
|
1064
|
|
|
* @param int $dst_w The width of the destination image |
|
1065
|
|
|
* @param int $dst_h The height of the destination image |
|
1066
|
|
|
* @param int $src_w The width of the destination image |
|
1067
|
|
|
* @param int $src_h The height of the destination image |
|
1068
|
|
|
*/ |
|
1069
|
|
|
function imagecopyresamplebicubic($dst_img, $src_img, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) |
|
1070
|
|
|
{ |
|
1071
|
|
|
$palsize = imagecolorstotal($src_img); |
|
1072
|
|
|
for ($i = 0; $i < $palsize; $i++) |
|
1073
|
|
|
{ |
|
1074
|
|
|
$colors = imagecolorsforindex($src_img, $i); |
|
1075
|
|
|
imagecolorallocate($dst_img, $colors['red'], $colors['green'], $colors['blue']); |
|
1076
|
|
|
} |
|
1077
|
|
|
|
|
1078
|
|
|
$scaleX = ($src_w - 1) / $dst_w; |
|
1079
|
|
|
$scaleY = ($src_h - 1) / $dst_h; |
|
1080
|
|
|
|
|
1081
|
|
|
$scaleX2 = (int) $scaleX / 2; |
|
1082
|
|
|
$scaleY2 = (int) $scaleY / 2; |
|
1083
|
|
|
|
|
1084
|
|
|
for ($j = $src_y; $j < $dst_h; $j++) |
|
1085
|
|
|
{ |
|
1086
|
|
|
$sY = (int) $j * $scaleY; |
|
1087
|
|
|
$y13 = $sY + $scaleY2; |
|
1088
|
|
|
|
|
1089
|
|
|
for ($i = $src_x; $i < $dst_w; $i++) |
|
1090
|
|
|
{ |
|
1091
|
|
|
$sX = (int) $i * $scaleX; |
|
1092
|
|
|
$x34 = $sX + $scaleX2; |
|
1093
|
|
|
|
|
1094
|
|
|
$color1 = imagecolorsforindex($src_img, imagecolorat($src_img, $sX, $y13)); |
|
1095
|
|
|
$color2 = imagecolorsforindex($src_img, imagecolorat($src_img, $sX, $sY)); |
|
1096
|
|
|
$color3 = imagecolorsforindex($src_img, imagecolorat($src_img, $x34, $y13)); |
|
1097
|
|
|
$color4 = imagecolorsforindex($src_img, imagecolorat($src_img, $x34, $sY)); |
|
1098
|
|
|
|
|
1099
|
|
|
$red = ($color1['red'] + $color2['red'] + $color3['red'] + $color4['red']) / 4; |
|
1100
|
|
|
$green = ($color1['green'] + $color2['green'] + $color3['green'] + $color4['green']) / 4; |
|
1101
|
|
|
$blue = ($color1['blue'] + $color2['blue'] + $color3['blue'] + $color4['blue']) / 4; |
|
1102
|
|
|
|
|
1103
|
|
|
$color = imagecolorresolve($dst_img, $red, $green, $blue); |
|
1104
|
|
|
if ($color == -1) |
|
1105
|
|
|
{ |
|
1106
|
|
|
if ($palsize++ < 256) |
|
1107
|
|
|
imagecolorallocate($dst_img, $red, $green, $blue); |
|
1108
|
|
|
$color = imagecolorclosest($dst_img, $red, $green, $blue); |
|
1109
|
|
|
} |
|
1110
|
|
|
|
|
1111
|
|
|
imagesetpixel($dst_img, $i + $dst_x - $src_x, $j + $dst_y - $src_y, $color); |
|
1112
|
|
|
} |
|
1113
|
|
|
} |
|
1114
|
|
|
} |
|
1115
|
|
|
|
|
1116
|
|
|
if (!function_exists('imagecreatefrombmp')) |
|
1117
|
|
|
{ |
|
1118
|
|
|
/** |
|
1119
|
|
|
* It is set only if it doesn't already exist (for forwards compatibility.) |
|
1120
|
|
|
* |
|
1121
|
|
|
* What it does: |
|
1122
|
|
|
* |
|
1123
|
|
|
* - It only supports uncompressed bitmaps. |
|
1124
|
|
|
* - It only supports standard windows bitmaps (no os/2 variants) |
|
1125
|
|
|
* - Returns an image identifier representing the bitmap image |
|
1126
|
|
|
* obtained from the given filename. |
|
1127
|
|
|
* |
|
1128
|
|
|
* @package Graphics |
|
1129
|
|
|
* @param string $filename The name of the file |
|
1130
|
|
|
* @return resource An image identifier representing the bitmap image |
|
1131
|
|
|
*/ |
|
1132
|
|
|
function imagecreatefrombmp($filename) |
|
1133
|
|
|
{ |
|
1134
|
|
|
global $gd2; |
|
1135
|
|
|
|
|
1136
|
|
|
$fp = fopen($filename, 'rb'); |
|
1137
|
|
|
|
|
1138
|
|
|
$errors = error_reporting(0); |
|
1139
|
|
|
|
|
1140
|
|
|
// Unpack the general information about the Bitmap Image File, first 14 Bytes |
|
1141
|
|
|
$header = unpack('vtype/Vsize/Vreserved/Voffset', fread($fp, 14)); |
|
1142
|
|
|
|
|
1143
|
|
|
// Unpack the DIB header, it stores detailed information about the bitmap image the pixel format, 40 Bytes long |
|
1144
|
|
|
$info = unpack('Vsize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vncolor/Vcolorimportant', fread($fp, 40)); |
|
1145
|
|
|
|
|
1146
|
|
|
// Not a standard bitmap, bail out |
|
1147
|
|
|
if ($header['type'] != 0x4D42) |
|
1148
|
|
|
return false; |
|
|
|
|
|
|
1149
|
|
|
|
|
1150
|
|
|
// Create our image canvas with the given WxH |
|
1151
|
|
|
if ($gd2) |
|
1152
|
|
|
$dst_img = imagecreatetruecolor($info['width'], $info['height']); |
|
1153
|
|
|
else |
|
1154
|
|
|
$dst_img = imagecreate($info['width'], $info['height']); |
|
1155
|
|
|
|
|
1156
|
|
|
// Color bitCounts 1,4,8 have palette information we use |
|
1157
|
|
|
$palette = array(); |
|
1158
|
|
|
if ($info['bits'] == 1 || $info['bits'] == 4 || $info['bits'] == 8) |
|
1159
|
|
|
{ |
|
1160
|
|
|
$palette_size = $header['offset'] - 54; |
|
1161
|
|
|
|
|
1162
|
|
|
// Read the palette data |
|
1163
|
|
|
$palettedata = fread($fp, $palette_size); |
|
1164
|
|
|
|
|
1165
|
|
|
// Create the rgb color array |
|
1166
|
|
|
$n = 0; |
|
1167
|
|
|
for ($j = 0; $j < $palette_size; $j++) |
|
1168
|
|
|
{ |
|
1169
|
|
|
$b = ord($palettedata[$j++]); |
|
1170
|
|
|
$g = ord($palettedata[$j++]); |
|
1171
|
|
|
$r = ord($palettedata[$j++]); |
|
1172
|
|
|
|
|
1173
|
|
|
$palette[$n++] = imagecolorallocate($dst_img, $r, $g, $b); |
|
1174
|
|
|
} |
|
1175
|
|
|
} |
|
1176
|
|
|
|
|
1177
|
|
|
$scan_line_size = ($info['bits'] * $info['width'] + 7) >> 3; |
|
1178
|
|
|
$scan_line_align = $scan_line_size & 3 ? 4 - ($scan_line_size & 3) : 0; |
|
1179
|
|
|
|
|
1180
|
|
|
for ($y = 0, $l = $info['height'] - 1; $y < $info['height']; $y++, $l--) |
|
1181
|
|
|
{ |
|
1182
|
|
|
fseek($fp, $header['offset'] + ($scan_line_size + $scan_line_align) * $l); |
|
1183
|
|
|
$scan_line = fread($fp, $scan_line_size); |
|
1184
|
|
|
|
|
1185
|
|
|
if (strlen($scan_line) < $scan_line_size) |
|
1186
|
|
|
continue; |
|
1187
|
|
|
|
|
1188
|
|
|
// 32 bits per pixel |
|
1189
|
|
|
if ($info['bits'] == 32) |
|
1190
|
|
|
{ |
|
1191
|
|
|
$x = 0; |
|
1192
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1193
|
|
|
{ |
|
1194
|
|
|
$b = ord($scan_line[$j++]); |
|
1195
|
|
|
$g = ord($scan_line[$j++]); |
|
1196
|
|
|
$r = ord($scan_line[$j++]); |
|
1197
|
|
|
$j++; |
|
1198
|
|
|
|
|
1199
|
|
|
$color = imagecolorexact($dst_img, $r, $g, $b); |
|
1200
|
|
|
if ($color == -1) |
|
1201
|
|
|
{ |
|
1202
|
|
|
$color = imagecolorallocate($dst_img, $r, $g, $b); |
|
1203
|
|
|
|
|
1204
|
|
|
// Gah! Out of colors? Stupid GD 1... try anyhow. |
|
1205
|
|
|
if ($color == -1) |
|
1206
|
|
|
$color = imagecolorclosest($dst_img, $r, $g, $b); |
|
1207
|
|
|
} |
|
1208
|
|
|
|
|
1209
|
|
|
imagesetpixel($dst_img, $x, $y, $color); |
|
1210
|
|
|
} |
|
1211
|
|
|
} |
|
1212
|
|
|
// 24 bits per pixel |
|
1213
|
|
|
elseif ($info['bits'] == 24) |
|
1214
|
|
|
{ |
|
1215
|
|
|
$x = 0; |
|
1216
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1217
|
|
|
{ |
|
1218
|
|
|
$b = ord($scan_line[$j++]); |
|
1219
|
|
|
$g = ord($scan_line[$j++]); |
|
1220
|
|
|
$r = ord($scan_line[$j++]); |
|
1221
|
|
|
|
|
1222
|
|
|
$color = imagecolorexact($dst_img, $r, $g, $b); |
|
1223
|
|
|
if ($color == -1) |
|
1224
|
|
|
{ |
|
1225
|
|
|
$color = imagecolorallocate($dst_img, $r, $g, $b); |
|
1226
|
|
|
|
|
1227
|
|
|
// Gah! Out of colors? Stupid GD 1... try anyhow. |
|
1228
|
|
|
if ($color == -1) |
|
1229
|
|
|
$color = imagecolorclosest($dst_img, $r, $g, $b); |
|
1230
|
|
|
} |
|
1231
|
|
|
|
|
1232
|
|
|
imagesetpixel($dst_img, $x, $y, $color); |
|
1233
|
|
|
} |
|
1234
|
|
|
} |
|
1235
|
|
|
// 16 bits per pixel |
|
1236
|
|
|
elseif ($info['bits'] == 16) |
|
1237
|
|
|
{ |
|
1238
|
|
|
$x = 0; |
|
1239
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1240
|
|
|
{ |
|
1241
|
|
|
$b1 = ord($scan_line[$j++]); |
|
1242
|
|
|
$b2 = ord($scan_line[$j++]); |
|
1243
|
|
|
|
|
1244
|
|
|
$word = $b2 * 256 + $b1; |
|
1245
|
|
|
|
|
1246
|
|
|
$b = (($word & 31) * 255) / 31; |
|
1247
|
|
|
$g = ((($word >> 5) & 31) * 255) / 31; |
|
1248
|
|
|
$r = ((($word >> 10) & 31) * 255) / 31; |
|
1249
|
|
|
|
|
1250
|
|
|
// Scale the image colors up properly. |
|
1251
|
|
|
$color = imagecolorexact($dst_img, $r, $g, $b); |
|
1252
|
|
|
if ($color == -1) |
|
1253
|
|
|
{ |
|
1254
|
|
|
$color = imagecolorallocate($dst_img, $r, $g, $b); |
|
1255
|
|
|
|
|
1256
|
|
|
// Gah! Out of colors? Stupid GD 1... try anyhow. |
|
1257
|
|
|
if ($color == -1) |
|
1258
|
|
|
$color = imagecolorclosest($dst_img, $r, $g, $b); |
|
1259
|
|
|
} |
|
1260
|
|
|
|
|
1261
|
|
|
imagesetpixel($dst_img, $x, $y, $color); |
|
1262
|
|
|
} |
|
1263
|
|
|
} |
|
1264
|
|
|
// 8 bits per pixel |
|
1265
|
|
|
elseif ($info['bits'] == 8) |
|
1266
|
|
|
{ |
|
1267
|
|
|
$x = 0; |
|
1268
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1269
|
|
|
imagesetpixel($dst_img, $x, $y, $palette[ord($scan_line[$j++])]); |
|
1270
|
|
|
} |
|
1271
|
|
|
// 4 bits per pixel |
|
1272
|
|
|
elseif ($info['bits'] == 4) |
|
1273
|
|
|
{ |
|
1274
|
|
|
$x = 0; |
|
1275
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1276
|
|
|
{ |
|
1277
|
|
|
$byte = ord($scan_line[$j++]); |
|
1278
|
|
|
|
|
1279
|
|
|
imagesetpixel($dst_img, $x, $y, $palette[(int) ($byte / 16)]); |
|
1280
|
|
|
if (++$x < $info['width']) |
|
1281
|
|
|
imagesetpixel($dst_img, $x, $y, $palette[$byte & 15]); |
|
1282
|
|
|
} |
|
1283
|
|
|
} |
|
1284
|
|
|
// 1 bit |
|
1285
|
|
|
elseif ($info['bits'] == 1) |
|
1286
|
|
|
{ |
|
1287
|
|
|
$x = 0; |
|
1288
|
|
|
for ($j = 0; $j < $scan_line_size; $x++) |
|
1289
|
|
|
{ |
|
1290
|
|
|
$byte = ord($scan_line[$j++]); |
|
1291
|
|
|
|
|
1292
|
|
|
imagesetpixel($dst_img, $x, $y, $palette[(($byte) & 128) != 0]); |
|
1293
|
|
|
for ($shift = 1; $shift < 8; $shift++) |
|
1294
|
|
|
{ |
|
1295
|
|
|
if (++$x < $info['width']) |
|
1296
|
|
|
imagesetpixel($dst_img, $x, $y, $palette[(($byte << $shift) & 128) != 0]); |
|
1297
|
|
|
} |
|
1298
|
|
|
} |
|
1299
|
|
|
} |
|
1300
|
|
|
} |
|
1301
|
|
|
|
|
1302
|
|
|
fclose($fp); |
|
1303
|
|
|
|
|
1304
|
|
|
error_reporting($errors); |
|
1305
|
|
|
|
|
1306
|
|
|
return $dst_img; |
|
|
|
|
|
|
1307
|
|
|
} |
|
1308
|
|
|
} |
|
1309
|
|
|
|
|
1310
|
|
|
/** |
|
1311
|
|
|
* Show an image containing the visual verification code for registration. |
|
1312
|
|
|
* |
|
1313
|
|
|
* What it does: |
|
1314
|
|
|
* |
|
1315
|
|
|
* - Requires the GD extension. |
|
1316
|
|
|
* - Uses a random font for each letter from default_theme_dir/fonts. |
|
1317
|
|
|
* - Outputs a png if possible, otherwise a gif. |
|
1318
|
|
|
* |
|
1319
|
|
|
* @package Graphics |
|
1320
|
|
|
* @param string $code The code to display |
|
1321
|
|
|
* |
|
1322
|
|
|
* @return false|null false if something goes wrong. |
|
1323
|
|
|
*/ |
|
1324
|
|
|
function showCodeImage($code) |
|
1325
|
|
|
{ |
|
1326
|
|
|
global $gd2, $settings, $user_info, $modSettings; |
|
1327
|
|
|
|
|
1328
|
|
|
if (!checkGD()) |
|
1329
|
|
|
return false; |
|
1330
|
|
|
|
|
1331
|
|
|
// What type are we going to be doing? |
|
1332
|
|
|
// Note: The higher the value of visual_verification_type the harder the verification is |
|
1333
|
|
|
// from 0 as disabled through to 4 as "Very hard". |
|
1334
|
|
|
$imageType = $modSettings['visual_verification_type']; |
|
1335
|
|
|
|
|
1336
|
|
|
// Special case to allow the admin center to show samples. |
|
1337
|
|
|
if ($user_info['is_admin'] && isset($_GET['type'])) |
|
1338
|
|
|
$imageType = (int) $_GET['type']; |
|
1339
|
|
|
|
|
1340
|
|
|
// Some quick references for what we do. |
|
1341
|
|
|
// Do we show no, low or high noise? |
|
1342
|
|
|
$noiseType = $imageType == 3 ? 'low' : ($imageType == 4 ? 'high' : ($imageType == 5 ? 'extreme' : 'none')); |
|
1343
|
|
|
// Can we have more than one font in use? |
|
1344
|
|
|
$varyFonts = $imageType > 1 ? true : false; |
|
1345
|
|
|
// Just a plain white background? |
|
1346
|
|
|
$simpleBGColor = $imageType < 3 ? true : false; |
|
1347
|
|
|
// Plain black foreground? |
|
1348
|
|
|
$simpleFGColor = $imageType == 0 ? true : false; |
|
1349
|
|
|
// High much to rotate each character. |
|
1350
|
|
|
$rotationType = $imageType == 1 ? 'none' : ($imageType > 3 ? 'low' : 'high'); |
|
1351
|
|
|
// Do we show some characters inverse? |
|
1352
|
|
|
$showReverseChars = $imageType > 3 ? true : false; |
|
1353
|
|
|
// Special case for not showing any characters. |
|
1354
|
|
|
$disableChars = $imageType == 0 ? true : false; |
|
1355
|
|
|
// What do we do with the font colors. Are they one color, close to one color or random? |
|
1356
|
|
|
$fontColorType = $imageType == 1 ? 'plain' : ($imageType > 3 ? 'random' : 'cyclic'); |
|
1357
|
|
|
// Are the fonts random sizes? |
|
1358
|
|
|
$fontSizeRandom = $imageType > 3 ? true : false; |
|
1359
|
|
|
// How much space between characters? |
|
1360
|
|
|
$fontHorSpace = $imageType > 3 ? 'high' : ($imageType == 1 ? 'medium' : 'minus'); |
|
1361
|
|
|
// Where do characters sit on the image? (Fixed position or random/very random) |
|
1362
|
|
|
$fontVerPos = $imageType == 1 ? 'fixed' : ($imageType > 3 ? 'vrandom' : 'random'); |
|
1363
|
|
|
// Make font semi-transparent? |
|
1364
|
|
|
$fontTrans = $imageType == 2 || $imageType == 3 ? true : false; |
|
1365
|
|
|
// Give the image a border? |
|
1366
|
|
|
$hasBorder = $simpleBGColor; |
|
1367
|
|
|
|
|
1368
|
|
|
// The amount of pixels in between characters. |
|
1369
|
|
|
$character_spacing = 1; |
|
1370
|
|
|
|
|
1371
|
|
|
// What color is the background - generally white unless we're on "hard". |
|
1372
|
|
|
if ($simpleBGColor) |
|
1373
|
|
|
$background_color = array(255, 255, 255); |
|
1374
|
|
|
else |
|
1375
|
|
|
$background_color = isset($settings['verification_background']) ? $settings['verification_background'] : array(236, 237, 243); |
|
1376
|
|
|
|
|
1377
|
|
|
// The color of the characters shown (red, green, blue). |
|
1378
|
|
|
if ($simpleFGColor) |
|
1379
|
|
|
$foreground_color = array(0, 0, 0); |
|
1380
|
|
|
else |
|
1381
|
|
|
{ |
|
1382
|
|
|
$foreground_color = array(64, 101, 136); |
|
1383
|
|
|
|
|
1384
|
|
|
// Has the theme author requested a custom color? |
|
1385
|
|
|
if (isset($settings['verification_foreground'])) |
|
1386
|
|
|
$foreground_color = $settings['verification_foreground']; |
|
1387
|
|
|
} |
|
1388
|
|
|
|
|
1389
|
|
|
if (!is_dir($settings['default_theme_dir'] . '/fonts')) |
|
1390
|
|
|
return false; |
|
1391
|
|
|
|
|
1392
|
|
|
// Can we use true type fonts? |
|
1393
|
|
|
$can_do_ttf = function_exists('imagettftext'); |
|
1394
|
|
|
|
|
1395
|
|
|
// Get a list of the available fonts. |
|
1396
|
|
|
$font_dir = dir($settings['default_theme_dir'] . '/fonts'); |
|
1397
|
|
|
$font_list = array(); |
|
1398
|
|
|
$ttfont_list = array(); |
|
1399
|
|
|
while ($entry = $font_dir->read()) |
|
1400
|
|
|
{ |
|
1401
|
|
|
if (preg_match('~^(.+)\.gdf$~', $entry, $matches) === 1) |
|
1402
|
|
|
$font_list[] = $entry; |
|
1403
|
|
|
elseif (preg_match('~^(.+)\.ttf$~', $entry, $matches) === 1) |
|
1404
|
|
|
$ttfont_list[] = $entry; |
|
1405
|
|
|
} |
|
1406
|
|
|
|
|
1407
|
|
|
if (empty($font_list) && ($can_do_ttf && empty($ttfont_list))) |
|
1408
|
|
|
return false; |
|
1409
|
|
|
|
|
1410
|
|
|
// For non-hard things don't even change fonts. |
|
1411
|
|
|
if (!$varyFonts) |
|
1412
|
|
|
{ |
|
1413
|
|
|
$font_list = !empty($font_list) ? array($font_list[0]) : $font_list; |
|
1414
|
|
|
|
|
1415
|
|
|
// Try use OpenSans if we can - it looks good! |
|
1416
|
|
|
if (in_array('OpenSans.ttf', $ttfont_list)) |
|
1417
|
|
|
$ttfont_list = array('OpenSans.ttf'); |
|
1418
|
|
|
else |
|
1419
|
|
|
$ttfont_list = empty($ttfont_list) ? array() : array($ttfont_list[0]); |
|
1420
|
|
|
} |
|
1421
|
|
|
|
|
1422
|
|
|
// Create a list of characters to be shown. |
|
1423
|
|
|
$characters = array(); |
|
1424
|
|
|
$loaded_fonts = array(); |
|
1425
|
|
|
$str_len = strlen($code); |
|
1426
|
|
|
for ($i = 0; $i < $str_len; $i++) |
|
1427
|
|
|
{ |
|
1428
|
|
|
$characters[$i] = array( |
|
1429
|
|
|
'id' => $code[$i], |
|
1430
|
|
|
'font' => array_rand($can_do_ttf ? $ttfont_list : $font_list), |
|
1431
|
|
|
); |
|
1432
|
|
|
|
|
1433
|
|
|
$loaded_fonts[$characters[$i]['font']] = null; |
|
1434
|
|
|
} |
|
1435
|
|
|
|
|
1436
|
|
|
// Load all fonts and determine the maximum font height. |
|
1437
|
|
|
if (!$can_do_ttf) |
|
1438
|
|
|
foreach ($loaded_fonts as $font_index => $dummy) |
|
1439
|
|
|
$loaded_fonts[$font_index] = imageloadfont($settings['default_theme_dir'] . '/fonts/' . $font_list[$font_index]); |
|
1440
|
|
|
|
|
1441
|
|
|
// Determine the dimensions of each character. |
|
1442
|
|
|
$extra = ($imageType == 4 || $imageType == 5) ? 80 : 45; |
|
1443
|
|
|
$total_width = $character_spacing * strlen($code) + $extra; |
|
1444
|
|
|
$max_height = 0; |
|
1445
|
|
|
foreach ($characters as $char_index => $character) |
|
1446
|
|
|
{ |
|
1447
|
|
|
if ($can_do_ttf) |
|
1448
|
|
|
{ |
|
1449
|
|
|
// GD2 handles font size differently. |
|
1450
|
|
|
if ($fontSizeRandom) |
|
1451
|
|
|
$font_size = $gd2 ? mt_rand(17, 19) : mt_rand(25, 27); |
|
1452
|
|
|
else |
|
1453
|
|
|
$font_size = $gd2 ? 17 : 27; |
|
1454
|
|
|
|
|
1455
|
|
|
$img_box = imagettfbbox($font_size, 0, $settings['default_theme_dir'] . '/fonts/' . $ttfont_list[$character['font']], $character['id']); |
|
1456
|
|
|
|
|
1457
|
|
|
$characters[$char_index]['width'] = abs($img_box[2] - $img_box[0]); |
|
1458
|
|
|
$characters[$char_index]['height'] = abs(max($img_box[1] - $img_box[7], $img_box[5] - $img_box[3])); |
|
1459
|
|
|
} |
|
1460
|
|
|
else |
|
1461
|
|
|
{ |
|
1462
|
|
|
$characters[$char_index]['width'] = imagefontwidth($loaded_fonts[$character['font']]); |
|
1463
|
|
|
$characters[$char_index]['height'] = imagefontheight($loaded_fonts[$character['font']]); |
|
1464
|
|
|
} |
|
1465
|
|
|
|
|
1466
|
|
|
$max_height = max($characters[$char_index]['height'] + 10, $max_height); |
|
1467
|
|
|
$total_width += $characters[$char_index]['width']; |
|
1468
|
|
|
} |
|
1469
|
|
|
|
|
1470
|
|
|
// Create an image. |
|
1471
|
|
|
$code_image = $gd2 ? imagecreatetruecolor($total_width, $max_height) : imagecreate($total_width, $max_height); |
|
1472
|
|
|
|
|
1473
|
|
|
// Draw the background. |
|
1474
|
|
|
$bg_color = imagecolorallocate($code_image, $background_color[0], $background_color[1], $background_color[2]); |
|
1475
|
|
|
imagefilledrectangle($code_image, 0, 0, $total_width - 1, $max_height - 1, $bg_color); |
|
1476
|
|
|
|
|
1477
|
|
|
// Randomize the foreground color a little. |
|
1478
|
|
|
for ($i = 0; $i < 3; $i++) |
|
1479
|
|
|
$foreground_color[$i] = mt_rand(max($foreground_color[$i] - 3, 0), min($foreground_color[$i] + 3, 255)); |
|
1480
|
|
|
$fg_color = imagecolorallocate($code_image, $foreground_color[0], $foreground_color[1], $foreground_color[2]); |
|
1481
|
|
|
|
|
1482
|
|
|
// Color for the noise dots. |
|
1483
|
|
|
$dotbgcolor = array(); |
|
1484
|
|
|
for ($i = 0; $i < 3; $i++) |
|
1485
|
|
|
$dotbgcolor[$i] = $background_color[$i] < $foreground_color[$i] ? mt_rand(0, max($foreground_color[$i] - 20, 0)) : mt_rand(min($foreground_color[$i] + 20, 255), 255); |
|
1486
|
|
|
$randomness_color = imagecolorallocate($code_image, $dotbgcolor[0], $dotbgcolor[1], $dotbgcolor[2]); |
|
1487
|
|
|
|
|
1488
|
|
|
// Some squares/rectangles for new extreme level |
|
1489
|
|
|
if ($noiseType == 'extreme') |
|
1490
|
|
|
{ |
|
1491
|
|
|
$width4 = (int) ($total_width / 4); |
|
1492
|
|
|
$height3 = (int) ($max_height / 3); |
|
1493
|
|
|
for ($i = 0; $i < mt_rand(1, 5); $i++) |
|
1494
|
|
|
{ |
|
1495
|
|
|
$x1 = mt_rand(0, $width4); |
|
1496
|
|
|
$x2 = $x1 + mt_rand($width4, $total_width); |
|
1497
|
|
|
$y1 = mt_rand(0, $max_height); |
|
1498
|
|
|
$y2 = $y1 + mt_rand(0, $height3); |
|
1499
|
|
|
imagefilledrectangle($code_image, $x1, $y1, $x2, $y2, mt_rand(0, 1) ? $fg_color : $randomness_color); |
|
1500
|
|
|
} |
|
1501
|
|
|
} |
|
1502
|
|
|
|
|
1503
|
|
|
// Fill in the characters. |
|
1504
|
|
|
if (!$disableChars) |
|
1505
|
|
|
{ |
|
1506
|
|
|
$cur_x = 0; |
|
1507
|
|
|
$last_index = -1; |
|
1508
|
|
|
foreach ($characters as $char_index => $character) |
|
1509
|
|
|
{ |
|
1510
|
|
|
// How much rotation will we give? |
|
1511
|
|
|
if ($rotationType == 'none') |
|
1512
|
|
|
$angle = 0; |
|
1513
|
|
|
else |
|
1514
|
|
|
$angle = mt_rand(-100, 100) / ($rotationType == 'high' ? 6 : 10); |
|
1515
|
|
|
|
|
1516
|
|
|
// What color shall we do it? |
|
1517
|
|
|
if ($fontColorType == 'cyclic') |
|
1518
|
|
|
{ |
|
1519
|
|
|
// Here we'll pick from a set of acceptance types. |
|
1520
|
|
|
$colors = array( |
|
1521
|
|
|
array(10, 120, 95), |
|
1522
|
|
|
array(46, 81, 29), |
|
1523
|
|
|
array(4, 22, 154), |
|
1524
|
|
|
array(131, 9, 130), |
|
1525
|
|
|
array(0, 0, 0), |
|
1526
|
|
|
array(143, 39, 31), |
|
1527
|
|
|
); |
|
1528
|
|
|
|
|
1529
|
|
|
// Pick a color, but not the same one twice in a row |
|
1530
|
|
|
$new_index = $last_index; |
|
1531
|
|
|
while ($last_index == $new_index) |
|
1532
|
|
|
$new_index = mt_rand(0, count($colors) - 1); |
|
1533
|
|
|
$char_fg_color = $colors[$new_index]; |
|
1534
|
|
|
$last_index = $new_index; |
|
1535
|
|
|
} |
|
1536
|
|
|
elseif ($fontColorType == 'random') |
|
1537
|
|
|
$char_fg_color = array(mt_rand(max($foreground_color[0] - 2, 0), $foreground_color[0]), mt_rand(max($foreground_color[1] - 2, 0), $foreground_color[1]), mt_rand(max($foreground_color[2] - 2, 0), $foreground_color[2])); |
|
1538
|
|
|
else |
|
1539
|
|
|
$char_fg_color = array($foreground_color[0], $foreground_color[1], $foreground_color[2]); |
|
1540
|
|
|
|
|
1541
|
|
|
if (!empty($can_do_ttf)) |
|
1542
|
|
|
{ |
|
1543
|
|
|
// GD2 handles font size differently. |
|
1544
|
|
|
if ($fontSizeRandom) |
|
1545
|
|
|
$font_size = $gd2 ? mt_rand(17, 19) : mt_rand(18, 25); |
|
1546
|
|
|
else |
|
1547
|
|
|
$font_size = $gd2 ? 18 : 24; |
|
1548
|
|
|
|
|
1549
|
|
|
// Work out the sizes - also fix the character width cause TTF not quite so wide! |
|
1550
|
|
|
$font_x = $fontHorSpace === 'minus' && $cur_x > 0 ? $cur_x - 3 : $cur_x + 5; |
|
1551
|
|
|
$font_y = $max_height - ($fontVerPos === 'vrandom' ? mt_rand(2, 8) : ($fontVerPos === 'random' ? mt_rand(3, 5) : 5)); |
|
1552
|
|
|
|
|
1553
|
|
|
// What font face? |
|
1554
|
|
|
if (!empty($ttfont_list)) |
|
1555
|
|
|
$fontface = $settings['default_theme_dir'] . '/fonts/' . $ttfont_list[mt_rand(0, count($ttfont_list) - 1)]; |
|
1556
|
|
|
|
|
1557
|
|
|
// What color are we to do it in? |
|
1558
|
|
|
$is_reverse = $showReverseChars ? mt_rand(0, 1) : false; |
|
1559
|
|
|
$char_color = $fontTrans ? imagecolorallocatealpha($code_image, $char_fg_color[0], $char_fg_color[1], $char_fg_color[2], 50) : imagecolorallocate($code_image, $char_fg_color[0], $char_fg_color[1], $char_fg_color[2]); |
|
1560
|
|
|
|
|
1561
|
|
|
$fontcord = @imagettftext($code_image, $font_size, $angle, $font_x, $font_y, $char_color, $fontface, $character['id']); |
|
|
|
|
|
|
1562
|
|
|
if (empty($fontcord)) |
|
1563
|
|
|
$can_do_ttf = false; |
|
1564
|
|
|
elseif ($is_reverse !== false) |
|
1565
|
|
|
{ |
|
1566
|
|
|
if (version_compare(PHP_VERSION, '8.1.0') === -1) |
|
1567
|
|
|
imagefilledpolygon($code_image, $fontcord, 4, $fg_color); |
|
1568
|
|
|
else |
|
1569
|
|
|
imagefilledpolygon($code_image, $fontcord, $fg_color); |
|
|
|
|
|
|
1570
|
|
|
|
|
1571
|
|
|
// Put the character back! |
|
1572
|
|
|
imagettftext($code_image, $font_size, $angle, $font_x, $font_y, $randomness_color, $fontface, $character['id']); |
|
1573
|
|
|
} |
|
1574
|
|
|
|
|
1575
|
|
|
if ($can_do_ttf) |
|
1576
|
|
|
$cur_x = max($fontcord[2], $fontcord[4]) + ($angle == 0 ? 0 : 3); |
|
1577
|
|
|
} |
|
1578
|
|
|
|
|
1579
|
|
|
if (!$can_do_ttf) |
|
1580
|
|
|
{ |
|
1581
|
|
|
$char_image = $gd2 ? imagecreatetruecolor($character['width'], $character['height']) : imagecreate($character['width'], $character['height']); |
|
1582
|
|
|
$char_bgcolor = imagecolorallocate($char_image, $background_color[0], $background_color[1], $background_color[2]); |
|
1583
|
|
|
imagefilledrectangle($char_image, 0, 0, $character['width'] - 1, $character['height'] - 1, $char_bgcolor); |
|
1584
|
|
|
imagechar($char_image, $loaded_fonts[$character['font']], 0, 0, $character['id'], imagecolorallocate($char_image, $char_fg_color[0], $char_fg_color[1], $char_fg_color[2])); |
|
1585
|
|
|
$rotated_char = imagerotate($char_image, mt_rand(-100, 100) / 10, $char_bgcolor); |
|
1586
|
|
|
imagecopy($code_image, $rotated_char, $cur_x, 0, 0, 0, $character['width'], $character['height']); |
|
1587
|
|
|
imagedestroy($rotated_char); |
|
1588
|
|
|
imagedestroy($char_image); |
|
1589
|
|
|
|
|
1590
|
|
|
$cur_x += $character['width'] + $character_spacing; |
|
1591
|
|
|
} |
|
1592
|
|
|
} |
|
1593
|
|
|
} |
|
1594
|
|
|
// If disabled just show a cross. |
|
1595
|
|
|
else |
|
1596
|
|
|
{ |
|
1597
|
|
|
imageline($code_image, 0, 0, $total_width, $max_height, $fg_color); |
|
1598
|
|
|
imageline($code_image, 0, $max_height, $total_width, 0, $fg_color); |
|
1599
|
|
|
} |
|
1600
|
|
|
|
|
1601
|
|
|
// Make the background color transparent on the hard image. |
|
1602
|
|
|
if (!$simpleBGColor) |
|
1603
|
|
|
imagecolortransparent($code_image, $bg_color); |
|
1604
|
|
|
|
|
1605
|
|
|
if ($hasBorder) |
|
1606
|
|
|
imagerectangle($code_image, 0, 0, $total_width - 1, $max_height - 1, $fg_color); |
|
1607
|
|
|
|
|
1608
|
|
|
// Add some noise to the background? |
|
1609
|
|
|
if ($noiseType != 'none') |
|
1610
|
|
|
{ |
|
1611
|
|
|
for ($i = mt_rand(0, 2); $i < $max_height; $i += mt_rand(1, 2)) |
|
1612
|
|
|
for ($j = mt_rand(0, 10); $j < $total_width; $j += mt_rand(1, 10)) |
|
1613
|
|
|
imagesetpixel($code_image, $j, $i, mt_rand(0, 1) ? $fg_color : $randomness_color); |
|
1614
|
|
|
|
|
1615
|
|
|
// Put in some lines too? |
|
1616
|
|
|
if ($noiseType != 'extreme') |
|
1617
|
|
|
{ |
|
1618
|
|
|
$num_lines = $noiseType == 'high' ? mt_rand(3, 7) : mt_rand(2, 5); |
|
1619
|
|
|
for ($i = 0; $i < $num_lines; $i++) |
|
1620
|
|
|
{ |
|
1621
|
|
|
if (mt_rand(0, 1)) |
|
1622
|
|
|
{ |
|
1623
|
|
|
$x1 = mt_rand(0, $total_width); |
|
1624
|
|
|
$x2 = mt_rand(0, $total_width); |
|
1625
|
|
|
$y1 = 0; |
|
1626
|
|
|
$y2 = $max_height; |
|
1627
|
|
|
} |
|
1628
|
|
|
else |
|
1629
|
|
|
{ |
|
1630
|
|
|
$y1 = mt_rand(0, $max_height); |
|
1631
|
|
|
$y2 = mt_rand(0, $max_height); |
|
1632
|
|
|
$x1 = 0; |
|
1633
|
|
|
$x2 = $total_width; |
|
1634
|
|
|
} |
|
1635
|
|
|
imagesetthickness($code_image, mt_rand(1, 2)); |
|
1636
|
|
|
imageline($code_image, $x1, $y1, $x2, $y2, mt_rand(0, 1) ? $fg_color : $randomness_color); |
|
1637
|
|
|
} |
|
1638
|
|
|
} |
|
1639
|
|
|
else |
|
1640
|
|
|
{ |
|
1641
|
|
|
// Put in some ellipse |
|
1642
|
|
|
$num_ellipse = $noiseType == 'extreme' ? mt_rand(6, 12) : mt_rand(2, 6); |
|
1643
|
|
|
$width4 = (int) ($total_width / 4); |
|
1644
|
|
|
$width2 = (int) ($total_width / 2); |
|
1645
|
|
|
$height4 = (int) ($max_height / 4); |
|
1646
|
|
|
$height2 = (int) ($max_height / 2); |
|
1647
|
|
|
|
|
1648
|
|
|
for ($i = 0; $i < $num_ellipse; $i++) |
|
1649
|
|
|
{ |
|
1650
|
|
|
$x1 = mt_rand($width4 * -1, $total_width + $width4); |
|
1651
|
|
|
$x2 = mt_rand($width2, 2 * $total_width); |
|
1652
|
|
|
$y1 = mt_rand($height4 * -1, $max_height + $height4); |
|
1653
|
|
|
$y2 = mt_rand($height2, 2 * $max_height); |
|
1654
|
|
|
imageellipse($code_image, $x1, $y1, $x2, $y2, mt_rand(0, 1) ? $fg_color : $randomness_color); |
|
1655
|
|
|
} |
|
1656
|
|
|
} |
|
1657
|
|
|
} |
|
1658
|
|
|
|
|
1659
|
|
|
// Show the image. |
|
1660
|
|
|
if (function_exists('imagepng')) |
|
1661
|
|
|
{ |
|
1662
|
|
|
header('Content-type: image/png'); |
|
1663
|
|
|
imagepng($code_image); |
|
1664
|
|
|
} |
|
1665
|
|
|
else |
|
1666
|
|
|
{ |
|
1667
|
|
|
header('Content-type: image/gif'); |
|
1668
|
|
|
imagegif($code_image); |
|
1669
|
|
|
} |
|
1670
|
|
|
|
|
1671
|
|
|
// Bail out. |
|
1672
|
|
|
imagedestroy($code_image); |
|
1673
|
|
|
die(); |
|
|
|
|
|
|
1674
|
|
|
} |
|
1675
|
|
|
|
|
1676
|
|
|
/** |
|
1677
|
|
|
* Show a letter for the visual verification code. |
|
1678
|
|
|
* |
|
1679
|
|
|
* - Alternative function for showCodeImage() in case GD is missing. |
|
1680
|
|
|
* - Includes an image from a random sub directory of default_theme_dir/fonts. |
|
1681
|
|
|
* |
|
1682
|
|
|
* @package Graphics |
|
1683
|
|
|
* @param string $letter A letter to show as an image |
|
1684
|
|
|
* |
|
1685
|
|
|
* @return false|null false if something goes wrong. |
|
1686
|
|
|
*/ |
|
1687
|
|
|
function showLetterImage($letter) |
|
1688
|
|
|
{ |
|
1689
|
|
|
global $settings; |
|
1690
|
|
|
|
|
1691
|
|
|
if (!is_dir($settings['default_theme_dir'] . '/fonts')) |
|
1692
|
|
|
return false; |
|
1693
|
|
|
|
|
1694
|
|
|
// Get a list of the available font directories. |
|
1695
|
|
|
$font_dir = dir($settings['default_theme_dir'] . '/fonts'); |
|
1696
|
|
|
$font_list = array(); |
|
1697
|
|
|
while ($entry = $font_dir->read()) |
|
1698
|
|
|
if ($entry[0] !== '.' && is_dir($settings['default_theme_dir'] . '/fonts/' . $entry) && file_exists($settings['default_theme_dir'] . '/fonts/' . $entry . '.gdf')) |
|
1699
|
|
|
$font_list[] = $entry; |
|
1700
|
|
|
|
|
1701
|
|
|
if (empty($font_list)) |
|
1702
|
|
|
return false; |
|
1703
|
|
|
|
|
1704
|
|
|
// Pick a random font. |
|
1705
|
|
|
$random_font = $font_list[array_rand($font_list)]; |
|
1706
|
|
|
|
|
1707
|
|
|
// Check if the given letter exists. |
|
1708
|
|
|
if (!file_exists($settings['default_theme_dir'] . '/fonts/' . $random_font . '/' . $letter . '.gif')) |
|
1709
|
|
|
return false; |
|
1710
|
|
|
|
|
1711
|
|
|
// Include it! |
|
1712
|
|
|
header('Content-type: image/gif'); |
|
1713
|
|
|
include($settings['default_theme_dir'] . '/fonts/' . $random_font . '/' . $letter . '.gif'); |
|
1714
|
|
|
|
|
1715
|
|
|
// Nothing more to come. |
|
1716
|
|
|
die(); |
|
|
|
|
|
|
1717
|
|
|
} |
|
1718
|
|
|
|
|
1719
|
|
|
/** |
|
1720
|
|
|
* Simple function to generate an image containing some text. |
|
1721
|
|
|
* It uses preferentially Imagick if present, otherwise GD. |
|
1722
|
|
|
* Font and size are fixed. |
|
1723
|
|
|
* |
|
1724
|
|
|
* @package Graphics |
|
1725
|
|
|
* |
|
1726
|
|
|
* @param string $text The text the image should contain |
|
1727
|
|
|
* @param int $width Width of the final image |
|
1728
|
|
|
* @param int $height Height of the image |
|
1729
|
|
|
* @param string $format Type of the image (valid types are png, jpeg, gif) |
|
1730
|
|
|
* |
|
1731
|
|
|
* @return boolean|resource The image or false if neither Imagick nor GD are found |
|
1732
|
|
|
*/ |
|
1733
|
|
|
function generateTextImage($text, $width = 100, $height = 100, $format = 'png') |
|
1734
|
|
|
{ |
|
1735
|
|
|
$valid_formats = array('jpeg', 'png', 'gif'); |
|
1736
|
|
|
if (!in_array($format, $valid_formats)) |
|
1737
|
|
|
{ |
|
1738
|
|
|
$format = 'png'; |
|
1739
|
|
|
} |
|
1740
|
|
|
|
|
1741
|
|
|
if (checkImagick() === true) |
|
1742
|
|
|
{ |
|
1743
|
|
|
return generateTextImageWithIM($text, $width, $height, $format); |
|
1744
|
|
|
} |
|
1745
|
|
|
elseif (checkGD() === true) |
|
1746
|
|
|
{ |
|
1747
|
|
|
return generateTextImageWithGD($text, $width, $height, $format); |
|
1748
|
|
|
} |
|
1749
|
|
|
else |
|
1750
|
|
|
{ |
|
1751
|
|
|
return false; |
|
1752
|
|
|
} |
|
1753
|
|
|
} |
|
1754
|
|
|
|
|
1755
|
|
|
/** |
|
1756
|
|
|
* Simple function to generate an image containing some text. |
|
1757
|
|
|
* It uses preferentially Imagick if present, otherwise GD. |
|
1758
|
|
|
* Font and size are fixed. |
|
1759
|
|
|
* |
|
1760
|
|
|
* @uses GD |
|
1761
|
|
|
* |
|
1762
|
|
|
* @package Graphics |
|
1763
|
|
|
* |
|
1764
|
|
|
* @param string $text The text the image should contain |
|
1765
|
|
|
* @param int $width Width of the final image |
|
1766
|
|
|
* @param int $height Height of the image |
|
1767
|
|
|
* @param string $format Type of the image (valid types are png, jpeg, gif) |
|
1768
|
|
|
* |
|
1769
|
|
|
* @return resource|boolean The image |
|
1770
|
|
|
*/ |
|
1771
|
|
|
function generateTextImageWithGD($text, $width = 100, $height = 100, $format = 'png') |
|
1772
|
|
|
{ |
|
1773
|
|
|
global $settings; |
|
1774
|
|
|
|
|
1775
|
|
|
$create_function = 'image' . $format; |
|
1776
|
|
|
|
|
1777
|
|
|
// Create a white filled box |
|
1778
|
|
|
$image = imagecreate($width, $height); |
|
1779
|
|
|
imagecolorallocate($image, 255, 255, 255); |
|
1780
|
|
|
|
|
1781
|
|
|
$text_color = imagecolorallocate($image, 0, 0, 0); |
|
1782
|
|
|
$font = $settings['default_theme_dir'] . '/fonts/VDS_New.ttf'; |
|
1783
|
|
|
|
|
1784
|
|
|
// The loop is to try to fit the text into the image. |
|
1785
|
|
|
$true_type = function_exists('imagettftext'); |
|
1786
|
|
|
$font_size = $true_type ? 28 : 5; |
|
1787
|
|
|
do |
|
1788
|
|
|
{ |
|
1789
|
|
|
if ($true_type) |
|
1790
|
|
|
{ |
|
1791
|
|
|
$metric = imagettfbbox($font_size, 0, $font, $text); |
|
1792
|
|
|
$text_width = abs($metric[4] - $metric[0]); |
|
1793
|
|
|
$text_height = abs($metric[5] - $metric[1]); |
|
1794
|
|
|
$text_offset = $metric[7]; |
|
1795
|
|
|
} |
|
1796
|
|
|
else |
|
1797
|
|
|
{ |
|
1798
|
|
|
$text_width = imagefontwidth($font_size) * strlen($text); |
|
1799
|
|
|
$text_height = imagefontheight($font_size); |
|
1800
|
|
|
} |
|
1801
|
|
|
} while ($text_width > $width && $font_size-- > 1); |
|
1802
|
|
|
|
|
1803
|
|
|
$w_offset = floor(($width - $text_width) / 2); |
|
1804
|
|
|
$h_offset = floor(($height - $text_height) / 2); |
|
1805
|
|
|
$h_offset = $true_type ? $h_offset - $text_offset : $h_offset; |
|
|
|
|
|
|
1806
|
|
|
|
|
1807
|
|
|
if ($true_type) |
|
1808
|
|
|
{ |
|
1809
|
|
|
imagettftext($image, $font_size, 0, $w_offset, $h_offset, $text_color, $font, $text); |
|
|
|
|
|
|
1810
|
|
|
} |
|
1811
|
|
|
else |
|
1812
|
|
|
{ |
|
1813
|
|
|
imagestring($image, $font_size, $w_offset, $h_offset, $text, $text_color); |
|
|
|
|
|
|
1814
|
|
|
} |
|
1815
|
|
|
|
|
1816
|
|
|
// Capture the image string |
|
1817
|
|
|
ob_start(); |
|
1818
|
|
|
$result = $create_function($image); |
|
1819
|
|
|
$image = ob_get_contents(); |
|
1820
|
|
|
ob_end_clean(); |
|
1821
|
|
|
|
|
1822
|
|
|
return $result ? $image : false; |
|
|
|
|
|
|
1823
|
|
|
} |
|
1824
|
|
|
|
|
1825
|
|
|
/** |
|
1826
|
|
|
* Function to generate an image containing some text. |
|
1827
|
|
|
* It uses Imagick, Font and size are fixed to fit within width |
|
1828
|
|
|
* |
|
1829
|
|
|
* @uses Imagick |
|
1830
|
|
|
* |
|
1831
|
|
|
* @package Graphics |
|
1832
|
|
|
* |
|
1833
|
|
|
* @param string $text The text the image should contain |
|
1834
|
|
|
* @param int $width Width of the final image |
|
1835
|
|
|
* @param int $height Height of the image |
|
1836
|
|
|
* @param string $format Type of the image (valid types are png, jpeg, gif) |
|
1837
|
|
|
* |
|
1838
|
|
|
* @return boolean|resource The image or false on error |
|
1839
|
|
|
*/ |
|
1840
|
|
|
function generateTextImageWithIM($text, $width = 100, $height = 100, $format = 'png') |
|
1841
|
|
|
{ |
|
1842
|
|
|
global $settings; |
|
1843
|
|
|
|
|
1844
|
|
|
try |
|
1845
|
|
|
{ |
|
1846
|
|
|
$image = new Imagick(); |
|
1847
|
|
|
$image->newImage($width, $height, new ImagickPixel('white')); |
|
1848
|
|
|
$image->setImageFormat($format); |
|
1849
|
|
|
|
|
1850
|
|
|
// 28pt is ~2em given default font stack |
|
1851
|
|
|
$font_size = 28; |
|
1852
|
|
|
|
|
1853
|
|
|
$draw = new ImagickDraw(); |
|
1854
|
|
|
$draw->setStrokeColor(new ImagickPixel('#000000')); |
|
1855
|
|
|
$draw->setFillColor(new ImagickPixel('#000000')); |
|
1856
|
|
|
$draw->setStrokeWidth(0); |
|
1857
|
|
|
$draw->setTextAlignment(Imagick::ALIGN_CENTER); |
|
1858
|
|
|
$draw->setFont($settings['default_theme_dir'] . '/fonts/VDS_New.ttf'); |
|
1859
|
|
|
|
|
1860
|
|
|
// Make sure the text will fit the the allowed space |
|
1861
|
|
|
do |
|
1862
|
|
|
{ |
|
1863
|
|
|
$draw->setFontSize($font_size); |
|
1864
|
|
|
$metric = $image->queryFontMetrics($draw, $text); |
|
1865
|
|
|
$text_width = (int) $metric['textWidth']; |
|
1866
|
|
|
} while ($text_width > $width && $font_size-- > 1); |
|
1867
|
|
|
|
|
1868
|
|
|
// Place text in center of block |
|
1869
|
|
|
$image->annotateImage($draw, $width / 2, $height / 2 + $font_size / 4, 0, $text); |
|
1870
|
|
|
$image = $image->getImageBlob(); |
|
1871
|
|
|
|
|
1872
|
|
|
return $image; |
|
|
|
|
|
|
1873
|
|
|
} |
|
1874
|
|
|
catch (Exception $e) |
|
1875
|
|
|
{ |
|
1876
|
|
|
return false; |
|
1877
|
|
|
} |
|
1878
|
|
|
} |
|
1879
|
|
|
|
If you suppress an error, we recommend checking for the error condition explicitly: