classes/kohana/image/gd.php

   1 <?php defined('SYSPATH') or die('No direct script access.');
   2 /**
   3  * Image manipulation class using {@link  http://php.net/gd GD}.
   4  *
   5  * @package    Image
   6  * @author     Kohana Team
   7  * @copyright  (c) 2008-2009 Kohana Team
   8  * @license    http://kohanaphp.com/license.html
   9  */
  10 class Kohana_Image_GD extends Image {
  11
  12         public static function check()
  13         {
  14                 if ( ! function_exists('gd_info'))
  15                 {
  16                         throw new Kohana_Exception('GD is either not installed or not enabled, check your configuration');
  17                 }
  18
  19                 if (defined('GD_BUNDLED'))
  20                 {
  21                         // Get the version via a constant, available in PHP 5.
  22                         $bundled = GD_BUNDLED;
  23                 }
  24                 else
  25                 {
  26                         // Get the version information
  27                         $bundled = current(gd_info());
  28
  29                         // Extract the bundled status
  30                         $bundled = (bool) preg_match('/\bbundled\b/i', $bundled);
  31                 }
  32
  33                 if ( ! $bundled)
  34                 {
  35                         throw new Kohana_Exception('Image_GD requires GD to be bundled with PHP');
  36                 }
  37
  38                 if (defined('GD_VERSION'))
  39                 {
  40                         // Get the version via a constant, available in PHP 5.2.4+
  41                         $version = GD_VERSION;
  42                 }
  43                 else
  44                 {
  45                         // Get the version information
  46                         $version = current(gd_info());
  47
  48                         // Extract the version number
  49                         preg_match('/\d+\.\d+(?:\.\d+)?/', $version, $matches);
  50
  51                         // Get the major version
  52                         $version = $matches[0];
  53                 }
  54
  55                 if ( ! version_compare($version, '2.0', '>='))
  56                 {
  57                         throw new Kohana_Exception('Image_GD requires GD version 2.0 or greater, you have :version',
  58                                 array(':version' => $version));
  59                 }
  60
  61                 return Image_GD::$_checked = TRUE;
  62         }
  63
  64         // Temporary image resource
  65         protected $_image;
  66
  67         public function __construct($file)
  68         {
  69                 if ( ! Image_GD::$_checked)
  70                 {
  71                         // Run the install check
  72                         Image_GD::check();
  73                 }
  74
  75                 parent::__construct($file);
  76
  77                 // Set the image creation function name
  78                 switch ($this->type)
  79                 {
  80                         case IMAGETYPE_JPEG:
  81                                 $create = 'imagecreatefromjpeg';
  82                         break;
  83                         case IMAGETYPE_GIF:
  84                                 $create = 'imagecreatefromgif';
  85                         break;
  86                         case IMAGETYPE_PNG:
  87                                 $create = 'imagecreatefrompng';
  88                         break;
  89                 }
  90
  91                 if ( ! isset($create) OR ! function_exists($create))
  92                 {
  93                         throw new Kohana_Exception('Installed GD does not support :type images',
  94                                 array(':type' => image_type_to_extension($this->type, FALSE)));
  95                 }
  96
  97                 // Open the temporary image
  98                 $this->_image = $create($this->file);
  99
 100                 // Preserve transparency when saving
 101                 imagesavealpha($this->_image, TRUE);
 102         }
 103
 104         public function __destruct()
 105         {
 106                 if (is_resource($this->_image))
 107                 {
 108                         // Free all resources
 109                         imagedestroy($this->_image);
 110                 }
 111         }
 112
 113         protected function _do_resize($width, $height)
 114         {
 115                 // Presize width and height
 116                 $pre_width = $this->width;
 117                 $pre_height = $this->height;
 118
 119                 // Test if we can do a resize without resampling to speed up the final resize
 120                 if ($width > ($this->width / 2) AND $height > ($this->height / 2))
 121                 {
 122                         // The maximum reduction is 10% greater than the final size
 123                         $reduction_width  = round($width  * 1.1);
 124                         $reduction_height = round($height * 1.1);
 125
 126                         while ($pre_width / 2 > $reduction_width AND $pre_height / 2 > $reduction_height)
 127                         {
 128                                 // Reduce the size using an O(2n) algorithm, until it reaches the maximum reduction
 129                                 $pre_width /= 2;
 130                                 $pre_height /= 2;
 131                         }
 132
 133                         // Create the temporary image to copy to
 134                         $image = $this->_create($pre_width, $pre_height);
 135
 136                         if (imagecopyresized($image, $this->_image, 0, 0, 0, 0, $pre_width, $pre_height, $this->width, $this->height))
 137                         {
 138                                 // Swap the new image for the old one
 139                                 imagedestroy($this->_image);
 140                                 $this->_image = $image;
 141                         }
 142                 }
 143
 144                 // Create the temporary image to copy to
 145                 $image = $this->_create($width, $height);
 146
 147                 // Execute the resize
 148                 if (imagecopyresampled($image, $this->_image, 0, 0, 0, 0, $width, $height, $pre_width, $pre_height))
 149                 {
 150                         // Swap the new image for the old one
 151                         imagedestroy($this->_image);
 152                         $this->_image = $image;
 153
 154                         // Reset the width and height
 155                         $this->width  = imagesx($image);
 156                         $this->height = imagesy($image);
 157                 }
 158         }
 159
 160         protected function _do_crop($width, $height, $offset_x, $offset_y)
 161         {
 162                 // Create the temporary image to copy to
 163                 $image = $this->_create($width, $height);
 164
 165                 // Execute the crop
 166                 if (imagecopyresampled($image, $this->_image, 0, 0, $offset_x, $offset_y, $width, $height, $width, $height))
 167                 {
 168                         // Swap the new image for the old one
 169                         imagedestroy($this->_image);
 170                         $this->_image = $image;
 171
 172                         // Reset the width and height
 173                         $this->width  = imagesx($image);
 174                         $this->height = imagesy($image);
 175                 }
 176         }
 177
 178         protected function _do_rotate($degrees)
 179         {
 180                 // Transparent black will be used as the background for the uncovered region
 181                 $transparent = imagecolorallocatealpha($this->_image, 0, 0, 0, 127);
 182
 183                 // Rotate, setting the transparent color
 184                 $image = imagerotate($this->_image, 360 - $degrees, $transparent, 1);
 185
 186                 // Save the alpha of the rotated image
 187                 imagesavealpha($image, TRUE);
 188
 189                 // Get the width and height of the rotated image
 190                 $width  = imagesx($image);
 191                 $height = imagesy($image);
 192
 193                 if (imagecopymerge($this->_image, $image, 0, 0, 0, 0, $width, $height, 100))
 194                 {
 195                         // Swap the new image for the old one
 196                         imagedestroy($this->_image);
 197                         $this->_image = $image;
 198
 199                         // Reset the width and height
 200                         $this->width  = $width;
 201                         $this->height = $height;
 202                 }
 203         }
 204
 205         protected function _do_flip($direction)
 206         {
 207                 // Create the flipped image
 208                 $flipped = $this->_create($this->width, $this->height);
 209
 210                 if ($direction === Image::HORIZONTAL)
 211                 {
 212                         for ($x = 0; $x < $this->width; $x++)
 213                         {
 214                                 // Flip each row from top to bottom
 215                                 imagecopy($flipped, $this->_image, $x, 0, $this->width - $x - 1, 0, 1, $this->height);
 216                         }
 217                 }
 218                 else
 219                 {
 220                         for ($y = 0; $y < $this->height; $y++)
 221                         {
 222                                 // Flip each column from left to right
 223                                 imagecopy($flipped, $this->_image, 0, $y, 0, $this->height - $y - 1, $this->width, 1);
 224                         }
 225                 }
 226
 227                 // Swap the new image for the old one
 228                 imagedestroy($this->_image);
 229                 $this->_image = $flipped;
 230
 231                 // Reset the width and height
 232                 $this->width  = imagesx($flipped);
 233                 $this->height = imagesy($flipped);
 234         }
 235
 236         protected function _do_sharpen($amount)
 237         {
 238                 // Amount should be in the range of 18-10
 239                 $amount = round(abs(-18 + ($amount * 0.08)), 2);
 240
 241                 // Gaussian blur matrix
 242                 $matrix = array
 243                 (
 244                         array(-1,   -1,    -1),
 245                         array(-1, $amount, -1),
 246                         array(-1,   -1,    -1),
 247                 );
 248
 249                 // Perform the sharpen
 250                 if (imageconvolution($this->_image, $matrix, $amount - 8, 0))
 251                 {
 252                         // Reset the width and height
 253                         $this->width  = imagesx($this->_image);
 254                         $this->height = imagesy($this->_image);
 255                 }
 256         }
 257
 258         protected function _do_reflection($height, $opacity, $fade_in)
 259         {
 260                 // Convert an opacity range of 0-100 to 127-0
 261                 $opacity = round(abs(($opacity * 127 / 100) - 127));
 262
 263                 if ($opacity < 127)
 264                 {
 265                         // Calculate the opacity stepping
 266                         $stepping = (127 - $opacity) / $height;
 267                 }
 268                 else
 269                 {
 270                         // Avoid a "divide by zero" error
 271                         $stepping = 127 / $height;
 272                 }
 273
 274                 // Create the reflection image
 275                 $reflection = $this->_create($this->width, $this->height + $height);
 276
 277                 // Copy the image to the reflection
 278                 imagecopy($reflection, $this->_image, 0, 0, 0, 0, $this->width, $this->height);
 279
 280                 for ($offset = 0; $height >= $offset; $offset++)
 281                 {
 282                         // Read the next line down
 283                         $src_y = $this->height - $offset - 1;
 284
 285                         // Place the line at the bottom of the reflection
 286                         $dst_y = $this->height + $offset;
 287
 288                         if ($fade_in === TRUE)
 289                         {
 290                                 // Start with the most transparent line first
 291                                 $dst_opacity = round($opacity + ($stepping * ($height - $offset)));
 292                         }
 293                         else
 294                         {
 295                                 // Start with the most opaque line first
 296                                 $dst_opacity = round($opacity + ($stepping * $offset));
 297                         }
 298
 299                         // Create a single line of the image
 300                         $line = $this->_create($this->width, 1);
 301
 302                         // Copy a single line from the current image into the line
 303                         imagecopy($line, $this->_image, 0, 0, 0, $src_y, $this->width, 1);
 304
 305                         // Colorize the line to add the correct alpha level
 306                         imagefilter($line, IMG_FILTER_COLORIZE, 0, 0, 0, $dst_opacity);
 307
 308                         // Copy a the line into the reflection
 309                         imagecopy($reflection, $line, 0, $dst_y, 0, 0, $this->width, 1);
 310                 }
 311
 312                 // Swap the new image for the old one
 313                 imagedestroy($this->_image);
 314                 $this->_image = $reflection;
 315
 316                 // Reset the width and height
 317                 $this->width  = imagesx($reflection);
 318                 $this->height = imagesy($reflection);
 319         }
 320
 321         protected function _do_watermark(Image $watermark, $offset_x, $offset_y, $opacity)
 322         {
 323                 // Create the watermark image resource
 324                 $overlay = imagecreatefromstring($watermark->render());
 325
 326                 // Get the width and height of the watermark
 327                 $width  = imagesx($overlay);
 328                 $height = imagesy($overlay);
 329
 330                 if ($opacity < 100)
 331                 {
 332                         // Convert an opacity range of 0-100 to 127-0
 333                         $opacity = round(abs(($opacity * 127 / 100) - 127));
 334
 335                         // Allocate transparent white
 336                         $color = imagecolorallocatealpha($overlay, 255, 255, 255, $opacity);
 337
 338                         // The transparent image will overlay the watermark
 339                         imagelayereffect($overlay, IMG_EFFECT_OVERLAY);
 340
 341                         // Fill the background with transparent white
 342                         imagefilledrectangle($overlay, 0, 0, $width, $height, $color);
 343                 }
 344
 345                 // Alpha blending must be enabled on the background!
 346                 imagealphablending($this->_image, TRUE);
 347
 348                 if (imagecopy($this->_image, $overlay, $offset_x, $offset_y, 0, 0, $width, $height))
 349                 {
 350                         // Destroy the overlay image
 351                         imagedestroy($overlay);
 352                 }
 353         }
 354
 355         protected function _do_background($r, $g, $b, $opacity)
 356         {
 357                 // Convert an opacity range of 0-100 to 127-0
 358                 $opacity = round(abs(($opacity * 127 / 100) - 127));
 359
 360                 // Create a new background
 361                 $background = $this->_create($this->width, $this->height);
 362
 363                 // Allocate the color
 364                 $color = imagecolorallocatealpha($background, $r, $g, $b, $opacity);
 365
 366                 // Fill the image with white
 367                 imagefilledrectangle($background, 0, 0, $this->width, $this->height, $color);
 368
 369                 // Alpha blending must be enabled on the background!
 370                 imagealphablending($background, TRUE);
 371
 372                 // Copy the image onto a white background to remove all transparency
 373                 if (imagecopy($background, $this->_image, 0, 0, 0, 0, $this->width, $this->height))
 374                 {
 375                         // Swap the new image for the old one
 376                         imagedestroy($this->_image);
 377                         $this->_image = $background;
 378                 }
 379         }
 380
 381         protected function _do_save($file, $quality)
 382         {
 383                 // Get the extension of the file
 384                 $extension = pathinfo($file, PATHINFO_EXTENSION);
 385
 386                 // Get the save function and IMAGETYPE
 387                 list($save, $type) = $this->_save_function($extension, $quality);
 388
 389                 // Save the image to a file
 390                 $status = isset($quality) ? $save($this->_image, $file, $quality) : $save($this->_image, $file);
 391
 392                 if ($status === TRUE AND $type !== $this->type)
 393                 {
 394                         // Reset the image type and mime type
 395                         $this->type = $type;
 396                         $this->mime = image_type_to_mime_type($type);
 397                 }
 398
 399                 return TRUE;
 400         }
 401
 402         protected function _do_render($type, $quality)
 403         {
 404                 // Get the save function and IMAGETYPE
 405                 list($save, $type) = $this->_save_function($type, $quality);
 406
 407                 // Capture the output
 408                 ob_start();
 409
 410                 // Render the image
 411                 $status = isset($quality) ? $save($this->_image, NULL, $quality) : $save($this->_image, NULL);
 412
 413                 if ($status === TRUE AND $type !== $this->type)
 414                 {
 415                         // Reset the image type and mime type
 416                         $this->type = $type;
 417                         $this->mime = image_type_to_mime_type($type);
 418                 }
 419
 420                 return ob_get_clean();
 421         }
 422
 423         /**
 424          * Get the GD saving function and image type for this extension.
 425          * Also normalizes the quality setting
 426          *
 427          * @throws  Kohana_Exception
 428          * @param   string   image type: png, jpg, etc
 429          * @param   integer  image quality
 430          * @return  array    save function, IMAGETYPE_* constant
 431          */
 432         protected function _save_function($extension, & $quality)
 433         {
 434                 switch (strtolower($extension))
 435                 {
 436                         case 'jpg':
 437                         case 'jpeg':
 438                                 // Save a JPG file
 439                                 $save = 'imagejpeg';
 440                                 $type = IMAGETYPE_JPEG;
 441                         break;
 442                         case 'gif':
 443                                 // Save a GIF file
 444                                 $save = 'imagegif';
 445                                 $type = IMAGETYPE_GIF;
 446
 447                                 // GIFs do not a quality setting
 448                                 $quality = NULL;
 449                         break;
 450                         case 'png':
 451                                 // Save a PNG file
 452                                 $save = 'imagepng';
 453                                 $type = IMAGETYPE_PNG;
 454
 455                                 // Use a compression level of 9 (does not affect quality!)
 456                                 $quality = 9;
 457                         break;
 458                         default:
 459                                 throw new Kohana_Exception('Installed GD does not support :type images',
 460                                         array(':type' => $type));
 461                         break;
 462                 }
 463
 464                 return array($save, $type);
 465         }
 466
 467         /**
 468          * Create an empty image with the given width and height.
 469          *
 470          * @param   integer   image width
 471          * @param   integer   image height
 472          * @return  resource
 473          */
 474         protected function _create($width, $height)
 475         {
 476                 // Create an empty image
 477                 $image = imagecreatetruecolor($width, $height);
 478
 479                 // Do not apply alpha blending
 480                 imagealphablending($image, FALSE);
 481
 482                 // Save alpha levels
 483                 imagesavealpha($image, TRUE);
 484
 485                 return $image;
 486         }
 487
 488 } // End Image_GD