/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/libraries/Image_lib.php

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 
2
/**
 
3
 * CodeIgniter
 
4
 *
 
5
 * An open source application development framework for PHP 5.1.6 or newer
 
6
 *
 
7
 * @package             CodeIgniter
 
8
 * @author              ExpressionEngine Dev Team
 
9
 * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
 
10
 * @license             http://codeigniter.com/user_guide/license.html
 
11
 * @link                http://codeigniter.com
 
12
 * @since               Version 1.0
 
13
 * @filesource
 
14
 */
 
15
 
 
16
// ------------------------------------------------------------------------
 
17
 
 
18
/**
 
19
 * Image Manipulation class
 
20
 *
 
21
 * @package             CodeIgniter
 
22
 * @subpackage  Libraries
 
23
 * @category    Image_lib
 
24
 * @author              ExpressionEngine Dev Team
 
25
 * @link                http://codeigniter.com/user_guide/libraries/image_lib.html
 
26
 */
 
27
class CI_Image_lib {
 
28
 
 
29
        var $image_library              = 'gd2';        // Can be:  imagemagick, netpbm, gd, gd2
 
30
        var $library_path               = '';
 
31
        var $dynamic_output             = FALSE;        // Whether to send to browser or write to disk
 
32
        var $source_image               = '';
 
33
        var $new_image                  = '';
 
34
        var $width                              = '';
 
35
        var $height                             = '';
 
36
        var $quality                    = '90';
 
37
        var $create_thumb               = FALSE;
 
38
        var $thumb_marker               = '_thumb';
 
39
        var $maintain_ratio             = TRUE;         // Whether to maintain aspect ratio when resizing or use hard values
 
40
        var $master_dim                 = 'auto';       // auto, height, or width.  Determines what to use as the master dimension
 
41
        var $rotation_angle             = '';
 
42
        var $x_axis                             = '';
 
43
        var     $y_axis                         = '';
 
44
 
 
45
        // Watermark Vars
 
46
        var $wm_text                    = '';                   // Watermark text if graphic is not used
 
47
        var $wm_type                    = 'text';               // Type of watermarking.  Options:  text/overlay
 
48
        var $wm_x_transp                = 4;
 
49
        var $wm_y_transp                = 4;
 
50
        var $wm_overlay_path    = '';                   // Watermark image path
 
51
        var $wm_font_path               = '';                   // TT font
 
52
        var $wm_font_size               = 17;                   // Font size (different versions of GD will either use points or pixels)
 
53
        var $wm_vrt_alignment   = 'B';                  // Vertical alignment:   T M B
 
54
        var $wm_hor_alignment   = 'C';                  // Horizontal alignment: L R C
 
55
        var $wm_padding                 = 0;                    // Padding around text
 
56
        var $wm_hor_offset              = 0;                    // Lets you push text to the right
 
57
        var $wm_vrt_offset              = 0;                    // Lets you push  text down
 
58
        var $wm_font_color              = '#ffffff';    // Text color
 
59
        var $wm_shadow_color    = '';                   // Dropshadow color
 
60
        var $wm_shadow_distance = 2;                    // Dropshadow distance
 
61
        var $wm_opacity                 = 50;                   // Image opacity: 1 - 100  Only works with image
 
62
 
 
63
        // Private Vars
 
64
        var $source_folder              = '';
 
65
        var $dest_folder                = '';
 
66
        var $mime_type                  = '';
 
67
        var $orig_width                 = '';
 
68
        var $orig_height                = '';
 
69
        var $image_type                 = '';
 
70
        var $size_str                   = '';
 
71
        var $full_src_path              = '';
 
72
        var $full_dst_path              = '';
 
73
        var $create_fnc                 = 'imagecreatetruecolor';
 
74
        var $copy_fnc                   = 'imagecopyresampled';
 
75
        var $error_msg                  = array();
 
76
        var $wm_use_drop_shadow = FALSE;
 
77
        var $wm_use_truetype    = FALSE;
 
78
 
 
79
        /**
 
80
         * Constructor
 
81
         *
 
82
         * @param       string
 
83
         * @return      void
 
84
         */
 
85
        public function __construct($props = array())
 
86
        {
 
87
                if (count($props) > 0)
 
88
                {
 
89
                        $this->initialize($props);
 
90
                }
 
91
 
 
92
                log_message('debug', "Image Lib Class Initialized");
 
93
        }
 
94
 
 
95
        // --------------------------------------------------------------------
 
96
 
 
97
        /**
 
98
         * Initialize image properties
 
99
         *
 
100
         * Resets values in case this class is used in a loop
 
101
         *
 
102
         * @access      public
 
103
         * @return      void
 
104
         */
 
105
        function clear()
 
106
        {
 
107
                $props = array('source_folder', 'dest_folder', 'source_image', 'full_src_path', 'full_dst_path', 'new_image', 'image_type', 'size_str', 'quality', 'orig_width', 'orig_height', 'width', 'height', 'rotation_angle', 'x_axis', 'y_axis', 'create_fnc', 'copy_fnc', 'wm_overlay_path', 'wm_use_truetype', 'dynamic_output', 'wm_font_size', 'wm_text', 'wm_vrt_alignment', 'wm_hor_alignment', 'wm_padding', 'wm_hor_offset', 'wm_vrt_offset', 'wm_font_color', 'wm_use_drop_shadow', 'wm_shadow_color', 'wm_shadow_distance', 'wm_opacity');
 
108
 
 
109
                foreach ($props as $val)
 
110
                {
 
111
                        $this->$val = '';
 
112
                }
 
113
 
 
114
                // special consideration for master_dim
 
115
                $this->master_dim = 'auto';
 
116
        }
 
117
 
 
118
        // --------------------------------------------------------------------
 
119
 
 
120
        /**
 
121
         * initialize image preferences
 
122
         *
 
123
         * @access      public
 
124
         * @param       array
 
125
         * @return      bool
 
126
         */
 
127
        function initialize($props = array())
 
128
        {
 
129
                /*
 
130
                 * Convert array elements into class variables
 
131
                 */
 
132
                if (count($props) > 0)
 
133
                {
 
134
                        foreach ($props as $key => $val)
 
135
                        {
 
136
                                $this->$key = $val;
 
137
                        }
 
138
                }
 
139
 
 
140
                /*
 
141
                 * Is there a source image?
 
142
                 *
 
143
                 * If not, there's no reason to continue
 
144
                 *
 
145
                 */
 
146
                if ($this->source_image == '')
 
147
                {
 
148
                        $this->set_error('imglib_source_image_required');
 
149
                        return FALSE;   
 
150
                }
 
151
 
 
152
                /*
 
153
                 * Is getimagesize() Available?
 
154
                 *
 
155
                 * We use it to determine the image properties (width/height).
 
156
                 * Note:  We need to figure out how to determine image
 
157
                 * properties using ImageMagick and NetPBM
 
158
                 *
 
159
                 */
 
160
                if ( ! function_exists('getimagesize'))
 
161
                {
 
162
                        $this->set_error('imglib_gd_required_for_props');
 
163
                        return FALSE;
 
164
                }
 
165
 
 
166
                $this->image_library = strtolower($this->image_library);
 
167
 
 
168
                /*
 
169
                 * Set the full server path
 
170
                 *
 
171
                 * The source image may or may not contain a path.
 
172
                 * Either way, we'll try use realpath to generate the
 
173
                 * full server path in order to more reliably read it.
 
174
                 *
 
175
                 */
 
176
                if (function_exists('realpath') AND @realpath($this->source_image) !== FALSE)
 
177
                {
 
178
                        $full_source_path = str_replace("\\", "/", realpath($this->source_image));
 
179
                }
 
180
                else
 
181
                {
 
182
                        $full_source_path = $this->source_image;
 
183
                }
 
184
 
 
185
                $x = explode('/', $full_source_path);
 
186
                $this->source_image = end($x);
 
187
                $this->source_folder = str_replace($this->source_image, '', $full_source_path);
 
188
 
 
189
                // Set the Image Properties
 
190
                if ( ! $this->get_image_properties($this->source_folder.$this->source_image))
 
191
                {
 
192
                        return FALSE;   
 
193
                }
 
194
 
 
195
                /*
 
196
                 * Assign the "new" image name/path
 
197
                 *
 
198
                 * If the user has set a "new_image" name it means
 
199
                 * we are making a copy of the source image. If not
 
200
                 * it means we are altering the original.  We'll
 
201
                 * set the destination filename and path accordingly.
 
202
                 *
 
203
                 */
 
204
                if ($this->new_image == '')
 
205
                {
 
206
                        $this->dest_image = $this->source_image;
 
207
                        $this->dest_folder = $this->source_folder;
 
208
                }
 
209
                else
 
210
                {
 
211
                        if (strpos($this->new_image, '/') === FALSE AND strpos($this->new_image, '\\') === FALSE)
 
212
                        {
 
213
                                $this->dest_folder = $this->source_folder;
 
214
                                $this->dest_image = $this->new_image;
 
215
                        }
 
216
                        else
 
217
                        {
 
218
                                if (function_exists('realpath') AND @realpath($this->new_image) !== FALSE)
 
219
                                {
 
220
                                        $full_dest_path = str_replace("\\", "/", realpath($this->new_image));
 
221
                                }
 
222
                                else
 
223
                                {
 
224
                                        $full_dest_path = $this->new_image;
 
225
                                }
 
226
 
 
227
                                // Is there a file name?
 
228
                                if ( ! preg_match("#\.(jpg|jpeg|gif|png)$#i", $full_dest_path))
 
229
                                {
 
230
                                        $this->dest_folder = $full_dest_path.'/';
 
231
                                        $this->dest_image = $this->source_image;
 
232
                                }
 
233
                                else
 
234
                                {
 
235
                                        $x = explode('/', $full_dest_path);
 
236
                                        $this->dest_image = end($x);
 
237
                                        $this->dest_folder = str_replace($this->dest_image, '', $full_dest_path);
 
238
                                }
 
239
                        }
 
240
                }
 
241
 
 
242
                /*
 
243
                 * Compile the finalized filenames/paths
 
244
                 *
 
245
                 * We'll create two master strings containing the
 
246
                 * full server path to the source image and the
 
247
                 * full server path to the destination image.
 
248
                 * We'll also split the destination image name
 
249
                 * so we can insert the thumbnail marker if needed.
 
250
                 *
 
251
                 */
 
252
                if ($this->create_thumb === FALSE OR $this->thumb_marker == '')
 
253
                {
 
254
                        $this->thumb_marker = '';
 
255
                }
 
256
 
 
257
                $xp     = $this->explode_name($this->dest_image);
 
258
 
 
259
                $filename = $xp['name'];
 
260
                $file_ext = $xp['ext'];
 
261
 
 
262
                $this->full_src_path = $this->source_folder.$this->source_image;
 
263
                $this->full_dst_path = $this->dest_folder.$filename.$this->thumb_marker.$file_ext;
 
264
 
 
265
                /*
 
266
                 * Should we maintain image proportions?
 
267
                 *
 
268
                 * When creating thumbs or copies, the target width/height
 
269
                 * might not be in correct proportion with the source
 
270
                 * image's width/height.  We'll recalculate it here.
 
271
                 *
 
272
                 */
 
273
                if ($this->maintain_ratio === TRUE && ($this->width != '' AND $this->height != ''))
 
274
                {
 
275
                        $this->image_reproportion();
 
276
                }
 
277
 
 
278
                /*
 
279
                 * Was a width and height specified?
 
280
                 *
 
281
                 * If the destination width/height was
 
282
                 * not submitted we will use the values
 
283
                 * from the actual file
 
284
                 *
 
285
                 */
 
286
                if ($this->width == '')
 
287
                        $this->width = $this->orig_width;
 
288
 
 
289
                if ($this->height == '')
 
290
                        $this->height = $this->orig_height;
 
291
 
 
292
                // Set the quality
 
293
                $this->quality = trim(str_replace("%", "", $this->quality));
 
294
 
 
295
                if ($this->quality == '' OR $this->quality == 0 OR ! is_numeric($this->quality))
 
296
                        $this->quality = 90;
 
297
 
 
298
                // Set the x/y coordinates
 
299
                $this->x_axis = ($this->x_axis == '' OR ! is_numeric($this->x_axis)) ? 0 : $this->x_axis;
 
300
                $this->y_axis = ($this->y_axis == '' OR ! is_numeric($this->y_axis)) ? 0 : $this->y_axis;
 
301
 
 
302
                // Watermark-related Stuff...
 
303
                if ($this->wm_font_color != '')
 
304
                {
 
305
                        if (strlen($this->wm_font_color) == 6)
 
306
                        {
 
307
                                $this->wm_font_color = '#'.$this->wm_font_color;
 
308
                        }
 
309
                }
 
310
 
 
311
                if ($this->wm_shadow_color != '')
 
312
                {
 
313
                        if (strlen($this->wm_shadow_color) == 6)
 
314
                        {
 
315
                                $this->wm_shadow_color = '#'.$this->wm_shadow_color;
 
316
                        }
 
317
                }
 
318
 
 
319
                if ($this->wm_overlay_path != '')
 
320
                {
 
321
                        $this->wm_overlay_path = str_replace("\\", "/", realpath($this->wm_overlay_path));
 
322
                }
 
323
 
 
324
                if ($this->wm_shadow_color != '')
 
325
                {
 
326
                        $this->wm_use_drop_shadow = TRUE;
 
327
                }
 
328
 
 
329
                if ($this->wm_font_path != '')
 
330
                {
 
331
                        $this->wm_use_truetype = TRUE;
 
332
                }
 
333
 
 
334
                return TRUE;
 
335
        }
 
336
 
 
337
        // --------------------------------------------------------------------
 
338
 
 
339
        /**
 
340
         * Image Resize
 
341
         *
 
342
         * This is a wrapper function that chooses the proper
 
343
         * resize function based on the protocol specified
 
344
         *
 
345
         * @access      public
 
346
         * @return      bool
 
347
         */
 
348
        function resize()
 
349
        {
 
350
                $protocol = 'image_process_'.$this->image_library;
 
351
 
 
352
                if (preg_match('/gd2$/i', $protocol))
 
353
                {
 
354
                        $protocol = 'image_process_gd';
 
355
                }
 
356
 
 
357
                return $this->$protocol('resize');
 
358
        }
 
359
 
 
360
        // --------------------------------------------------------------------
 
361
 
 
362
        /**
 
363
         * Image Crop
 
364
         *
 
365
         * This is a wrapper function that chooses the proper
 
366
         * cropping function based on the protocol specified
 
367
         *
 
368
         * @access      public
 
369
         * @return      bool
 
370
         */
 
371
        function crop()
 
372
        {
 
373
                $protocol = 'image_process_'.$this->image_library;
 
374
 
 
375
                if (preg_match('/gd2$/i', $protocol))
 
376
                {
 
377
                        $protocol = 'image_process_gd';
 
378
                }
 
379
 
 
380
                return $this->$protocol('crop');
 
381
        }
 
382
 
 
383
        // --------------------------------------------------------------------
 
384
 
 
385
        /**
 
386
         * Image Rotate
 
387
         *
 
388
         * This is a wrapper function that chooses the proper
 
389
         * rotation function based on the protocol specified
 
390
         *
 
391
         * @access      public
 
392
         * @return      bool
 
393
         */
 
394
        function rotate()
 
395
        {
 
396
                // Allowed rotation values
 
397
                $degs = array(90, 180, 270, 'vrt', 'hor');
 
398
 
 
399
                if ($this->rotation_angle == '' OR ! in_array($this->rotation_angle, $degs))
 
400
                {
 
401
                        $this->set_error('imglib_rotation_angle_required');
 
402
                        return FALSE;   
 
403
                }
 
404
 
 
405
                // Reassign the width and height
 
406
                if ($this->rotation_angle == 90 OR $this->rotation_angle == 270)
 
407
                {
 
408
                        $this->width    = $this->orig_height;
 
409
                        $this->height   = $this->orig_width;
 
410
                }
 
411
                else
 
412
                {
 
413
                        $this->width    = $this->orig_width;
 
414
                        $this->height   = $this->orig_height;
 
415
                }
 
416
 
 
417
 
 
418
                // Choose resizing function
 
419
                if ($this->image_library == 'imagemagick' OR $this->image_library == 'netpbm')
 
420
                {
 
421
                        $protocol = 'image_process_'.$this->image_library;
 
422
 
 
423
                        return $this->$protocol('rotate');
 
424
                }
 
425
 
 
426
                if ($this->rotation_angle == 'hor' OR $this->rotation_angle == 'vrt')
 
427
                {
 
428
                        return $this->image_mirror_gd();
 
429
                }
 
430
                else
 
431
                {
 
432
                        return $this->image_rotate_gd();
 
433
                }
 
434
        }
 
435
 
 
436
        // --------------------------------------------------------------------
 
437
 
 
438
        /**
 
439
         * Image Process Using GD/GD2
 
440
         *
 
441
         * This function will resize or crop
 
442
         *
 
443
         * @access      public
 
444
         * @param       string
 
445
         * @return      bool
 
446
         */
 
447
        function image_process_gd($action = 'resize')
 
448
        {
 
449
                $v2_override = FALSE;
 
450
 
 
451
                // If the target width/height match the source, AND if the new file name is not equal to the old file name
 
452
                // we'll simply make a copy of the original with the new name... assuming dynamic rendering is off.
 
453
                if ($this->dynamic_output === FALSE)
 
454
                {
 
455
                        if ($this->orig_width == $this->width AND $this->orig_height == $this->height)
 
456
                        {
 
457
                                if ($this->source_image != $this->new_image)
 
458
                                {
 
459
                                        if (@copy($this->full_src_path, $this->full_dst_path))
 
460
                                        {
 
461
                                                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
462
                                        }
 
463
                                }
 
464
 
 
465
                                return TRUE;
 
466
                        }
 
467
                }
 
468
 
 
469
                // Let's set up our values based on the action
 
470
                if ($action == 'crop')
 
471
                {
 
472
                        //  Reassign the source width/height if cropping
 
473
                        $this->orig_width  = $this->width;
 
474
                        $this->orig_height = $this->height;
 
475
 
 
476
                        // GD 2.0 has a cropping bug so we'll test for it
 
477
                        if ($this->gd_version() !== FALSE)
 
478
                        {
 
479
                                $gd_version = str_replace('0', '', $this->gd_version());
 
480
                                $v2_override = ($gd_version == 2) ? TRUE : FALSE;
 
481
                        }
 
482
                }
 
483
                else
 
484
                {
 
485
                        // If resizing the x/y axis must be zero
 
486
                        $this->x_axis = 0;
 
487
                        $this->y_axis = 0;
 
488
                }
 
489
 
 
490
                //  Create the image handle
 
491
                if ( ! ($src_img = $this->image_create_gd()))
 
492
                {
 
493
                        return FALSE;
 
494
                }
 
495
 
 
496
                //  Create The Image
 
497
                //
 
498
                //  old conditional which users report cause problems with shared GD libs who report themselves as "2.0 or greater"
 
499
                //  it appears that this is no longer the issue that it was in 2004, so we've removed it, retaining it in the comment
 
500
                //  below should that ever prove inaccurate.
 
501
                //
 
502
                //  if ($this->image_library == 'gd2' AND function_exists('imagecreatetruecolor') AND $v2_override == FALSE)
 
503
                if ($this->image_library == 'gd2' AND function_exists('imagecreatetruecolor'))
 
504
                {
 
505
                        $create = 'imagecreatetruecolor';
 
506
                        $copy   = 'imagecopyresampled';
 
507
                }
 
508
                else
 
509
                {
 
510
                        $create = 'imagecreate';
 
511
                        $copy   = 'imagecopyresized';
 
512
                }
 
513
 
 
514
                $dst_img = $create($this->width, $this->height);
 
515
 
 
516
                if ($this->image_type == 3) // png we can actually preserve transparency
 
517
                {
 
518
                        imagealphablending($dst_img, FALSE);
 
519
                        imagesavealpha($dst_img, TRUE);
 
520
                }
 
521
 
 
522
                $copy($dst_img, $src_img, 0, 0, $this->x_axis, $this->y_axis, $this->width, $this->height, $this->orig_width, $this->orig_height);
 
523
 
 
524
                //  Show the image
 
525
                if ($this->dynamic_output == TRUE)
 
526
                {
 
527
                        $this->image_display_gd($dst_img);
 
528
                }
 
529
                else
 
530
                {
 
531
                        // Or save it
 
532
                        if ( ! $this->image_save_gd($dst_img))
 
533
                        {
 
534
                                return FALSE;
 
535
                        }
 
536
                }
 
537
 
 
538
                //  Kill the file handles
 
539
                imagedestroy($dst_img);
 
540
                imagedestroy($src_img);
 
541
 
 
542
                // Set the file to 777
 
543
                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
544
 
 
545
                return TRUE;
 
546
        }
 
547
 
 
548
        // --------------------------------------------------------------------
 
549
 
 
550
        /**
 
551
         * Image Process Using ImageMagick
 
552
         *
 
553
         * This function will resize, crop or rotate
 
554
         *
 
555
         * @access      public
 
556
         * @param       string
 
557
         * @return      bool
 
558
         */
 
559
        function image_process_imagemagick($action = 'resize')
 
560
        {
 
561
                //  Do we have a vaild library path?
 
562
                if ($this->library_path == '')
 
563
                {
 
564
                        $this->set_error('imglib_libpath_invalid');
 
565
                        return FALSE;
 
566
                }
 
567
 
 
568
                if ( ! preg_match("/convert$/i", $this->library_path))
 
569
                {
 
570
                        $this->library_path = rtrim($this->library_path, '/').'/';
 
571
 
 
572
                        $this->library_path .= 'convert';
 
573
                }
 
574
 
 
575
                // Execute the command
 
576
                $cmd = $this->library_path." -quality ".$this->quality;
 
577
 
 
578
                if ($action == 'crop')
 
579
                {
 
580
                        $cmd .= " -crop ".$this->width."x".$this->height."+".$this->x_axis."+".$this->y_axis." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
 
581
                }
 
582
                elseif ($action == 'rotate')
 
583
                {
 
584
                        switch ($this->rotation_angle)
 
585
                        {
 
586
                                case 'hor'      : $angle = '-flop';
 
587
                                        break;
 
588
                                case 'vrt'      : $angle = '-flip';
 
589
                                        break;
 
590
                                default         : $angle = '-rotate '.$this->rotation_angle;
 
591
                                        break;
 
592
                        }
 
593
 
 
594
                        $cmd .= " ".$angle." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
 
595
                }
 
596
                else  // Resize
 
597
                {
 
598
                        $cmd .= " -resize ".$this->width."x".$this->height." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
 
599
                }
 
600
 
 
601
                $retval = 1;
 
602
 
 
603
                @exec($cmd, $output, $retval);
 
604
 
 
605
                //      Did it work?
 
606
                if ($retval > 0)
 
607
                {
 
608
                        $this->set_error('imglib_image_process_failed');
 
609
                        return FALSE;
 
610
                }
 
611
 
 
612
                // Set the file to 777
 
613
                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
614
 
 
615
                return TRUE;
 
616
        }
 
617
 
 
618
        // --------------------------------------------------------------------
 
619
 
 
620
        /**
 
621
         * Image Process Using NetPBM
 
622
         *
 
623
         * This function will resize, crop or rotate
 
624
         *
 
625
         * @access      public
 
626
         * @param       string
 
627
         * @return      bool
 
628
         */
 
629
        function image_process_netpbm($action = 'resize')
 
630
        {
 
631
                if ($this->library_path == '')
 
632
                {
 
633
                        $this->set_error('imglib_libpath_invalid');
 
634
                        return FALSE;
 
635
                }
 
636
 
 
637
                //  Build the resizing command
 
638
                switch ($this->image_type)
 
639
                {
 
640
                        case 1 :
 
641
                                                $cmd_in         = 'giftopnm';
 
642
                                                $cmd_out        = 'ppmtogif';
 
643
                                break;
 
644
                        case 2 :
 
645
                                                $cmd_in         = 'jpegtopnm';
 
646
                                                $cmd_out        = 'ppmtojpeg';
 
647
                                break;
 
648
                        case 3 :
 
649
                                                $cmd_in         = 'pngtopnm';
 
650
                                                $cmd_out        = 'ppmtopng';
 
651
                                break;
 
652
                }
 
653
 
 
654
                if ($action == 'crop')
 
655
                {
 
656
                        $cmd_inner = 'pnmcut -left '.$this->x_axis.' -top '.$this->y_axis.' -width '.$this->width.' -height '.$this->height;
 
657
                }
 
658
                elseif ($action == 'rotate')
 
659
                {
 
660
                        switch ($this->rotation_angle)
 
661
                        {
 
662
                                case 90         :       $angle = 'r270';
 
663
                                        break;
 
664
                                case 180        :       $angle = 'r180';
 
665
                                        break;
 
666
                                case 270        :       $angle = 'r90';
 
667
                                        break;
 
668
                                case 'vrt'      :       $angle = 'tb';
 
669
                                        break;
 
670
                                case 'hor'      :       $angle = 'lr';
 
671
                                        break;
 
672
                        }
 
673
 
 
674
                        $cmd_inner = 'pnmflip -'.$angle.' ';
 
675
                }
 
676
                else // Resize
 
677
                {
 
678
                        $cmd_inner = 'pnmscale -xysize '.$this->width.' '.$this->height;
 
679
                }
 
680
 
 
681
                $cmd = $this->library_path.$cmd_in.' '.$this->full_src_path.' | '.$cmd_inner.' | '.$cmd_out.' > '.$this->dest_folder.'netpbm.tmp';
 
682
 
 
683
                $retval = 1;
 
684
 
 
685
                @exec($cmd, $output, $retval);
 
686
 
 
687
                //  Did it work?
 
688
                if ($retval > 0)
 
689
                {
 
690
                        $this->set_error('imglib_image_process_failed');
 
691
                        return FALSE;
 
692
                }
 
693
 
 
694
                // With NetPBM we have to create a temporary image.
 
695
                // If you try manipulating the original it fails so
 
696
                // we have to rename the temp file.
 
697
                copy ($this->dest_folder.'netpbm.tmp', $this->full_dst_path);
 
698
                unlink ($this->dest_folder.'netpbm.tmp');
 
699
                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
700
 
 
701
                return TRUE;
 
702
        }
 
703
 
 
704
        // --------------------------------------------------------------------
 
705
 
 
706
        /**
 
707
         * Image Rotate Using GD
 
708
         *
 
709
         * @access      public
 
710
         * @return      bool
 
711
         */
 
712
        function image_rotate_gd()
 
713
        {
 
714
                //  Create the image handle
 
715
                if ( ! ($src_img = $this->image_create_gd()))
 
716
                {
 
717
                        return FALSE;
 
718
                }
 
719
 
 
720
                // Set the background color
 
721
                // This won't work with transparent PNG files so we are
 
722
                // going to have to figure out how to determine the color
 
723
                // of the alpha channel in a future release.
 
724
 
 
725
                $white  = imagecolorallocate($src_img, 255, 255, 255);
 
726
 
 
727
                //  Rotate it!
 
728
                $dst_img = imagerotate($src_img, $this->rotation_angle, $white);
 
729
 
 
730
                //  Save the Image
 
731
                if ($this->dynamic_output == TRUE)
 
732
                {
 
733
                        $this->image_display_gd($dst_img);
 
734
                }
 
735
                else
 
736
                {
 
737
                        // Or save it
 
738
                        if ( ! $this->image_save_gd($dst_img))
 
739
                        {
 
740
                                return FALSE;
 
741
                        }
 
742
                }
 
743
 
 
744
                //  Kill the file handles
 
745
                imagedestroy($dst_img);
 
746
                imagedestroy($src_img);
 
747
 
 
748
                // Set the file to 777
 
749
 
 
750
                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
751
 
 
752
                return TRUE;
 
753
        }
 
754
 
 
755
        // --------------------------------------------------------------------
 
756
 
 
757
        /**
 
758
         * Create Mirror Image using GD
 
759
         *
 
760
         * This function will flip horizontal or vertical
 
761
         *
 
762
         * @access      public
 
763
         * @return      bool
 
764
         */
 
765
        function image_mirror_gd()
 
766
        {
 
767
                if ( ! $src_img = $this->image_create_gd())
 
768
                {
 
769
                        return FALSE;
 
770
                }
 
771
 
 
772
                $width  = $this->orig_width;
 
773
                $height = $this->orig_height;
 
774
 
 
775
                if ($this->rotation_angle == 'hor')
 
776
                {
 
777
                        for ($i = 0; $i < $height; $i++)
 
778
                        {
 
779
                                $left  = 0;
 
780
                                $right = $width-1;
 
781
 
 
782
                                while ($left < $right)
 
783
                                {
 
784
                                        $cl = imagecolorat($src_img, $left, $i);
 
785
                                        $cr = imagecolorat($src_img, $right, $i);
 
786
 
 
787
                                        imagesetpixel($src_img, $left, $i, $cr);
 
788
                                        imagesetpixel($src_img, $right, $i, $cl);
 
789
 
 
790
                                        $left++;
 
791
                                        $right--;
 
792
                                }
 
793
                        }
 
794
                }
 
795
                else
 
796
                {
 
797
                        for ($i = 0; $i < $width; $i++)
 
798
                        {
 
799
                                $top = 0;
 
800
                                $bot = $height-1;
 
801
 
 
802
                                while ($top < $bot)
 
803
                                {
 
804
                                        $ct = imagecolorat($src_img, $i, $top);
 
805
                                        $cb = imagecolorat($src_img, $i, $bot);
 
806
 
 
807
                                        imagesetpixel($src_img, $i, $top, $cb);
 
808
                                        imagesetpixel($src_img, $i, $bot, $ct);
 
809
 
 
810
                                        $top++;
 
811
                                        $bot--;
 
812
                                }
 
813
                        }
 
814
                }
 
815
 
 
816
                //  Show the image
 
817
                if ($this->dynamic_output == TRUE)
 
818
                {
 
819
                        $this->image_display_gd($src_img);
 
820
                }
 
821
                else
 
822
                {
 
823
                        // Or save it
 
824
                        if ( ! $this->image_save_gd($src_img))
 
825
                        {
 
826
                                return FALSE;
 
827
                        }
 
828
                }
 
829
 
 
830
                //  Kill the file handles
 
831
                imagedestroy($src_img);
 
832
 
 
833
                // Set the file to 777
 
834
                @chmod($this->full_dst_path, FILE_WRITE_MODE);
 
835
 
 
836
                return TRUE;
 
837
        }
 
838
 
 
839
        // --------------------------------------------------------------------
 
840
 
 
841
        /**
 
842
         * Image Watermark
 
843
         *
 
844
         * This is a wrapper function that chooses the type
 
845
         * of watermarking based on the specified preference.
 
846
         *
 
847
         * @access      public
 
848
         * @param       string
 
849
         * @return      bool
 
850
         */
 
851
        function watermark()
 
852
        {
 
853
                if ($this->wm_type == 'overlay')
 
854
                {
 
855
                        return $this->overlay_watermark();
 
856
                }
 
857
                else
 
858
                {
 
859
                        return $this->text_watermark();
 
860
                }
 
861
        }
 
862
 
 
863
        // --------------------------------------------------------------------
 
864
 
 
865
        /**
 
866
         * Watermark - Graphic Version
 
867
         *
 
868
         * @access      public
 
869
         * @return      bool
 
870
         */
 
871
        function overlay_watermark()
 
872
        {
 
873
                if ( ! function_exists('imagecolortransparent'))
 
874
                {
 
875
                        $this->set_error('imglib_gd_required');
 
876
                        return FALSE;
 
877
                }
 
878
 
 
879
                //  Fetch source image properties
 
880
                $this->get_image_properties();
 
881
 
 
882
                //  Fetch watermark image properties
 
883
                $props                  = $this->get_image_properties($this->wm_overlay_path, TRUE);
 
884
                $wm_img_type    = $props['image_type'];
 
885
                $wm_width               = $props['width'];
 
886
                $wm_height              = $props['height'];
 
887
 
 
888
                //  Create two image resources
 
889
                $wm_img  = $this->image_create_gd($this->wm_overlay_path, $wm_img_type);
 
890
                $src_img = $this->image_create_gd($this->full_src_path);
 
891
 
 
892
                // Reverse the offset if necessary
 
893
                // When the image is positioned at the bottom
 
894
                // we don't want the vertical offset to push it
 
895
                // further down.  We want the reverse, so we'll
 
896
                // invert the offset.  Same with the horizontal
 
897
                // offset when the image is at the right
 
898
 
 
899
                $this->wm_vrt_alignment = strtoupper(substr($this->wm_vrt_alignment, 0, 1));
 
900
                $this->wm_hor_alignment = strtoupper(substr($this->wm_hor_alignment, 0, 1));
 
901
 
 
902
                if ($this->wm_vrt_alignment == 'B')
 
903
                        $this->wm_vrt_offset = $this->wm_vrt_offset * -1;
 
904
 
 
905
                if ($this->wm_hor_alignment == 'R')
 
906
                        $this->wm_hor_offset = $this->wm_hor_offset * -1;
 
907
 
 
908
                //  Set the base x and y axis values
 
909
                $x_axis = $this->wm_hor_offset + $this->wm_padding;
 
910
                $y_axis = $this->wm_vrt_offset + $this->wm_padding;
 
911
 
 
912
                //  Set the vertical position
 
913
                switch ($this->wm_vrt_alignment)
 
914
                {
 
915
                        case 'T':
 
916
                                break;
 
917
                        case 'M':       $y_axis += ($this->orig_height / 2) - ($wm_height / 2);
 
918
                                break;
 
919
                        case 'B':       $y_axis += $this->orig_height - $wm_height;
 
920
                                break;
 
921
                }
 
922
 
 
923
                //  Set the horizontal position
 
924
                switch ($this->wm_hor_alignment)
 
925
                {
 
926
                        case 'L':
 
927
                                break;
 
928
                        case 'C':       $x_axis += ($this->orig_width / 2) - ($wm_width / 2);
 
929
                                break;
 
930
                        case 'R':       $x_axis += $this->orig_width - $wm_width;
 
931
                                break;
 
932
                }
 
933
 
 
934
                //  Build the finalized image
 
935
                if ($wm_img_type == 3 AND function_exists('imagealphablending'))
 
936
                {
 
937
                        @imagealphablending($src_img, TRUE);
 
938
                }
 
939
 
 
940
                // Set RGB values for text and shadow
 
941
                $rgba = imagecolorat($wm_img, $this->wm_x_transp, $this->wm_y_transp);
 
942
                $alpha = ($rgba & 0x7F000000) >> 24;
 
943
 
 
944
                // make a best guess as to whether we're dealing with an image with alpha transparency or no/binary transparency
 
945
                if ($alpha > 0)
 
946
                {
 
947
                        // copy the image directly, the image's alpha transparency being the sole determinant of blending
 
948
                        imagecopy($src_img, $wm_img, $x_axis, $y_axis, 0, 0, $wm_width, $wm_height);
 
949
                }
 
950
                else
 
951
                {
 
952
                        // set our RGB value from above to be transparent and merge the images with the specified opacity
 
953
                        imagecolortransparent($wm_img, imagecolorat($wm_img, $this->wm_x_transp, $this->wm_y_transp));
 
954
                        imagecopymerge($src_img, $wm_img, $x_axis, $y_axis, 0, 0, $wm_width, $wm_height, $this->wm_opacity);
 
955
                }
 
956
 
 
957
                //  Output the image
 
958
                if ($this->dynamic_output == TRUE)
 
959
                {
 
960
                        $this->image_display_gd($src_img);
 
961
                }
 
962
                else
 
963
                {
 
964
                        if ( ! $this->image_save_gd($src_img))
 
965
                        {
 
966
                                return FALSE;
 
967
                        }
 
968
                }
 
969
 
 
970
                imagedestroy($src_img);
 
971
                imagedestroy($wm_img);
 
972
 
 
973
                return TRUE;
 
974
        }
 
975
 
 
976
        // --------------------------------------------------------------------
 
977
 
 
978
        /**
 
979
         * Watermark - Text Version
 
980
         *
 
981
         * @access      public
 
982
         * @return      bool
 
983
         */
 
984
        function text_watermark()
 
985
        {
 
986
                if ( ! ($src_img = $this->image_create_gd()))
 
987
                {
 
988
                        return FALSE;
 
989
                }
 
990
 
 
991
                if ($this->wm_use_truetype == TRUE AND ! file_exists($this->wm_font_path))
 
992
                {
 
993
                        $this->set_error('imglib_missing_font');
 
994
                        return FALSE;
 
995
                }
 
996
 
 
997
                //  Fetch source image properties
 
998
                $this->get_image_properties();
 
999
 
 
1000
                // Set RGB values for text and shadow
 
1001
                $this->wm_font_color    = str_replace('#', '', $this->wm_font_color);
 
1002
                $this->wm_shadow_color  = str_replace('#', '', $this->wm_shadow_color);
 
1003
 
 
1004
                $R1 = hexdec(substr($this->wm_font_color, 0, 2));
 
1005
                $G1 = hexdec(substr($this->wm_font_color, 2, 2));
 
1006
                $B1 = hexdec(substr($this->wm_font_color, 4, 2));
 
1007
 
 
1008
                $R2 = hexdec(substr($this->wm_shadow_color, 0, 2));
 
1009
                $G2 = hexdec(substr($this->wm_shadow_color, 2, 2));
 
1010
                $B2 = hexdec(substr($this->wm_shadow_color, 4, 2));
 
1011
 
 
1012
                $txt_color      = imagecolorclosest($src_img, $R1, $G1, $B1);
 
1013
                $drp_color      = imagecolorclosest($src_img, $R2, $G2, $B2);
 
1014
 
 
1015
                // Reverse the vertical offset
 
1016
                // When the image is positioned at the bottom
 
1017
                // we don't want the vertical offset to push it
 
1018
                // further down.  We want the reverse, so we'll
 
1019
                // invert the offset.  Note: The horizontal
 
1020
                // offset flips itself automatically
 
1021
 
 
1022
                if ($this->wm_vrt_alignment == 'B')
 
1023
                        $this->wm_vrt_offset = $this->wm_vrt_offset * -1;
 
1024
 
 
1025
                if ($this->wm_hor_alignment == 'R')
 
1026
                        $this->wm_hor_offset = $this->wm_hor_offset * -1;
 
1027
 
 
1028
                // Set font width and height
 
1029
                // These are calculated differently depending on
 
1030
                // whether we are using the true type font or not
 
1031
                if ($this->wm_use_truetype == TRUE)
 
1032
                {
 
1033
                        if ($this->wm_font_size == '')
 
1034
                                $this->wm_font_size = '17';
 
1035
 
 
1036
                        $fontwidth  = $this->wm_font_size-($this->wm_font_size/4);
 
1037
                        $fontheight = $this->wm_font_size;
 
1038
                        $this->wm_vrt_offset += $this->wm_font_size;
 
1039
                }
 
1040
                else
 
1041
                {
 
1042
                        $fontwidth  = imagefontwidth($this->wm_font_size);
 
1043
                        $fontheight = imagefontheight($this->wm_font_size);
 
1044
                }
 
1045
 
 
1046
                // Set base X and Y axis values
 
1047
                $x_axis = $this->wm_hor_offset + $this->wm_padding;
 
1048
                $y_axis = $this->wm_vrt_offset + $this->wm_padding;
 
1049
 
 
1050
                // Set verticle alignment
 
1051
                if ($this->wm_use_drop_shadow == FALSE)
 
1052
                        $this->wm_shadow_distance = 0;
 
1053
 
 
1054
                $this->wm_vrt_alignment = strtoupper(substr($this->wm_vrt_alignment, 0, 1));
 
1055
                $this->wm_hor_alignment = strtoupper(substr($this->wm_hor_alignment, 0, 1));
 
1056
 
 
1057
                switch ($this->wm_vrt_alignment)
 
1058
                {
 
1059
                        case     "T" :
 
1060
                                break;
 
1061
                        case "M":       $y_axis += ($this->orig_height/2)+($fontheight/2);
 
1062
                                break;
 
1063
                        case "B":       $y_axis += ($this->orig_height - $fontheight - $this->wm_shadow_distance - ($fontheight/2));
 
1064
                                break;
 
1065
                }
 
1066
 
 
1067
                $x_shad = $x_axis + $this->wm_shadow_distance;
 
1068
                $y_shad = $y_axis + $this->wm_shadow_distance;
 
1069
 
 
1070
                // Set horizontal alignment
 
1071
                switch ($this->wm_hor_alignment)
 
1072
                {
 
1073
                        case "L":
 
1074
                                break;
 
1075
                        case "R":
 
1076
                                                if ($this->wm_use_drop_shadow)
 
1077
                                                        $x_shad += ($this->orig_width - $fontwidth*strlen($this->wm_text));
 
1078
                                                        $x_axis += ($this->orig_width - $fontwidth*strlen($this->wm_text));
 
1079
                                break;
 
1080
                        case "C":
 
1081
                                                if ($this->wm_use_drop_shadow)
 
1082
                                                        $x_shad += floor(($this->orig_width - $fontwidth*strlen($this->wm_text))/2);
 
1083
                                                        $x_axis += floor(($this->orig_width  -$fontwidth*strlen($this->wm_text))/2);
 
1084
                                break;
 
1085
                }
 
1086
 
 
1087
                //  Add the text to the source image
 
1088
                if ($this->wm_use_truetype)
 
1089
                {
 
1090
                        if ($this->wm_use_drop_shadow)
 
1091
                                imagettftext($src_img, $this->wm_font_size, 0, $x_shad, $y_shad, $drp_color, $this->wm_font_path, $this->wm_text);
 
1092
                                imagettftext($src_img, $this->wm_font_size, 0, $x_axis, $y_axis, $txt_color, $this->wm_font_path, $this->wm_text);
 
1093
                }
 
1094
                else
 
1095
                {
 
1096
                        if ($this->wm_use_drop_shadow)
 
1097
                                imagestring($src_img, $this->wm_font_size, $x_shad, $y_shad, $this->wm_text, $drp_color);
 
1098
                                imagestring($src_img, $this->wm_font_size, $x_axis, $y_axis, $this->wm_text, $txt_color);
 
1099
                }
 
1100
 
 
1101
                //  Output the final image
 
1102
                if ($this->dynamic_output == TRUE)
 
1103
                {
 
1104
                        $this->image_display_gd($src_img);
 
1105
                }
 
1106
                else
 
1107
                {
 
1108
                        $this->image_save_gd($src_img);
 
1109
                }
 
1110
 
 
1111
                imagedestroy($src_img);
 
1112
 
 
1113
                return TRUE;
 
1114
        }
 
1115
 
 
1116
        // --------------------------------------------------------------------
 
1117
 
 
1118
        /**
 
1119
         * Create Image - GD
 
1120
         *
 
1121
         * This simply creates an image resource handle
 
1122
         * based on the type of image being processed
 
1123
         *
 
1124
         * @access      public
 
1125
         * @param       string
 
1126
         * @return      resource
 
1127
         */
 
1128
        function image_create_gd($path = '', $image_type = '')
 
1129
        {
 
1130
                if ($path == '')
 
1131
                        $path = $this->full_src_path;
 
1132
 
 
1133
                if ($image_type == '')
 
1134
                        $image_type = $this->image_type;
 
1135
 
 
1136
 
 
1137
                switch ($image_type)
 
1138
                {
 
1139
                        case     1 :
 
1140
                                                if ( ! function_exists('imagecreatefromgif'))
 
1141
                                                {
 
1142
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_gif_not_supported'));
 
1143
                                                        return FALSE;
 
1144
                                                }
 
1145
 
 
1146
                                                return imagecreatefromgif($path);
 
1147
                                break;
 
1148
                        case 2 :
 
1149
                                                if ( ! function_exists('imagecreatefromjpeg'))
 
1150
                                                {
 
1151
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_jpg_not_supported'));
 
1152
                                                        return FALSE;
 
1153
                                                }
 
1154
 
 
1155
                                                return imagecreatefromjpeg($path);
 
1156
                                break;
 
1157
                        case 3 :
 
1158
                                                if ( ! function_exists('imagecreatefrompng'))
 
1159
                                                {
 
1160
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_png_not_supported'));
 
1161
                                                        return FALSE;
 
1162
                                                }
 
1163
 
 
1164
                                                return imagecreatefrompng($path);
 
1165
                                break;
 
1166
 
 
1167
                }
 
1168
 
 
1169
                $this->set_error(array('imglib_unsupported_imagecreate'));
 
1170
                return FALSE;
 
1171
        }
 
1172
 
 
1173
        // --------------------------------------------------------------------
 
1174
 
 
1175
        /**
 
1176
         * Write image file to disk - GD
 
1177
         *
 
1178
         * Takes an image resource as input and writes the file
 
1179
         * to the specified destination
 
1180
         *
 
1181
         * @access      public
 
1182
         * @param       resource
 
1183
         * @return      bool
 
1184
         */
 
1185
        function image_save_gd($resource)
 
1186
        {
 
1187
                switch ($this->image_type)
 
1188
                {
 
1189
                        case 1 :
 
1190
                                                if ( ! function_exists('imagegif'))
 
1191
                                                {
 
1192
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_gif_not_supported'));
 
1193
                                                        return FALSE;
 
1194
                                                }
 
1195
 
 
1196
                                                if ( ! @imagegif($resource, $this->full_dst_path))
 
1197
                                                {
 
1198
                                                        $this->set_error('imglib_save_failed');
 
1199
                                                        return FALSE;
 
1200
                                                }
 
1201
                                break;
 
1202
                        case 2  :
 
1203
                                                if ( ! function_exists('imagejpeg'))
 
1204
                                                {
 
1205
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_jpg_not_supported'));
 
1206
                                                        return FALSE;
 
1207
                                                }
 
1208
 
 
1209
                                                if ( ! @imagejpeg($resource, $this->full_dst_path, $this->quality))
 
1210
                                                {
 
1211
                                                        $this->set_error('imglib_save_failed');
 
1212
                                                        return FALSE;
 
1213
                                                }
 
1214
                                break;
 
1215
                        case 3  :
 
1216
                                                if ( ! function_exists('imagepng'))
 
1217
                                                {
 
1218
                                                        $this->set_error(array('imglib_unsupported_imagecreate', 'imglib_png_not_supported'));
 
1219
                                                        return FALSE;
 
1220
                                                }
 
1221
 
 
1222
                                                if ( ! @imagepng($resource, $this->full_dst_path))
 
1223
                                                {
 
1224
                                                        $this->set_error('imglib_save_failed');
 
1225
                                                        return FALSE;
 
1226
                                                }
 
1227
                                break;
 
1228
                        default         :
 
1229
                                                        $this->set_error(array('imglib_unsupported_imagecreate'));
 
1230
                                                        return FALSE;
 
1231
                                break;
 
1232
                }
 
1233
 
 
1234
                return TRUE;
 
1235
        }
 
1236
 
 
1237
        // --------------------------------------------------------------------
 
1238
 
 
1239
        /**
 
1240
         * Dynamically outputs an image
 
1241
         *
 
1242
         * @access      public
 
1243
         * @param       resource
 
1244
         * @return      void
 
1245
         */
 
1246
        function image_display_gd($resource)
 
1247
        {
 
1248
                header("Content-Disposition: filename={$this->source_image};");
 
1249
                header("Content-Type: {$this->mime_type}");
 
1250
                header('Content-Transfer-Encoding: binary');
 
1251
                header('Last-Modified: '.gmdate('D, d M Y H:i:s', time()).' GMT');
 
1252
 
 
1253
                switch ($this->image_type)
 
1254
                {
 
1255
                        case 1          :       imagegif($resource);
 
1256
                                break;
 
1257
                        case 2          :       imagejpeg($resource, '', $this->quality);
 
1258
                                break;
 
1259
                        case 3          :       imagepng($resource);
 
1260
                                break;
 
1261
                        default         :       echo 'Unable to display the image';
 
1262
                                break;
 
1263
                }
 
1264
        }
 
1265
 
 
1266
        // --------------------------------------------------------------------
 
1267
 
 
1268
        /**
 
1269
         * Re-proportion Image Width/Height
 
1270
         *
 
1271
         * When creating thumbs, the desired width/height
 
1272
         * can end up warping the image due to an incorrect
 
1273
         * ratio between the full-sized image and the thumb.
 
1274
         *
 
1275
         * This function lets us re-proportion the width/height
 
1276
         * if users choose to maintain the aspect ratio when resizing.
 
1277
         *
 
1278
         * @access      public
 
1279
         * @return      void
 
1280
         */
 
1281
        function image_reproportion()
 
1282
        {
 
1283
                if ( ! is_numeric($this->width) OR ! is_numeric($this->height) OR $this->width == 0 OR $this->height == 0)
 
1284
                        return;
 
1285
 
 
1286
                if ( ! is_numeric($this->orig_width) OR ! is_numeric($this->orig_height) OR $this->orig_width == 0 OR $this->orig_height == 0)
 
1287
                        return;
 
1288
 
 
1289
                $new_width      = ceil($this->orig_width*$this->height/$this->orig_height);
 
1290
                $new_height     = ceil($this->width*$this->orig_height/$this->orig_width);
 
1291
 
 
1292
                $ratio = (($this->orig_height/$this->orig_width) - ($this->height/$this->width));
 
1293
 
 
1294
                if ($this->master_dim != 'width' AND $this->master_dim != 'height')
 
1295
                {
 
1296
                        $this->master_dim = ($ratio < 0) ? 'width' : 'height';
 
1297
                }
 
1298
 
 
1299
                if (($this->width != $new_width) AND ($this->height != $new_height))
 
1300
                {
 
1301
                        if ($this->master_dim == 'height')
 
1302
                        {
 
1303
                                $this->width = $new_width;
 
1304
                        }
 
1305
                        else
 
1306
                        {
 
1307
                                $this->height = $new_height;
 
1308
                        }
 
1309
                }
 
1310
        }
 
1311
 
 
1312
        // --------------------------------------------------------------------
 
1313
 
 
1314
        /**
 
1315
         * Get image properties
 
1316
         *
 
1317
         * A helper function that gets info about the file
 
1318
         *
 
1319
         * @access      public
 
1320
         * @param       string
 
1321
         * @return      mixed
 
1322
         */
 
1323
        function get_image_properties($path = '', $return = FALSE)
 
1324
        {
 
1325
                // For now we require GD but we should
 
1326
                // find a way to determine this using IM or NetPBM
 
1327
 
 
1328
                if ($path == '')
 
1329
                        $path = $this->full_src_path;
 
1330
 
 
1331
                if ( ! file_exists($path))
 
1332
                {
 
1333
                        $this->set_error('imglib_invalid_path');
 
1334
                        return FALSE;
 
1335
                }
 
1336
 
 
1337
                $vals = @getimagesize($path);
 
1338
 
 
1339
                $types = array(1 => 'gif', 2 => 'jpeg', 3 => 'png');
 
1340
 
 
1341
                $mime = (isset($types[$vals['2']])) ? 'image/'.$types[$vals['2']] : 'image/jpg';
 
1342
 
 
1343
                if ($return == TRUE)
 
1344
                {
 
1345
                        $v['width']                     = $vals['0'];
 
1346
                        $v['height']            = $vals['1'];
 
1347
                        $v['image_type']        = $vals['2'];
 
1348
                        $v['size_str']          = $vals['3'];
 
1349
                        $v['mime_type']         = $mime;
 
1350
 
 
1351
                        return $v;
 
1352
                }
 
1353
 
 
1354
                $this->orig_width       = $vals['0'];
 
1355
                $this->orig_height      = $vals['1'];
 
1356
                $this->image_type       = $vals['2'];
 
1357
                $this->size_str         = $vals['3'];
 
1358
                $this->mime_type        = $mime;
 
1359
 
 
1360
                return TRUE;
 
1361
        }
 
1362
 
 
1363
        // --------------------------------------------------------------------
 
1364
 
 
1365
        /**
 
1366
         * Size calculator
 
1367
         *
 
1368
         * This function takes a known width x height and
 
1369
         * recalculates it to a new size.  Only one
 
1370
         * new variable needs to be known
 
1371
         *
 
1372
         *      $props = array(
 
1373
         *                                      'width'                 => $width,
 
1374
         *                                      'height'                => $height,
 
1375
         *                                      'new_width'             => 40,
 
1376
         *                                      'new_height'    => ''
 
1377
         *                                );
 
1378
         *
 
1379
         * @access      public
 
1380
         * @param       array
 
1381
         * @return      array
 
1382
         */
 
1383
        function size_calculator($vals)
 
1384
        {
 
1385
                if ( ! is_array($vals))
 
1386
                {
 
1387
                        return;
 
1388
                }
 
1389
 
 
1390
                $allowed = array('new_width', 'new_height', 'width', 'height');
 
1391
 
 
1392
                foreach ($allowed as $item)
 
1393
                {
 
1394
                        if ( ! isset($vals[$item]) OR $vals[$item] == '')
 
1395
                                $vals[$item] = 0;
 
1396
                }
 
1397
 
 
1398
                if ($vals['width'] == 0 OR $vals['height'] == 0)
 
1399
                {
 
1400
                        return $vals;
 
1401
                }
 
1402
 
 
1403
                if ($vals['new_width'] == 0)
 
1404
                {
 
1405
                        $vals['new_width'] = ceil($vals['width']*$vals['new_height']/$vals['height']);
 
1406
                }
 
1407
                elseif ($vals['new_height'] == 0)
 
1408
                {
 
1409
                        $vals['new_height'] = ceil($vals['new_width']*$vals['height']/$vals['width']);
 
1410
                }
 
1411
 
 
1412
                return $vals;
 
1413
        }
 
1414
 
 
1415
        // --------------------------------------------------------------------
 
1416
 
 
1417
        /**
 
1418
         * Explode source_image
 
1419
         *
 
1420
         * This is a helper function that extracts the extension
 
1421
         * from the source_image.  This function lets us deal with
 
1422
         * source_images with multiple periods, like:  my.cool.jpg
 
1423
         * It returns an associative array with two elements:
 
1424
         * $array['ext']  = '.jpg';
 
1425
         * $array['name'] = 'my.cool';
 
1426
         *
 
1427
         * @access      public
 
1428
         * @param       array
 
1429
         * @return      array
 
1430
         */
 
1431
        function explode_name($source_image)
 
1432
        {
 
1433
                $ext = strrchr($source_image, '.');
 
1434
                $name = ($ext === FALSE) ? $source_image : substr($source_image, 0, -strlen($ext));
 
1435
 
 
1436
                return array('ext' => $ext, 'name' => $name);
 
1437
        }
 
1438
 
 
1439
        // --------------------------------------------------------------------
 
1440
 
 
1441
        /**
 
1442
         * Is GD Installed?
 
1443
         *
 
1444
         * @access      public
 
1445
         * @return      bool
 
1446
         */
 
1447
        function gd_loaded()
 
1448
        {
 
1449
                if ( ! extension_loaded('gd'))
 
1450
                {
 
1451
                        if ( ! dl('gd.so'))
 
1452
                        {
 
1453
                                return FALSE;
 
1454
                        }
 
1455
                }
 
1456
 
 
1457
                return TRUE;
 
1458
        }
 
1459
 
 
1460
        // --------------------------------------------------------------------
 
1461
 
 
1462
        /**
 
1463
         * Get GD version
 
1464
         *
 
1465
         * @access      public
 
1466
         * @return      mixed
 
1467
         */
 
1468
        function gd_version()
 
1469
        {
 
1470
                if (function_exists('gd_info'))
 
1471
                {
 
1472
                        $gd_version = @gd_info();
 
1473
                        $gd_version = preg_replace("/\D/", "", $gd_version['GD Version']);
 
1474
 
 
1475
                        return $gd_version;
 
1476
                }
 
1477
 
 
1478
                return FALSE;
 
1479
        }
 
1480
 
 
1481
        // --------------------------------------------------------------------
 
1482
 
 
1483
        /**
 
1484
         * Set error message
 
1485
         *
 
1486
         * @access      public
 
1487
         * @param       string
 
1488
         * @return      void
 
1489
         */
 
1490
        function set_error($msg)
 
1491
        {
 
1492
                $CI =& get_instance();
 
1493
                $CI->lang->load('imglib');
 
1494
 
 
1495
                if (is_array($msg))
 
1496
                {
 
1497
                        foreach ($msg as $val)
 
1498
                        {
 
1499
 
 
1500
                                $msg = ($CI->lang->line($val) == FALSE) ? $val : $CI->lang->line($val);
 
1501
                                $this->error_msg[] = $msg;
 
1502
                                log_message('error', $msg);
 
1503
                        }
 
1504
                }
 
1505
                else
 
1506
                {
 
1507
                        $msg = ($CI->lang->line($msg) == FALSE) ? $msg : $CI->lang->line($msg);
 
1508
                        $this->error_msg[] = $msg;
 
1509
                        log_message('error', $msg);
 
1510
                }
 
1511
        }
 
1512
 
 
1513
        // --------------------------------------------------------------------
 
1514
 
 
1515
        /**
 
1516
         * Show error messages
 
1517
         *
 
1518
         * @access      public
 
1519
         * @param       string
 
1520
         * @return      string
 
1521
         */
 
1522
        function display_errors($open = '<p>', $close = '</p>')
 
1523
        {
 
1524
                $str = '';
 
1525
                foreach ($this->error_msg as $val)
 
1526
                {
 
1527
                        $str .= $open.$val.$close;
 
1528
                }
 
1529
 
 
1530
                return $str;
 
1531
        }
 
1532
 
 
1533
}
 
1534
// END Image_lib Class
 
1535
 
 
1536
/* End of file Image_lib.php */
 
1537
/* Location: ./system/libraries/Image_lib.php */
 
 
b'\\ No newline at end of file'