Support for image manipulation using GD.
Class declared in MODPATH/image/classes/Image/GD.php on line 3.
string(11) "imagerotate"string(16) "imageconvolution"string(11) "imagefilter"string(16) "imagelayereffect"integer 1
integer 2
integer 3
integer 4
integer 5
integer 6
integer 17
integer 18
string $default_driverdefault driver: GD, ImageMagick, etc
string(2) "GD"string $fileimage file path
NULL
integer $heightimage height
NULL
string $mimemime type of the image
NULL
integer $typeone of the IMAGETYPE_* constants
NULL
integer $widthimage width
NULL
array(0) bool FALSE
NULL
NULL
Runs Image_GD::check and loads the image.
string
$file
required - Image file path voidpublic function __construct($file)
{
if (!Image_GD::$_checked) {
// Run the install check
Image_GD::check();
}
parent::__construct($file);
// Set the image creation function name
switch ($this->type) {
case IMAGETYPE_JPEG:
$create = 'imagecreatefromjpeg';
break;
case IMAGETYPE_GIF:
$create = 'imagecreatefromgif';
break;
case IMAGETYPE_PNG:
$create = 'imagecreatefrompng';
break;
}
if (!isset($create) OR ! function_exists($create)) {
throw new Kohana_Exception('Installed GD does not support :type images', [':type' => image_type_to_extension($this->type, false)]);
}
// Save function for future use
$this->_create_function = $create;
// Save filename for lazy loading
$this->_image = $this->file;
}Destroys the loaded image to free up resources.
voidpublic function __destruct()
{
if (is_resource($this->_image)) {
// Free all resources
imagedestroy($this->_image);
}
}Checks if GD is enabled and verify that key methods exist, some of which require GD to be bundled with PHP. Exceptions will be thrown from those methods when GD is not bundled.
booleanpublic static function check()
{
if (!function_exists('gd_info')) {
throw new Kohana_Exception('GD is either not installed or not enabled, check your configuration');
}
$functions = [
Image_GD::IMAGEROTATE,
Image_GD::IMAGECONVOLUTION,
Image_GD::IMAGEFILTER,
Image_GD::IMAGELAYEREFFECT
];
foreach ($functions as $function) {
Image_GD::$_available_functions[$function] = function_exists($function);
}
if (defined('GD_VERSION')) {
// Get the version via a constant, available in PHP 5.2.4+
$version = GD_VERSION;
} else {
// Get the version information
$info = gd_info();
// Extract the version number
preg_match('/\d+\.\d+(?:\.\d+)?/', $info['GD Version'], $matches);
// Get the major version
$version = $matches[0];
}
if (!version_compare($version, '2.0.1', '>=')) {
throw new Kohana_Exception('Image_GD requires GD version :required or greater, you have :version', ['required' => '2.0.1', ':version' => $version]);
}
return Image_GD::$_checked = true;
}Render the current image.
echo $image;
The output of this function is binary and must be rendered with the appropriate Content-Type header or it will not be displayed correctly!
stringpublic function __toString()
{
try {
// Render the current image
return $this->render();
} catch (Exception $e) {
if (is_object(Kohana::$log)) {
// Get the text of the exception
$error = Kohana_Exception::text($e);
// Add this exception to the log
Kohana::$log->add(Log::ERROR, $error);
}
// Showing any kind of error will be "inside" image data
return '';
}
}Set the background color of an image. This is only useful for images with alpha transparency.
// Make the image background black
$image->background('#000');
// Make the image background black with 50% opacity
$image->background('#000', 50);
string
$color
required - Hexadecimal color value integer
$opacity
= integer 100 - Background opacity: 0-100 $thispublic function background($color, $opacity = 100)
{
if ($color[0] === '#') {
// Remove the pound
$color = substr($color, 1);
}
if (strlen($color) === 3) {
// Convert shorthand into longhand hex notation
$color = preg_replace('/./', '$0$0', $color);
}
// Convert the hex into RGB values
list ($r, $g, $b) = array_map('hexdec', str_split($color, 2));
// The opacity must be in the range of 0 to 100
$opacity = min(max($opacity, 0), 100);
$this->_do_background($r, $g, $b, $opacity);
return $this;
}Crop an image to the given size. Either the width or the height can be omitted and the current width or height will be used.
If no offset is specified, the center of the axis will be used. If an offset of true is specified, the bottom of the axis will be used.
// Crop the image to 200x200 pixels, from the center
$image->crop(200, 200);
integer
$width
required - New width integer
$height
required - New height mixed
$offset_x
= NULL - Offset from the left mixed
$offset_y
= NULL - Offset from the top $thispublic function crop($width, $height, $offset_x = null, $offset_y = null)
{
if ($width > $this->width) {
// Use the current width
$width = $this->width;
}
if ($height > $this->height) {
// Use the current height
$height = $this->height;
}
if ($offset_x === null) {
// Center the X offset
$offset_x = round(($this->width - $width) / 2);
} elseif ($offset_x === true) {
// Bottom the X offset
$offset_x = $this->width - $width;
} elseif ($offset_x < 0) {
// Set the X offset from the right
$offset_x = $this->width - $width + $offset_x;
}
if ($offset_y === null) {
// Center the Y offset
$offset_y = round(($this->height - $height) / 2);
} elseif ($offset_y === true) {
// Bottom the Y offset
$offset_y = $this->height - $height;
} elseif ($offset_y < 0) {
// Set the Y offset from the bottom
$offset_y = $this->height - $height + $offset_y;
}
// Determine the maximum possible width and height
$max_width = $this->width - $offset_x;
$max_height = $this->height - $offset_y;
if ($width > $max_width) {
// Use the maximum available width
$width = $max_width;
}
if ($height > $max_height) {
// Use the maximum available height
$height = $max_height;
}
$this->_do_crop($width, $height, $offset_x, $offset_y);
return $this;
}Loads an image and prepares it for manipulation.
$image = Image::factory('upload/test.jpg');
string
$file
required - Image file path string
$driver
= NULL - Driver type: GD, ImageMagick, etc Imagepublic static function factory($file, $driver = null)
{
if ($driver === null) {
// Use the driver from configuration file or default one
$configured_driver = Kohana::$config->load('image.default_driver');
$driver = ($configured_driver) ? $configured_driver : Image::$default_driver;
}
// Set the class name
$class = 'Image_' . $driver;
return new $class($file);
}Flip the image along the horizontal or vertical axis.
// Flip the image from top to bottom
$image->flip(Image::HORIZONTAL);
// Flip the image from left to right
$image->flip(Image::VERTICAL);
integer
$direction
required - Direction: Image::HORIZONTAL, Image::VERTICAL $thispublic function flip($direction)
{
if ($direction !== Image::HORIZONTAL) {
// Flip vertically
$direction = Image::VERTICAL;
}
$this->_do_flip($direction);
return $this;
}Add a reflection to an image. The most opaque part of the reflection will be equal to the opacity setting and fade out to full transparent. Alpha transparency is preserved.
// Create a 50 pixel reflection that fades from 0-100% opacity
$image->reflection(50);
// Create a 50 pixel reflection that fades from 100-0% opacity
$image->reflection(50, 100, true);
// Create a 50 pixel reflection that fades from 0-60% opacity
$image->reflection(50, 60, true);
By default, the reflection will be go from transparent at the top to opaque at the bottom.
integer
$height
= NULL - Reflection height integer
$opacity
= integer 100 - Reflection opacity: 0-100 boolean
$fade_in
= bool FALSE - True to fade in, false to fade out $thispublic function reflection($height = null, $opacity = 100, $fade_in = false)
{
if ($height === null OR $height > $this->height) {
// Use the current height
$height = $this->height;
}
// The opacity must be in the range of 0 to 100
$opacity = min(max($opacity, 0), 100);
$this->_do_reflection($height, $opacity, $fade_in);
return $this;
}Render the image and return the binary string.
// Render the image at 50% quality
$data = $image->render(null, 50);
// Render the image as a PNG
$data = $image->render('png');
string
$type
= NULL - Image type to return: png, jpg, gif, etc integer
$quality
= integer 100 - Quality of image: 1-100 stringpublic function render($type = null, $quality = 100)
{
if ($type === null) {
// Use the current image type
$type = image_type_to_extension($this->type, false);
}
return $this->_do_render($type, $quality);
}Resize the image to the given size. Either the width or the height can be omitted and the image will be resized proportionally.
// Resize to 200 pixels on the shortest side
$image->resize(200, 200);
// Resize to 200x200 pixels, keeping aspect ratio
$image->resize(200, 200, Image::INVERSE);
// Resize to 500 pixel width, keeping aspect ratio
$image->resize(500, null);
// Resize to 500 pixel height, keeping aspect ratio
$image->resize(null, 500);
// Resize to 200x500 pixels, ignoring aspect ratio
$image->resize(200, 500, Image::NONE);
integer
$width
= NULL - New width integer
$height
= NULL - New height integer
$master
= NULL - Master dimension $thispublic function resize($width = null, $height = null, $master = null)
{
if ($master === null) {
// Choose the master dimension automatically
$master = Image::AUTO;
}
// Image::WIDTH and Image::HEIGHT deprecated. You can use it in old projects,
// but in new you must pass empty value for non-master dimension
elseif ($master == Image::WIDTH AND ! empty($width)) {
$master = Image::AUTO;
// Set empty height for backward compatibility
$height = null;
} elseif ($master == Image::HEIGHT AND ! empty($height)) {
$master = Image::AUTO;
// Set empty width for backward compatibility
$width = null;
}
if (empty($width)) {
if ($master === Image::NONE) {
// Use the current width
$width = $this->width;
} else {
// If width not set, master will be height
$master = Image::HEIGHT;
}
}
if (empty($height)) {
if ($master === Image::NONE) {
// Use the current height
$height = $this->height;
} else {
// If height not set, master will be width
$master = Image::WIDTH;
}
}
switch ($master) {
case Image::AUTO:
// Choose direction with the greatest reduction ratio
$master = ($this->width / $width) > ($this->height / $height) ? Image::WIDTH : Image::HEIGHT;
break;
case Image::INVERSE:
// Choose direction with the minimum reduction ratio
$master = ($this->width / $width) > ($this->height / $height) ? Image::HEIGHT : Image::WIDTH;
break;
}
switch ($master) {
case Image::WIDTH:
// Recalculate the height based on the width proportions
$height = $this->height * $width / $this->width;
break;
case Image::HEIGHT:
// Recalculate the width based on the height proportions
$width = $this->width * $height / $this->height;
break;
case Image::PRECISE:
// Resize to precise size
$ratio = $this->width / $this->height;
if ($width / $height > $ratio) {
$height = $this->height * $width / $this->width;
} else {
$width = $this->width * $height / $this->height;
}
break;
}
// Convert the width and height to integers, minimum value is 1px
$width = max(round($width), 1);
$height = max(round($height), 1);
$this->_do_resize($width, $height);
return $this;
}Rotate the image by a given amount.
// Rotate 45 degrees clockwise
$image->rotate(45);
// Rotate 90% counter-clockwise
$image->rotate(-90);
integer
$degrees
required - Degrees to rotate: -360-360 $thispublic function rotate($degrees)
{
// Make the degrees an integer
$degrees = (int) $degrees;
if ($degrees > 180) {
do {
// Keep subtracting full circles until the degrees have normalized
$degrees -= 360;
} while ($degrees > 180);
}
if ($degrees < -180) {
do {
// Keep adding full circles until the degrees have normalized
$degrees += 360;
} while ($degrees < -180);
}
$this->_do_rotate($degrees);
return $this;
}Save the image. If the filename is omitted, the original image will be overwritten.
// Save the image as a PNG
$image->save('saved/cool.png');
// Overwrite the original image
$image->save();
If the file exists, but is not writable, an exception will be thrown.
If the file does not exist, and the directory is not writable, an exception will be thrown.
string
$file
= NULL - New image path integer
$quality
= integer 100 - Quality of image: 1-100 booleanpublic function save($file = null, $quality = 100)
{
if ($file === null) {
// Overwrite the file
$file = $this->file;
}
if (is_file($file)) {
if (!is_writable($file)) {
throw new Kohana_Exception('File must be writable: :file', [':file' => Debug::path($file)]);
}
} else {
// Get the directory of the file
$directory = realpath(pathinfo($file, PATHINFO_DIRNAME));
if (!is_dir($directory) OR ! is_writable($directory)) {
throw new Kohana_Exception('Directory must be writable: :directory', [':directory' => Debug::path($directory)]);
}
}
// The quality must be in the range of 1 to 100
$quality = min(max($quality, 1), 100);
return $this->_do_save($file, $quality);
}Sharpen the image by a given amount.
// Sharpen the image by 20%
$image->sharpen(20);
integer
$amount
required - Amount to sharpen: 1-100 $thispublic function sharpen($amount)
{
// The amount must be in the range of 1 to 100
$amount = min(max($amount, 1), 100);
$this->_do_sharpen($amount);
return $this;
}Add a watermark to an image with a specified opacity. Alpha transparency will be preserved.
If no offset is specified, the center of the axis will be used. If an offset of true is specified, the bottom of the axis will be used.
// Add a watermark to the bottom right of the image
$mark = Image::factory('upload/watermark.png');
$image->watermark($mark, true, true);
Image
$watermark
required - Watermark Image instance integer
$offset_x
= NULL - Offset from the left integer
$offset_y
= NULL - Offset from the top integer
$opacity
= integer 100 - Opacity of watermark: 1-100 $thispublic function watermark(Image $watermark, $offset_x = null, $offset_y = null, $opacity = 100)
{
if ($offset_x === null) {
// Center the X offset
$offset_x = round(($this->width - $watermark->width) / 2);
} elseif ($offset_x === true) {
// Bottom the X offset
$offset_x = $this->width - $watermark->width;
} elseif ($offset_x < 0) {
// Set the X offset from the right
$offset_x = $this->width - $watermark->width + $offset_x;
}
if ($offset_y === null) {
// Center the Y offset
$offset_y = round(($this->height - $watermark->height) / 2);
} elseif ($offset_y === true) {
// Bottom the Y offset
$offset_y = $this->height - $watermark->height;
} elseif ($offset_y < 0) {
// Set the Y offset from the bottom
$offset_y = $this->height - $watermark->height + $offset_y;
}
// The opacity must be in the range of 1 to 100
$opacity = min(max($opacity, 1), 100);
$this->_do_watermark($watermark, $offset_x, $offset_y, $opacity);
return $this;
}Create an empty image with the given width and height.
integer
$width
required - Image width integer
$height
required - Image height resourceprotected function _create($width, $height)
{
// Create an empty image
$image = imagecreatetruecolor($width, $height);
// Do not apply alpha blending
imagealphablending($image, false);
// Save alpha levels
imagesavealpha($image, true);
return $image;
}Execute a background.
integer
$r
required - Red integer
$g
required - Green integer
$b
required - Blue integer
$opacity
required - Opacity voidprotected function _do_background($r, $g, $b, $opacity)
{
// Loads image if not yet loaded
$this->_load_image();
// Convert an opacity range of 0-100 to 127-0
$opacity = round(abs(($opacity * 127 / 100) - 127));
// Create a new background
$background = $this->_create($this->width, $this->height);
// Allocate the color
$color = imagecolorallocatealpha($background, $r, $g, $b, $opacity);
// Fill the image with white
imagefilledrectangle($background, 0, 0, $this->width, $this->height, $color);
// Alpha blending must be enabled on the background!
imagealphablending($background, true);
// Copy the image onto a white background to remove all transparency
if (imagecopy($background, $this->_image, 0, 0, 0, 0, $this->width, $this->height)) {
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $background;
}
}Execute a crop.
integer
$width
required - New width integer
$height
required - New height integer
$offset_x
required - Offset from the left integer
$offset_y
required - Offset from the top voidprotected function _do_crop($width, $height, $offset_x, $offset_y)
{
// Create the temporary image to copy to
$image = $this->_create($width, $height);
// Loads image if not yet loaded
$this->_load_image();
// Execute the crop
if (imagecopyresampled($image, $this->_image, 0, 0, $offset_x, $offset_y, $width, $height, $width, $height)) {
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $image;
// Reset the width and height
$this->width = imagesx($image);
$this->height = imagesy($image);
}
}Execute a flip.
integer
$direction
required - Direction to flip voidprotected function _do_flip($direction)
{
// Create the flipped image
$flipped = $this->_create($this->width, $this->height);
// Loads image if not yet loaded
$this->_load_image();
if ($direction === Image::HORIZONTAL) {
for ($x = 0; $x < $this->width; $x++) {
// Flip each row from top to bottom
imagecopy($flipped, $this->_image, $x, 0, $this->width - $x - 1, 0, 1, $this->height);
}
} else {
for ($y = 0; $y < $this->height; $y++) {
// Flip each column from left to right
imagecopy($flipped, $this->_image, 0, $y, 0, $this->height - $y - 1, $this->width, 1);
}
}
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $flipped;
// Reset the width and height
$this->width = imagesx($flipped);
$this->height = imagesy($flipped);
}Execute a reflection.
integer
$height
required - Reflection height integer
$opacity
required - Reflection opacity boolean
$fade_in
required - True to fade out, false to fade in voidprotected function _do_reflection($height, $opacity, $fade_in)
{
if (empty(Image_GD::$_available_functions[Image_GD::IMAGEFILTER])) {
throw new Kohana_Exception('This method requires :function, which is only available in the bundled version of GD', [':function' => 'imagefilter']);
}
// Loads image if not yet loaded
$this->_load_image();
// Convert an opacity range of 0-100 to 127-0
$opacity = round(abs(($opacity * 127 / 100) - 127));
if ($opacity < 127) {
// Calculate the opacity stepping
$stepping = (127 - $opacity) / $height;
} else {
// Avoid a "divide by zero" error
$stepping = 127 / $height;
}
// Create the reflection image
$reflection = $this->_create($this->width, $this->height + $height);
// Copy the image to the reflection
imagecopy($reflection, $this->_image, 0, 0, 0, 0, $this->width, $this->height);
for ($offset = 0; $height >= $offset; $offset++) {
// Read the next line down
$src_y = $this->height - $offset - 1;
// Place the line at the bottom of the reflection
$dst_y = $this->height + $offset;
if ($fade_in === true) {
// Start with the most transparent line first
$dst_opacity = round($opacity + ($stepping * ($height - $offset)));
} else {
// Start with the most opaque line first
$dst_opacity = round($opacity + ($stepping * $offset));
}
// Create a single line of the image
$line = $this->_create($this->width, 1);
// Copy a single line from the current image into the line
imagecopy($line, $this->_image, 0, 0, 0, $src_y, $this->width, 1);
// Colorize the line to add the correct alpha level
imagefilter($line, IMG_FILTER_COLORIZE, 0, 0, 0, $dst_opacity);
// Copy a the line into the reflection
imagecopy($reflection, $line, 0, $dst_y, 0, 0, $this->width, 1);
}
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $reflection;
// Reset the width and height
$this->width = imagesx($reflection);
$this->height = imagesy($reflection);
}Execute a render.
string
$type
required - Image type: png, jpg, gif, etc integer
$quality
required - Quality stringprotected function _do_render($type, $quality)
{
// Loads image if not yet loaded
$this->_load_image();
// Get the save function and IMAGETYPE
list($save, $type) = $this->_save_function($type, $quality);
// Capture the output
ob_start();
// Render the image
$status = isset($quality) ? $save($this->_image, null, $quality) : $save($this->_image, null);
if ($status === true AND $type !== $this->type) {
// Reset the image type and mime type
$this->type = $type;
$this->mime = image_type_to_mime_type($type);
}
return ob_get_clean();
}Execute a resize.
integer
$width
required - New width integer
$height
required - New height voidprotected function _do_resize($width, $height)
{
// Presize width and height
$pre_width = $this->width;
$pre_height = $this->height;
// Loads image if not yet loaded
$this->_load_image();
// Test if we can do a resize without resampling to speed up the final resize
if ($width > ($this->width / 2) AND $height > ($this->height / 2)) {
// The maximum reduction is 10% greater than the final size
$reduction_width = round($width * 1.1);
$reduction_height = round($height * 1.1);
while ($pre_width / 2 > $reduction_width AND $pre_height / 2 > $reduction_height) {
// Reduce the size using an O(2n) algorithm, until it reaches the maximum reduction
$pre_width /= 2;
$pre_height /= 2;
}
// Create the temporary image to copy to
$image = $this->_create($pre_width, $pre_height);
if (imagecopyresized($image, $this->_image, 0, 0, 0, 0, $pre_width, $pre_height, $this->width, $this->height)) {
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $image;
}
}
// Create the temporary image to copy to
$image = $this->_create($width, $height);
// Execute the resize
if (imagecopyresampled($image, $this->_image, 0, 0, 0, 0, $width, $height, $pre_width, $pre_height)) {
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $image;
// Reset the width and height
$this->width = imagesx($image);
$this->height = imagesy($image);
}
}Execute a rotation.
integer
$degrees
required - Degrees to rotate voidprotected function _do_rotate($degrees)
{
if (empty(Image_GD::$_available_functions[Image_GD::IMAGEROTATE])) {
throw new Kohana_Exception('This method requires :function, which is only available in the bundled version of GD', [':function' => 'imagerotate']);
}
// Loads image if not yet loaded
$this->_load_image();
// Transparent black will be used as the background for the uncovered region
$transparent = imagecolorallocatealpha($this->_image, 0, 0, 0, 127);
// Rotate, setting the transparent color
$image = imagerotate($this->_image, 360 - $degrees, $transparent, 1);
// Save the alpha of the rotated image
imagesavealpha($image, true);
// Get the width and height of the rotated image
$width = imagesx($image);
$height = imagesy($image);
if (imagecopymerge($this->_image, $image, 0, 0, 0, 0, $width, $height, 100)) {
// Swap the new image for the old one
imagedestroy($this->_image);
$this->_image = $image;
// Reset the width and height
$this->width = $width;
$this->height = $height;
}
}Execute a save.
string
$file
required - New image filename integer
$quality
required - Quality booleanprotected function _do_save($file, $quality)
{
// Loads image if not yet loaded
$this->_load_image();
// Get the extension of the file
$extension = pathinfo($file, PATHINFO_EXTENSION);
// Get the save function and IMAGETYPE
list($save, $type) = $this->_save_function($extension, $quality);
// Save the image to a file
$status = isset($quality) ? $save($this->_image, $file, $quality) : $save($this->_image, $file);
if ($status === true AND $type !== $this->type) {
// Reset the image type and mime type
$this->type = $type;
$this->mime = image_type_to_mime_type($type);
}
return true;
}Execute a sharpen.
integer
$amount
required - Amount to sharpen voidprotected function _do_sharpen($amount)
{
if (empty(Image_GD::$_available_functions[Image_GD::IMAGECONVOLUTION])) {
throw new Kohana_Exception('This method requires :function, which is only available in the bundled version of GD', [':function' => 'imageconvolution']);
}
// Loads image if not yet loaded
$this->_load_image();
// Amount should be in the range of 18-10
$amount = round(abs(-18 + ($amount * 0.08)), 2);
// Gaussian blur matrix
$matrix = [
[-1, -1, -1],
[-1, $amount, -1],
[-1, -1, -1],
];
// Perform the sharpen
if (imageconvolution($this->_image, $matrix, $amount - 8, 0)) {
// Reset the width and height
$this->width = imagesx($this->_image);
$this->height = imagesy($this->_image);
}
}Execute a watermarking.
Image
$watermark
required - $image watermarking Image integer
$offset_x
required - Offset from the left integer
$offset_y
required - Offset from the top integer
$opacity
required - Opacity of watermark voidprotected function _do_watermark(Image $watermark, $offset_x, $offset_y, $opacity)
{
if (empty(Image_GD::$_available_functions[Image_GD::IMAGELAYEREFFECT])) {
throw new Kohana_Exception('This method requires :function, which is only available in the bundled version of GD', [':function' => 'imagelayereffect']);
}
// Loads image if not yet loaded
$this->_load_image();
// Create the watermark image resource
$overlay = imagecreatefromstring($watermark->render());
imagesavealpha($overlay, true);
// Get the width and height of the watermark
$width = imagesx($overlay);
$height = imagesy($overlay);
if ($opacity < 100) {
// Convert an opacity range of 0-100 to 127-0
$opacity = round(abs(($opacity * 127 / 100) - 127));
// Allocate transparent gray
$color = imagecolorallocatealpha($overlay, 127, 127, 127, $opacity);
// The transparent image will overlay the watermark
imagelayereffect($overlay, IMG_EFFECT_OVERLAY);
// Fill the background with the transparent color
imagefilledrectangle($overlay, 0, 0, $width, $height, $color);
}
// Alpha blending must be enabled on the background!
imagealphablending($this->_image, true);
if (imagecopy($this->_image, $overlay, $offset_x, $offset_y, 0, 0, $width, $height)) {
// Destroy the overlay image
imagedestroy($overlay);
}
}Loads an image into GD.
voidprotected function _load_image()
{
if (!is_resource($this->_image)) {
// Gets create function
$create = $this->_create_function;
// Open the temporary image
$this->_image = $create($this->file);
// Preserve transparency when saving
imagesavealpha($this->_image, true);
}
}Get the GD saving function and image type for this extension. Also normalizes the quality setting
string
$extension
required - Image type: png, jpg, etc byref integer
$quality
required - Image quality array - Save function, IMAGETYPE_* constantprotected function _save_function($extension, & $quality)
{
if (!$extension) {
// Use the current image type
$extension = image_type_to_extension($this->type, false);
}
switch (strtolower($extension)) {
case 'jpg':
case 'jpe':
case 'jpeg':
// Save a JPG file
$save = 'imagejpeg';
$type = IMAGETYPE_JPEG;
break;
case 'gif':
// Save a GIF file
$save = 'imagegif';
$type = IMAGETYPE_GIF;
// GIFs do not a quality setting
$quality = null;
break;
case 'png':
// Save a PNG file
$save = 'imagepng';
$type = IMAGETYPE_PNG;
// Use a compression level of 9 (does not affect quality!)
$quality = 9;
break;
default:
throw new Kohana_Exception('Installed GD does not support :type images', [':type' => $extension]);
break;
}
return [$save, $type];
}