Windy/EasyImages2.0
1
0
Fork 0
mirror of https://github.com/icret/EasyImages2.0.git synced 2025-01-08 11:58:03 +08:00
Code Issues Packages Projects Releases Wiki Activity
master
EasyImages2.0/app/Zebra_Image.php
icret 74bc2f401d changes
2023-03-09 02:42:50 +08:00

2128 lines
84 KiB
PHP
Raw Permalink Blame History

<?php
/**
* Methods used with the {@link resize()} method.
*/
define('ZEBRA_IMAGE_BOXED', 0);
define('ZEBRA_IMAGE_NOT_BOXED', 1);
define('ZEBRA_IMAGE_CROP_TOPLEFT', 2);
define('ZEBRA_IMAGE_CROP_TOPCENTER', 3);
define('ZEBRA_IMAGE_CROP_TOPRIGHT', 4);
define('ZEBRA_IMAGE_CROP_MIDDLELEFT', 5);
define('ZEBRA_IMAGE_CROP_CENTER', 6);
define('ZEBRA_IMAGE_CROP_MIDDLERIGHT', 7);
define('ZEBRA_IMAGE_CROP_BOTTOMLEFT', 8);
define('ZEBRA_IMAGE_CROP_BOTTOMCENTER', 9);
define('ZEBRA_IMAGE_CROP_BOTTOMRIGHT', 10);
// this enables handling of partially broken JPEG files without warnings/errors
ini_set('gd.jpeg_ignore_warning', '1');
/**
* A single-file, lightweight PHP library designed for efficient image manipulation featuring methods for modifying
* images and applying filters Supports WEBP format.
*
* Read more {@link https://github.com/stefangabos/Zebra_Image/ here}
*
* @author Stefan Gabos <contact@stefangabos.ro>
* @version 2.8.2 (last revision: January 25, 2023)
* @copyright © 2006 - 2023 Stefan Gabos
* @license https://www.gnu.org/licenses/lgpl-3.0.txt GNU LESSER GENERAL PUBLIC LICENSE
* @package Zebra_Image
*/
class Zebra_Image {
/**
* If set to `true`, JPEG images will be auto-rotated according to the {@link http://keyj.emphy.de/exif-orientation-rant/ Exif Orientation Tag}
* so that they are always shown correctly.
*
* > If set to `true` you must also enable exif-support with `--enable-exif`.<br>
* Windows users must enable both the `php_mbstring.dll` and `php_exif.dll` DLL's in `php.ini`.<br>
* `php_mbstring.dll` must be loaded before `php_exif.dll`, so adjust your php.ini accordingly.
* See {@link https://www.php.net/manual/en/exif.installation.php the manual}.
*
* Default is `false`
*
* @since 2.2.4
*
* @var boolean
*/
public $auto_handle_exif_orientation;
/**
* Indicates whether BMP images should be compressed with run-length encoding (RLE), or not.
*
* > Used only if PHP version is `7.2.0+` and the file at {@link target_path} is a `BMP` image, or it will be
* ignored otherwise.
*
* Default is `TRUE`
*
* @since 2.8.1
*
* @var boolean
*/
public $bmp_compressed;
/**
* Indicates the file system permissions to be set for newly created images.
*
* Better is to leave this setting as it is.
*
* If you know what you are doing, here is how you can calculate the permission levels:
*
* - 400 Owner Read
* - 200 Owner Write
* - 100 Owner Execute
* - 40 Group Read
* - 20 Group Write
* - 10 Group Execute
* - 4 Global Read
* - 2 Global Write
* - 1 Global Execute
*
* Default is `0755`
*
* @var integer
*/
public $chmod_value;
/**
* If set to `false`, images having both width and height smaller than the required width and height will be left
* untouched. {@link jpeg_quality} and {@link png_compression} will still apply!
*
* Available only for the {@link resize()} method.
*
* Default is `true`
*
* @var boolean
*/
public $enlarge_smaller_images;
/**
* In case of an error read this property's value to see the error's code.
*
* Possible error codes are:
*
* - `1` - source file could not be found
* - `2` - source file is not readable
* - `3` - could not write target file
* - `4` - unsupported source file type *(note that you will also get this for animated WEBP images!)*
* - `5` - unsupported target file type
* - `6` - GD library version does not support target file format
* - `7` - GD library is not installed!
* - `8` - "chmod" command is disabled via configuration
* - `9` - "exif_read_data" function is not available
*
* Default is `0` (no error)
*
* @var integer
*/
public $error;
/**
* Indicates whether the created image should be saved as a progressive JPEG.
*
* > Used only if the file at {@link target_path} is a `JPG/JPEG` image, or will be ignored otherwise.
*
* Default is `false`
*
* @since 2.5.0
*
* @var boolean
*/
public $jpeg_interlace;
/**
* Indicates the quality of the output image (better quality means bigger file size).
*
* > Used only if the file at {@link target_path} is a `JPG/JPEG` image, or it will be ignored otherwise.
*
* Range is `0` - `100`.
*
* Default is `85`
*
* @var integer
*/
public $jpeg_quality;
/**
* Indicates the compression level of the output image (lower compression means bigger file size).
*
* > Used only if PHP version is `5.1.2+` and the file at {@link target_path} is a `PNG` image, or it will be
* ignored otherwise.
*
* Range is `0` - `9`.
*
* Default is `9`
*
* @since 2.2
*
* @var integer
*/
public $png_compression;
/**
* Specifies whether upon resizing images should preserve their aspect ratio.
*
* > Available only for the {@link resize()} method.
*
* Default is `true`
*
* @var boolean
*/
public $preserve_aspect_ratio;
/**
* Indicates whether a target file should preserve the source file's date/time.
*
* Default is `true`
*
* @since 1.0.4
*
* @var boolean
*/
public $preserve_time;
/**
* Indicates whether the target image should have a `sharpen` filter applied to it.
*
* Can be very useful when creating thumbnails and should be used only when creating thumbnails.
*
* > The sharpen filter relies on the {@link https://www.php.net/manual/en/function.imageconvolution.php imageconvolution}
* function which is available for PHP version `5.1.0+`, and will leave the images unaltered for older versions!
*
* Default is `false`
*
* @since 2.2
*
* @var boolean
*/
public $sharpen_images;
/**
* Path to an image file to apply the transformations to.
*
* Supported file types are `BMP`, `GIF`, `JPEG`, `PNG` and `WEBP`.
*
* > `WEBP` support is available for PHP version `7.0.0+`.<br><br>
* Note that even though `WEBP` support was added to PHP in version `5.5.0`, it only started working with version
* `5.5.1`, while support for transparency was added with version `7.0.0`. As a result, I decided to make it
* available only if PHP version is at least `7.0.0`<br><br>
* Animated `WEBP` images are not currently supported by GD.
* See {@link https://github.com/libgd/libgd/issues/648 here} and {@link https://bugs.php.net/bug.php?id=79809&thanks=4 here}.
*
* > `BMP` support is available for PHP version `7.2.0+`
*
* @var string
*/
public $source_path;
/**
* Path (including file name) to where to save the transformed image.
*
* > Can be a different format than the file at {@link source_path}. The format of the transformed image will be
* determined by the file's extension. Supported file types are `BMP`, `GIF`, `JPEG`, `PNG` and `WEBP`.
*
* > `WEBP` support is available for PHP version `7.0.0+`.<br><br>
* Note that even though `WEBP` support was added to PHP in version `5.5.0`, it only started working with version
* `5.5.1`, while support for transparency was added with version `7.0.0`. As a result, I decided to make it
* available only if PHP version is at least `7.0.0`<br><br>
* Animated `WEBP` images are not currently supported by GD.
* See {@link https://github.com/libgd/libgd/issues/648 here} and {@link https://bugs.php.net/bug.php?id=79809&thanks=4 here}.
*
* > `BMP` support is available for PHP version `7.2.0+`
*
* @var string
*/
public $target_path;
/**
* Indicates the quality level of the output image.
*
* > Used only if PHP version is `7.0.0+` and the file at {@link target_path} is a `WEBP` image, or it will be
* ignored otherwise.
*
* Range is `0` - `100`
*
* Default is `80`
*
* @since 2.6.0
*
* @var integer
*/
public $webp_quality;
/**
* @var resource
*/
private $source_identifier;
/**
* @var mixed
*/
private $source_type;
/**
* @var int
*/
private $source_width;
/**
* @var int
*/
private $source_height;
/**
* @var array<int>
*/
private $source_transparent_color;
/**
* @var int
*/
private $source_transparent_color_index;
/**
* @var int
*/
private $source_time;
/**
* @var string
*/
private $target_type;
/**
* Constructor of the class.
*
* Initializes the class and the default properties.
*
* @return void
*/
public function __construct() {
// set default values for properties
$this->chmod_value = 0755;
$this->error = 0;
$this->jpeg_quality = 85;
$this->png_compression = 9;
$this->webp_quality = 80;
$this->preserve_aspect_ratio = $this->preserve_time = $this->enlarge_smaller_images = $this->bmp_compressed = true;
$this->sharpen_images = $this->auto_handle_exif_orientation = $this->jpeg_interlace = false;
$this->source_path = $this->target_path = '';
}
/**
* Applies one or more filters to the image given as {@link source_path} and outputs it as the file specified as
* {@link target_path}.
*
* > This method is available only if the {@link https://www.php.net/manual/en/function.imagefilter.php imagefilter}
* function is available (available from `PHP 5+`), and will leave images unaltered otherwise.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // apply the "grayscale" filter
* $img->apply_filter('grayscale');
*
* // apply the "contrast" filter
* $img->apply_filter('contrast', -20);
* </code>
*
* You can also apply multiple filters at once. In this case, the method requires a single argument, an array of
* arrays, containing the filters and associated arguments, where applicable:
*
* <code>
* // create a sepia effect
* // note how we're applying multiple filters at once
* // each filter is in its own array
* $img->apply_filter(array(
*
* // first we apply the "grayscale" filter
* array('grayscale'),
*
* // then we apply the "colorize" filter with 90, 60, 40 as
* // the values for red, green and blue
* array('colorize', 90, 60, 40),
*
* ));
* </code>
*
* @param mixed $filter The case-insensitive name of the filter to apply. Can be one of the following:
*
* - **brightness** - changes the brightness of the image; use `arg1` to set
* the level of brightness; the range of brightness is
* `-255` - `255`
* - **colorize** - adds specified RGB values to each pixel; use `arg1`,
* `arg2` and `arg3` in the form of `red`, `green` and
* `blue`, and `arg4` for the `alpha` channel; the range
* for each color is `-255` to `255` and `0` to `127` for
* the `alpha` where `0` indicates completely opaque
* while `127` indicates completely transparent; *alpha
* support is available for PHP 5.2.5+*
* - **contrast** - changes the contrast of the image; use `arg1` to set
* the level of contrast; the range of contrast is `-100`
* to `100`
* - **edgedetect** - uses edge detection to highlight the edges in the image
* - **emboss** - embosses the image
* - **gaussian_blur** - blurs the image using the Gaussian method
* - **grayscale** - converts the image into grayscale by changing the red,
* green and blue components to their weighted sum using
* the same coefficients as the REC.601 luma (Y') calculation;
* the alpha components are retained; for palette images
* the result may differ due to palette limitations
* - **mean_removal** - uses mean removal to achieve a *"sketchy"* effect
* - **negate** - reverses all the colors of the image
* - **pixelate** - applies pixelation effect to the image; use `arg1` to
* set the block size and `arg2` to set the pixelation
* effect mode; *this filter is available only for PHP
* 5.3.0+*
* - **selective_blur** - blurs the image
* - **scatter** - applies scatter effect to the image; use `arg1` and
* `arg2` to define the effect strength and additionally
* `arg3` to only apply the on select pixel colors
* - **smooth** - makes the image smoother; use `arg1` to set the level
* of smoothness; applies a 9-cell convolution matrix
* where center pixel has the weight of `arg1` and others
* weight of 1.0; the result is normalized by dividing
* the sum with `arg1` + 8.0 (sum of the matrix); any
* float is accepted, large value (in practice: 2048 or)
* more) = no change
*
* @param mixed $arg1 Used by the following filters:
* - **brightness** - sets the brightness level (`-255` to `255`)
* - **contrast** - sets the contrast level (`-100` to `100`)
* - **colorize** - sets the value of the red component (`-255` to `255`)
* - **pixelate** - sets the block size, in pixels
* - **scatter** - effect subtraction level; this must not be higher or
* equal to the addition level set with `arg3`
* - **smooth** - sets the smoothness level
*
* @param mixed $arg2 Used by the following filters:
* - **colorize** - sets the value of the green component (`-255` to `255`)
* - **pixelate** - whether to use advanced pixelation effect or not (defaults to `false`)
* - **scatter** - effect addition level
*
* @param mixed $arg3 Used by the following filters:
* - **colorize** - sets the value of the blue component (`-255` to `255`)
* - **scatter** - optional array indexed color values to apply effect at
*
* @param mixed $arg4 Used by the following filters:
* - **colorize** - alpha channel; a value between `0` and `127`. `0` indicates
* completely opaque while `127` indicates completely
* transparent
*
* @since 2.2.2
*
* @return boolean Returns `true` on success or false on error.
*
* If {@link https://www.php.net/manual/en/function.imagefilter.php imagefilter} is not
* available, the method will return `false` without setting an {@link error} code.
*
* If the requested filter doesn't exist, or invalid arguments are passed, the method
* will trigger a warning.
*
* If `false` is returned and you are sure that
* {@link https://www.php.net/manual/en/function.imagefilter.php imagefilter} exists and that
* the requested filter is valid, check the {@link error} property to see the error code.
*/
public function apply_filter($filter, $arg1 = '', $arg2 = '', $arg3 = '', $arg4 = '') {
// if "imagefilter" function exists and the requested filter exists
if (function_exists('imagefilter')) {
// if image resource was successfully created
if ($this->_create_from_source()) {
// prepare the target image
$target_identifier = $this->_prepare_image($this->source_width, $this->source_height, -1);
// copy the original image
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
0,
0,
$this->source_width,
$this->source_height,
$this->source_width,
$this->source_height
);
// if multiple filters are to be applied at once
if (is_array($filter)) {
// iterate through the filters
foreach ($filter as $arguments) {
// if filter exists
if (defined('IMG_FILTER_' . strtoupper($arguments[0]))) {
// try to apply the filter and trigger an error if the filter could not be applied
if (!@call_user_func_array('imagefilter', array_merge(array($target_identifier, constant('IMG_FILTER_' . strtoupper($arguments[0]))), array_slice($arguments, 1)))) {
trigger_error('Invalid arguments used for "' . strtoupper($arguments[0]) . '" filter', E_USER_WARNING);
}
// if filter doesn't exists, trigger an error
} else {
trigger_error('Filter "' . strtoupper($arguments[0]) . '" is not available', E_USER_WARNING);
}
}
// if a single filter is to be applied and it is available
} elseif (defined('IMG_FILTER_' . strtoupper($filter))) {
// get all the arguments passed to the method
$arguments = func_get_args();
// try to apply the filter and trigger an error if the filter could not be applied
if (!@call_user_func_array('imagefilter', array_merge(array($target_identifier, constant('IMG_FILTER_' . strtoupper($filter))), array_slice($arguments, 1)))) {
trigger_error('Invalid arguments used for "' . strtoupper($arguments[0]) . '" filter', E_USER_WARNING);
}
// if filter doesn't exists, trigger an error
} else {
trigger_error('Filter "' . strtoupper($filter) . '" is not available', E_USER_WARNING);
}
// write image
return $this->_write_image($target_identifier);
}
}
// if script gets this far, return false
// note that we do not set the error level as it has been already set
// by the _create_from_source() method earlier, if the case
return false;
}
/**
* Crops a portion of the image given as {@link source_path} and outputs it as the file specified as {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // crop a rectangle of 100x100 pixels, starting from the top-left corner
* $img->crop(0, 0, 100, 100);
* </code>
*
* @param integer $start_x x coordinate to start cropping from
*
* @param integer $start_y y coordinate to start cropping from
*
* @param integer $end_x x coordinate where to end the cropping
*
* @param integer $end_y y coordinate where to end the cropping
*
* @param mixed $background_color (Optional) A hexadecimal color value (like `#FFFFFF` or `#FFF`) used when
* the cropping coordinates are off-scale (negative values and/or values
* greater than the image's size) to fill the remaining space.
*
* When set to `-1` the script will preserve transparency for transparent `GIF`
* and `PNG` images. For non-transparent images the background will be black
* (`#000000`) in this case.
*
* Default is `-1`
*
* @since 1.0.4
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error code.
*/
public function crop($start_x, $start_y, $end_x, $end_y, $background_color = -1) {
// this method might be also called internally
// in this case, there's a sixth argument that points to an already existing image identifier
$args = func_get_args();
// if a sixth argument exists
// for PHP 8.0.0+ GD functions return and accept \GdImage objects instead of resources (https://php.watch/versions/8.0/gdimage)
if (isset($args[5]) && (is_resource($args[5]) || (version_compare(PHP_VERSION, '8.0.0', '>=') && $args[5] instanceof \GdImage))) {
// that it is the image identifier that we'll be using further on
$this->source_identifier = $args[5];
// set this to true so that the script will continue to execute at the next IF
$result = true;
// we need to make sure these are integers or PHP 8.1+ will show a warning
// https://php.watch/versions/8.1/deprecate-implicit-conversion-incompatible-float-string
$start_x = (int)$start_x;
$start_y = (int)$start_y;
$end_x = (int)$end_x;
$end_y = (int)$end_y;
// if method is called as usually
// try to create an image resource from source path
} else {
$result = $this->_create_from_source();
}
// if image resource was successfully created
if ($result !== false) {
// compute width and height
$width = $end_x - $start_x;
$height = $end_y - $start_y;
// prepare the target image
$target_identifier = $this->_prepare_image($width, $height, $background_color);
$dest_x = 0;
$dest_y = 0;
// if starting x is negative
if ($start_x < 0) {
// we are adjusting the position where we place the cropped image on the target image
$dest_x = abs($start_x);
// and crop starting from 0
$start_x = 0;
}
// if ending x is larger than the image's width, adjust the width we're showing
if ($end_x > ($image_width = imagesx($this->source_identifier))) {
$width = $image_width - $start_x;
}
// if starting y is negative
if ($start_y < 0) {
// we are adjusting the position where we place the cropped image on the target image
$dest_y = abs($start_y);
// and crop starting from 0
$start_y = 0;
}
// if ending y is larger than the image's height, adjust the height we're showing
if ($end_y > ($image_height = imagesy($this->source_identifier))) {
$height = $image_height - $start_y;
}
// crop the image
imagecopyresampled(
$target_identifier,
$this->source_identifier,
$dest_x,
$dest_y,
$start_x,
$start_y,
$width,
$height,
$width,
$height
);
// write image
return $this->_write_image($target_identifier);
}
// if script gets this far, return false
// note that we do not set the error level as it has been already set
// by the _create_from_source() method earlier
return false;
}
/**
* Flips both horizontally and vertically the image given as {@link source_path} and outputs the resulted image as
* {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // flip the image both horizontally and vertically
* $img->flip_both();
* </code>
*
* @since 2.1
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error code.
*/
public function flip_both() {
return $this->_flip('both');
}
/**
* Flips horizontally the image given as {@link source_path} and outputs the resulted image as {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // flip the image horizontally
* $img->flip_horizontal();
* </code>
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error code.
*/
public function flip_horizontal() {
return $this->_flip('horizontal');
}
/**
* Flips vertically the image given as {@link source_path} and outputs the resulted image as {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // flip the image vertically
* $img->flip_vertical();
* </code>
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error code.
*/
public function flip_vertical() {
return $this->_flip('vertical');
}
/**
* Resizes the image given as {@link source_path} and outputs the resulted image as {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // apply a "sharpen" filter to the resulting images
* $img->sharpen_images = true;
*
* // resize the image to exactly 150x150 pixels, without altering
* // aspect ratio, by using the CROP_CENTER method
* $img->resize(150, 150, ZEBRA_IMAGE_CROP_CENTER);
* </code>
*
* @param integer $width The width to resize the image to.
*
* If set to `0`, the width will be automatically adjusted, depending on the
* value of the `height` argument so that the image preserves its aspect ratio.
*
* If {@link preserve_aspect_ratio} is set to `true` and both this and the
* `height` arguments are values greater than `0`, the image will be resized
* to the exact required width and height and the aspect ratio will be
* preserved (see also the description for the `method` argument below on
* how can this be done).
*
* If {@link preserve_aspect_ratio} is set to `false`, the image will be
* resized to the required width and the aspect ratio will be ignored.
*
* If both `width` and `height` are set to `0`, a copy of the source image
* will be created. {@link jpeg_quality} and {@link png_compression} will
* still apply!
*
* If either `width` or `height` are set to `0`, the script will consider
* the value of {@link preserve_aspect_ratio} to bet set to `true` regardless
* of its actual value!
*
* @param integer $height The height to resize the image to.
*
* If set to `0`, the height will be automatically adjusted, depending on
* the value of the `width` argument so that the image preserves its aspect
* ratio.
*
* If {@link preserve_aspect_ratio} is set to `true` and both this and the
* `width` arguments are values greater than `0`, the image will be resized
* to the exact required width and height and the aspect ratio will be
* preserved (see also the description for the `method` argument below on
* how can this be done).
*
* If {@link preserve_aspect_ratio} is set to `false`, the image will be
* resized to the required height and the aspect ratio will be ignored.
*
* If both `width` and `height` are set to `0`, a copy of the source image
* will be created. {@link jpeg_quality} and {@link png_compression} will
*
* If either `width` or `height` are set to `0`, the script will consider
* the value of {@link preserve_aspect_ratio} to bet set to `true` regardless
* of its actual value!
*
* @param int $method (Optional) Method to use when resizing images to exact width and height
* while preserving aspect ratio.
*
* If the {@link preserve_aspect_ratio} property is set to `true` and both
* the `width` and `height` arguments are values greater than `0`, the image
* will be resized to the exact given width and height and the aspect ratio
* will be preserved by using on of the following methods:
*
* - **ZEBRA_IMAGE_BOXED** - the image will be scaled so that it will fit
* in a box with the given width and height (both width/height will be
* smaller or equal to the required width/height) and then it will
* be centered both horizontally and vertically; the blank area will be
* filled with the color specified by the `bgcolor` argument. (the blank
* area will be filled only if the image is not transparent!)
*
* - **ZEBRA_IMAGE_NOT_BOXED** - the image will be scaled so that it
* *could* fit in a box with the given width and height but will not be
* enclosed in a box with given width and height. The new width/height
* will be both smaller or equal to the required width/height.
*
* - **ZEBRA_IMAGE_CROP_TOPLEFT**
* - **ZEBRA_IMAGE_CROP_TOPCENTER**
* - **ZEBRA_IMAGE_CROP_TOPRIGHT**
* - **ZEBRA_IMAGE_CROP_MIDDLELEFT**
* - **ZEBRA_IMAGE_CROP_CENTER**
* - **ZEBRA_IMAGE_CROP_MIDDLERIGHT**
* - **ZEBRA_IMAGE_CROP_BOTTOMLEFT**
* - **ZEBRA_IMAGE_CROP_BOTTOMCENTER**
* - **ZEBRA_IMAGE_CROP_BOTTOMRIGHT**
*
* For the methods involving crop, first the image is scaled so that both
* its sides are equal or greater than the respective sizes of the bounding
* box; next, a region of required width and height will be cropped from
* indicated region of the resulted image.
*
* Default is `ZEBRA_IMAGE_CROP_CENTER`
*
* @param mixed $background_color (Optional) The hexadecimal color (like `#FFFFFF` or `#FFF`) of the blank
* area. See the `method` argument.
*
* When set to `-1` the script will preserve transparency for transparent `GIF`
* and `PNG` images. For non-transparent images the background will be white
* (`#FFFFFF`) in this case.
*
* Default is `-1`
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see what went
* wrong.
*/
public function resize($width = 0, $height = 0, $method = ZEBRA_IMAGE_CROP_CENTER, $background_color = -1) {
// we need to make sure these are integers or PHP 8.1+ will show a warning
// https://php.watch/versions/8.1/deprecate-implicit-conversion-incompatible-float-string
$width = (int)$width;
$height = (int)$height;
// if image resource was successfully created
if ($this->_create_from_source()) {
// if either width or height is to be adjusted automatically
// set a flag telling the script that, even if $preserve_aspect_ratio is set to false
// treat everything as if it was set to true
if ($width == 0 || $height == 0) {
$auto_preserve_aspect_ratio = true;
}
// if aspect ratio needs to be preserved
if ($this->preserve_aspect_ratio || isset($auto_preserve_aspect_ratio)) {
// if height is given and width is to be computed accordingly
if ($width == 0 && $height > 0) {
// get the original image's aspect ratio
$aspect_ratio = $this->source_width / $this->source_height;
// the target image's height is as given as argument to the method
$target_height = $height;
// compute the target image's width, preserving the aspect ratio
$target_width = round($height * $aspect_ratio);
// if width is given and height is to be computed accordingly
} elseif ($width > 0 && $height == 0) {
// get the original image's aspect ratio
$aspect_ratio = $this->source_height / $this->source_width;
// the target image's width is as given as argument to the method
$target_width = $width;
// compute the target image's height, preserving the aspect ratio
$target_height = round($width * $aspect_ratio);
// if both width and height are given and ZEBRA_IMAGE_BOXED or ZEBRA_IMAGE_NOT_BOXED methods are to be used
} elseif ($width > 0 && $height > 0 && ($method == 0 || $method == 1)) {
// compute the horizontal and vertical aspect ratios
$vertical_aspect_ratio = $height / $this->source_height;
$horizontal_aspect_ratio = $width / $this->source_width;
// if the image's newly computed height would be inside the bounding box
if (round($horizontal_aspect_ratio * $this->source_height) < $height) {
// the target image's width is as given as argument to the method
$target_width = $width;
// compute the target image's height so that the image will stay inside the bounding box
$target_height = round($horizontal_aspect_ratio * $this->source_height);
// otherwise
} else {
// the target image's height is as given as argument to the method
$target_height = $height;
// compute the target image's width so that the image will stay inside the bounding box
$target_width = round($vertical_aspect_ratio * $this->source_width);
}
// if both width and height are given and image is to be cropped in order to get to the required size
} elseif ($width > 0 && $height > 0 && $method > 1 && $method < 11) {
// compute the horizontal and vertical aspect ratios
$vertical_aspect_ratio = $this->source_height / $height;
$horizontal_aspect_ratio = $this->source_width / $width;
// we'll use one of the two
$aspect_ratio =
$vertical_aspect_ratio < $horizontal_aspect_ratio ?
$vertical_aspect_ratio :
$horizontal_aspect_ratio;
// compute the target image's width, preserving the aspect ratio
$target_width = round($this->source_width / $aspect_ratio);
// compute the target image's height, preserving the aspect ratio
$target_height = round($this->source_height / $aspect_ratio);
// for any other case
} else {
// we will create a copy of the source image
$target_width = $this->source_width;
$target_height = $this->source_height;
}
// if aspect ratio does not need to be preserved
} else {
// compute the target image's width
$target_width = ($width > 0 ? $width : $this->source_width);
// compute the target image's height
$target_height = ($height > 0 ? $height : $this->source_height);
}
// if
if (
// all images are to be resized - including images that are smaller than the given width/height
$this->enlarge_smaller_images ||
// smaller images than the given width/height are to be left untouched
// but current image has at leas one side that is larger than the required width/height
($width > 0 && $height > 0 ?
($this->source_width > $width || $this->source_height > $height) :
($this->source_width > $target_width || $this->source_height > $target_height)
)
) {
// if
if (
// aspect ratio needs to be preserved AND
($this->preserve_aspect_ratio || isset($auto_preserve_aspect_ratio)) &&
// both width and height are given
($width > 0 && $height > 0) &&
// images are to be cropped
($method > 1 && $method < 11)
) {
// prepare the target image
$target_identifier = $this->_prepare_image($target_width, $target_height, $background_color);
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
0,
0,
$target_width,
$target_height,
$this->source_width,
$this->source_height
);
// do the crop according to the required method
switch ($method) {
// if image needs to be cropped from the top-left corner
case ZEBRA_IMAGE_CROP_TOPLEFT:
// crop accordingly
return $this->crop(
0,
0,
$width,
$height,
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the top-center
case ZEBRA_IMAGE_CROP_TOPCENTER:
// crop accordingly
return $this->crop(
intval(floor(($target_width - $width) / 2)),
0,
intval(floor(($target_width - $width) / 2) + $width),
$height,
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the top-right corner
case ZEBRA_IMAGE_CROP_TOPRIGHT:
// crop accordingly
return $this->crop(
$target_width - $width,
0,
$target_width,
$height,
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the middle-left
case ZEBRA_IMAGE_CROP_MIDDLELEFT:
// crop accordingly
return $this->crop(
0,
intval(floor(($target_height - $height) / 2)),
$width,
intval(floor(($target_height - $height) / 2) + $height),
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the center of the image
case ZEBRA_IMAGE_CROP_CENTER:
// crop accordingly
return $this->crop(
intval(floor(($target_width - $width) / 2)),
intval(floor(($target_height - $height) / 2)),
intval(floor(($target_width - $width) / 2) + $width),
intval(floor(($target_height - $height) / 2) + $height),
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the middle-right
case ZEBRA_IMAGE_CROP_MIDDLERIGHT:
// crop accordingly
return $this->crop(
$target_width - $width,
intval(floor(($target_height - $height) / 2)),
$target_width,
intval(floor(($target_height - $height) / 2) + $height),
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the bottom-left corner
case ZEBRA_IMAGE_CROP_BOTTOMLEFT:
// crop accordingly
return $this->crop(
0,
$target_height - $height,
$width,
$target_height,
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the bottom-center
case ZEBRA_IMAGE_CROP_BOTTOMCENTER:
// crop accordingly
return $this->crop(
intval(floor(($target_width - $width) / 2)),
$target_height - $height,
intval(floor(($target_width - $width) / 2) + $width),
$target_height,
$background_color,
$target_identifier // crop this resource instead
);
// if image needs to be cropped from the bottom-right corner
case ZEBRA_IMAGE_CROP_BOTTOMRIGHT:
// crop accordingly
return $this->crop(
$target_width - $width,
$target_height - $height,
$target_width,
$target_height,
$background_color,
$target_identifier // crop this resource instead
);
}
// if aspect ratio doesn't need to be preserved or
// it needs to be preserved and method is ZEBRA_IMAGE_BOXED or ZEBRA_IMAGE_NOT_BOXED
} else {
// prepare the target image
$target_identifier = $this->_prepare_image(
($width > 0 && $height > 0 && $method !== ZEBRA_IMAGE_NOT_BOXED ? $width : $target_width),
($width > 0 && $height > 0 && $method !== ZEBRA_IMAGE_NOT_BOXED ? $height : $target_height),
$background_color
);
imagecopyresampled(
$target_identifier,
$this->source_identifier,
($width > 0 && $height > 0 && $method !== ZEBRA_IMAGE_NOT_BOXED ? ($width - $target_width) / 2 : 0),
($width > 0 && $height > 0 && $method !== ZEBRA_IMAGE_NOT_BOXED ? ($height - $target_height) / 2 : 0),
0,
0,
$target_width,
$target_height,
$this->source_width,
$this->source_height
);
// if script gets this far, write the image to disk
return $this->_write_image($target_identifier);
}
// if we get here it means that
// smaller images than the given width/height are to be left untouched
// therefore, we save the image as it is
} else {
// prepare the target image
$target_identifier = $this->_prepare_image($this->source_width, $this->source_height, $background_color);
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
0,
0,
$this->source_width,
$this->source_height,
$this->source_width,
$this->source_height
);
// previously to 2.2.7 I was simply calling the _write_images() method without the code from above this
// comment and therefore, when resizing transparent images to a format which doesn't support transparency
// and the "enlarge_smaller_images" property being set to FALSE, the "background_color" argument was not
// applied and lead to unexpected background colors for the resulting images
return $this->_write_image($target_identifier);
}
}
// if script gets this far return false
// note that we do not set the error level as it has been already set
// by the _create_from_source() method earlier
return false;
}
/**
* Rotates the image given as {@link source_path} and outputs the resulted image as {@link target_path}.
*
* <code>
* // include the Zebra_Image library
* // (you don't need this if you installed using composer)
* require 'path/to/Zebra_Image.php';
*
* // instantiate the class
* $img = new Zebra_Image();
*
* // a source image
* // (where "ext" is one of the supported file types extension)
* $img->source_path = 'path/to/source.ext';
*
* // path to where should the resulting image be saved
* // note that by simply setting a different extension to the file will
* // instruct the script to create an image of that particular type
* $img->target_path = 'path/to/target.ext';
*
* // rotate the image 45 degrees, clockwise
* $img->rotate(45);
* </code>
*
* @param double $angle Angle by which to rotate the image clockwise.
*
* Between `0` and `360`.
*
* @param mixed $background_color (Optional) The hexadecimal color (like `#FFFFFF` or `#FFF`) of the
* uncovered zone after the rotation.
*
* When set to `-1` the script will preserve transparency for transparent `GIF`
* and `PNG` images. For non-transparent images the background will be white
* (`#FFFFFF`) in this case.
*
* Default is `-1`.
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error
* code.
*/
public function rotate($angle, $background_color = -1) {
// don't do anything if no angle is given
if ($angle == 0 || $angle == 360) {
return true;
}
// get function arguments
$arguments = func_get_args();
// if a third argument exists
$use_existing_source = (isset($arguments[2]) && $arguments[2] === false);
// if we came here just to fix orientation or if image resource was successfully created
if ($use_existing_source || $this->_create_from_source()) {
// there is a bug in GD when angle is 90, 180, 270
// transparency is not preserved
if ($angle % 90 === 0) {
$angle += 0.001;
}
// angles are given clockwise but imagerotate works counterclockwise so we need to negate our value
$angle = -$angle;
// if the uncovered zone after the rotation is to be transparent
if ($background_color == -1) {
// if target image is a PNG or an WEBP
if ($this->target_type === 'png' || $this->target_type === 'webp') {
// allocate a transparent color
$background_color = imagecolorallocatealpha($this->source_identifier, 0, 0, 0, 127);
// if target image is a GIF
} elseif ($this->target_type === 'gif') {
// if source image was a GIF and a transparent color existed
if ($this->source_type == IMAGETYPE_GIF && $this->source_transparent_color_index >= 0) {
// use that color
$background_color = imagecolorallocate(
$this->source_identifier,
$this->source_transparent_color['red'],
$this->source_transparent_color['green'],
$this->source_transparent_color['blue']
);
// if image had no transparent color
} else {
// allocate a transparent color
$background_color = imagecolorallocate($this->source_identifier, 255, 255, 255);
// make color transparent
// (imagecolorallocate may return FALSE, that's why the elvis operator)
imagecolortransparent($this->source_identifier, $background_color ? : null);
}
// for other image types
} else {
// use white as the color of uncovered zone after the rotation
$background_color = imagecolorallocate($this->source_identifier, 255, 255, 255);
}
// if a background color is given
} else {
// convert the color to RGB values
$background_color = $this->_hex2rgb($background_color);
// allocate the color to the image identifier
$background_color = imagecolorallocate(
$this->source_identifier,
$background_color['r'],
$background_color['g'],
$background_color['b']
);
}
// rotate the image
$target_identifier = imagerotate($this->source_identifier, $angle, $background_color ?: 0);
// if we called this method from the _create_from_source() method
// because we are fixing orientation
if ($use_existing_source) {
// make any further method work on the rotated image
$this->source_identifier = $target_identifier;
// update the width and height of the image to the values
// of the rotated image
$this->source_width = imagesx($target_identifier);
$this->source_height = imagesy($target_identifier);
return true;
// write image otherwise
} else {
return $this->_write_image($target_identifier);
}
}
// if script gets this far return false
// note that we do not set the error level as it has been already set
// by the _create_from_source() method earlier
return false;
}
/**
* Returns an array containing the image identifier representing the image obtained from {@link $source_path}, the
* image's width and height and the image's type.
*
* @return mixed
*
* @access private
*/
private function _create_from_source() {
// perform some error checking first
// if the GD library is not installed
if (!function_exists('gd_info')) {
// save the error level and stop the execution of the script
$this->error = 7;
return false;
// if source file does not exist
} elseif (!is_file($this->source_path)) {
// save the error level and stop the execution of the script
$this->error = 1;
return false;
// if source file is not readable
} elseif (!is_readable($this->source_path)) {
// save the error level and stop the execution of the script
$this->error = 2;
return false;
// if target file is same as source file and source file is not writable
} elseif ($this->target_path == $this->source_path && !is_writable($this->source_path)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
// try to get source file width, height and type
// and if it founds an unsupported file type
} elseif (
($this->source_type = strtolower(substr($this->source_path, strrpos($this->source_path, '.') + 1))) &&
!(version_compare(PHP_VERSION, '7.0.0') < 0 && $this->source_type === 'webp') &&
!(version_compare(PHP_VERSION, '7.2.0') < 0 && $this->source_type === 'bmp') &&
// getimagesize() doesn't support WEBP until 7.1.0 so we will handle that differently
($this->source_path !== 'webp' && !list($this->source_width, $this->source_height, $this->source_type) = @getimagesize($this->source_path))
) {
// save the error level and stop the execution of the script
$this->error = 4;
return false;
// if no errors so far
} else {
// get target file's type based on the file extension
$this->target_type = strtolower(substr($this->target_path, strrpos($this->target_path, '.') + 1));
// if we are working with WEBP images
if ($this->source_type === 'webp') {
// define this constant which is not available until PHP 7.1.0
if (!defined('IMAGETYPE_WEBP')) {
define('IMAGETYPE_WEBP', 18);
}
// if PHP version is less than 7.1.0
if (version_compare(PHP_VERSION, '7.1.0') < 0) {
// flag these so we compute them later on
$this->source_width = -1;
$this->source_height = -1;
}
// set value to newly created constant
$this->source_type = IMAGETYPE_WEBP;
}
// create an image from file using extension dependant function
// checks for file extension
switch ($this->source_type) {
// if BMP
case IMAGETYPE_BMP:
// create an image from file
$identifier = imagecreatefrombmp($this->source_path);
break;
// if GIF
case IMAGETYPE_GIF:
// create an image from file
$identifier = imagecreatefromgif($this->source_path);
// get the index of the transparent color (if any)
if (($this->source_transparent_color_index = imagecolortransparent($identifier)) >= 0) {
// get the transparent color's RGB values
// there are GIF images which *are* transparent and everything works as expected, but
// imagecolortransparent() returns a color that is outside the range of colors in the image's pallette...
// therefore, we check first if the index is in range
if ($this->source_transparent_color_index < imagecolorstotal($identifier)) {
// if transparent color index is in range, get the transparent color's RGB values
$this->source_transparent_color = @imagecolorsforindex($identifier, $this->source_transparent_color_index);
// if transparent color index is outside the range of colors in the image's pallette
} else {
// get RGB values for color at index 0
// (so that we don't have error further in the code)
$this->source_transparent_color = @imagecolorsforindex($identifier, 0);
}
}
break;
// if PNG
case IMAGETYPE_PNG:
// create an image from file
$identifier = imagecreatefrompng($this->source_path);
// disable blending
imagealphablending($identifier, false);
// save full alpha channel information
imagesavealpha($identifier, true);
break;
// if JPEG
case IMAGETYPE_JPEG:
// create an image from file
$identifier = imagecreatefromjpeg($this->source_path);
break;
// if WEBP
case IMAGETYPE_WEBP:
// because animated WEBP images are not supported
// we need to check if this is such a file
// WEBP file header https://developers.google.com/speed/webp/docs/riff_container
// solution from by Sven Liivak https://stackoverflow.com/questions/45190469/how-to-identify-whether-webp-image-is-static-or-animated#answer-52333192
$fh = fopen($this->source_path, 'rb');
// let's see if this is the "Extended" file format
fseek($fh, 12);
// if this is the extended file format
if (fread($fh, 4) === 'VP8X') {
// look for the "Animation (A)" bit
fseek($fh, 20);
// is this is an animated WEBP?
$is_animated = ((ord(fread($fh, 1)) >> 1) & 1);
}
fclose($fh);
// if this is an animated WEBP
if (isset($is_animated) && $is_animated) {
// flag as unsupported file type
$this->error = 4;
return false;
}
// create an image from file
$identifier = imagecreatefromwebp($this->source_path);
// if we are working with WEBP images but PHP version is less than 7.1.0
if ($this->source_width === -1) {
// use these to get image's width and height as support for WEBP in getimagesize() was added only
// beginning with PHP 7.1.0
$this->source_width = imagesx($identifier);
$this->source_height = imagesy($identifier);
}
// disable blending
imagealphablending($identifier, false);
// save full alpha channel information
imagesavealpha($identifier, true);
break;
default:
// if unsupported file type
// note that we call this if the file is not BMP, GIF, JPG, PNG or WEBP even though the getimagesize function
// might handle more image types
$this->error = 4;
return false;
}
}
// if target file has to have the same timestamp as the source image
// save it as a global property of the class
if ($this->preserve_time) {
$this->source_time = filemtime($this->source_path);
}
// make available the source image's identifier
$this->source_identifier = $identifier;
// for JPEG files, if we need to handle exif orientation automatically
if ($this->auto_handle_exif_orientation && $this->source_type === IMAGETYPE_JPEG) {
// if "exif_read_data" function is not available, return false
if (!function_exists('exif_read_data')) {
// save the error level and stop the execution of the script
$this->error = 9;
return false;
// if "exif_read_data" function is available, EXIF information is available, orientation information is available and orientation needs fixing
} elseif (($exif = @exif_read_data($this->source_path)) && isset($exif['Orientation']) && in_array($exif['Orientation'], array(3, 6, 8))) {
// fix the orientation
switch ($exif['Orientation']) {
case 3:
// 180 rotate left
$this->rotate(180, -1, false);
break;
case 6:
// 90 rotate right
$this->rotate(90, -1, false);
break;
case 8:
// 90 rotate left
$this->rotate(-90, -1, false);
break;
}
}
}
return true;
}
/**
* Flips horizontally, vertically or both ways the image given as {@link source_path}.
*
* @param string $orientation How to flip the image.
*
* Allowed values are `horizontal`, `vertical` and `both`.
*
* @since 2.1
*
* @return boolean Returns TRUE on success or FALSE on error.
*
* If FALSE is returned, check the {@link error} property to see the error code.
* @access private
*
*/
private function _flip($orientation) {
// if image resource was successfully created
if ($this->_create_from_source()) {
// prepare the target image
$target_identifier = $this->_prepare_image($this->source_width, $this->source_height, -1);
// flip according to $orientation
switch ($orientation) {
case 'horizontal':
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
($this->source_width - 1),
0,
$this->source_width,
$this->source_height,
-$this->source_width,
$this->source_height
);
break;
case 'vertical':
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
0,
($this->source_height - 1),
$this->source_width,
$this->source_height,
$this->source_width,
-$this->source_height
);
break;
case 'both':
imagecopyresampled(
$target_identifier,
$this->source_identifier,
0,
0,
($this->source_width - 1),
($this->source_height - 1),
$this->source_width,
$this->source_height,
-$this->source_width,
-$this->source_height
);
break;
}
// write image
return $this->_write_image($target_identifier);
}
// if script gets this far, return false
// note that we do not set the error level as it has been already set
// by the _create_from_source() method earlier
return false;
}
/**
* Converts a hexadecimal representation of a color (i.e. `#123456` or `#AAA`) to a RGB representation.
*
* The RGB values will be a value between `0` and `255` each.
*
* @param string $color Hexadecimal representation of a color (i.e. `#123456` or `#AAA`).
*
* @param string $default_on_error (Optional) Hexadecimal representation of a color to be used in case `$color`
* is not recognized as a hexadecimal color.
*
* Default is `#FFFFFF`
*
* @return array<int> Returns an associative array with the values of (R)ed, (G)reen and (B)lue
*
* @access private
*/
private function _hex2rgb($color, $default_on_error = '#FFFFFF') {
// if color is not formatted correctly
// use the default color
if (preg_match('/^#?([a-f]|[0-9]){3}(([a-f]|[0-9]){3})?$/i', $color) == 0) {
$color = $default_on_error;
}
// trim off the "#" prefix from $background_color
$color = ltrim($color, '#');
// if color is given using the shorthand (i.e. "FFF" instead of "FFFFFF")
if (strlen($color) == 3) {
$tmp = '';
// take each value
// and duplicate it
for ($i = 0; $i < 3; $i++) {
$tmp .= str_repeat($color[$i], 2);
}
// the color in it's full, 6 characters length notation
$color = $tmp;
}
// decimal representation of the color
$int = hexdec($color);
// extract and return the RGB values
return array(
'r' => 0xFF & ($int >> 0x10),
'g' => 0xFF & ($int >> 0x8),
'b' => 0xFF & $int
);
}
/**
* Creates a blank image of given width, height and background color.
*
* @param integer $width Width of the new image.
*
* @param integer $height Height of the new image.
*
* @param mixed $background_color (Optional) The hexadecimal color of the background.
*
* Can also be `-1` case in which the script will try to create a transparent
* image, if possible.
*
* Default is `#FFFFFF`.
*
* @return resource Returns the identifier of the newly created image.
*
* @access private
*/
private function _prepare_image($width, $height, $background_color = '#FFFFFF') {
// create a blank image
$identifier = imagecreatetruecolor((int)$width <= 0 ? 1 : (int)$width, (int)$height <= 0 ? 1 : (int)$height);
// if we are creating a transparent image, and image type supports transparency
if ($background_color === -1 && $this->target_type !== 'jpg') {
// disable blending
imagealphablending($identifier, false);
// allocate a transparent color
$background_color = imagecolorallocatealpha($identifier, 0, 0, 0, 127);
// we also need to set this for saving GIFs
imagecolortransparent($identifier, $background_color);
// save full alpha channel information
imagesavealpha($identifier, true);
// if we are not creating a transparent image
} else {
// convert hex color to rgb
$background_color = $this->_hex2rgb($background_color);
// prepare the background color
$background_color = imagecolorallocate($identifier, $background_color['r'], $background_color['g'], $background_color['b']);
}
// fill the image with the background color
imagefill($identifier, 0, 0, $background_color);
// return the image's identifier
return $identifier;
}
/**
* Sharpens images. Useful when creating thumbnails.
*
* Code taken from the comments at {@link https://www.php.net/manual/en/function.imageconvolution.php}.
*
* > This function will yield a result only for PHP version 5.1.0+ and will leave the image unaltered for older
* versions!
*
* @param resource $image An image identifier
*
* @return resource Returns the sharpened image
*
* @access private
*/
private function _sharpen_image($image) {
// if the "sharpen_images" is set to true and we're running an appropriate version of PHP
// (the "imageconvolution" is available only for PHP 5.1.0+)
if ($this->sharpen_images && version_compare(PHP_VERSION, '5.1.0') >= 0) {
// the convolution matrix as an array of three arrays of three floats
$matrix = array(
array(-1.2, -1, -1.2),
array(-1, 20, -1),
array(-1.2, -1, -1.2),
);
// the divisor of the matrix
$divisor = array_sum(array_map('array_sum', $matrix));
// color offset
$offset = 0;
// sharpen image
imageconvolution($image, $matrix, $divisor, $offset);
}
// return the image's identifier
return $image;
}
/**
* Creates a new image from given image identifier having the extension as specified by {@link target_path}.
*
* @param resource $identifier An image identifier
*
* @return boolean Returns `true` on success or `false` on error.
*
* If `false` is returned, check the {@link error} property to see the error code.
*
* @access private
*/
private function _write_image($identifier) {
// sharpen image if it's required
$this->_sharpen_image($identifier);
// save interlaced JPEG images if required
if (in_array($this->target_type, array('jpg', 'jpeg')) && $this->jpeg_interlace) {
imageinterlace($identifier, 1);
}
// image saving process goes according to required extension
switch ($this->target_type) {
// if BMP
case 'bmp':
// if GD support for this file type is not available
if (!function_exists('imagebmp')) {
// save the error level and stop the execution of the script
$this->error = 6;
return false;
// if, for some reason, file could not be created
} elseif (@!imagebmp($identifier, $this->target_path, $this->bmp_compressed)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
}
break;
// if GIF
case 'gif':
// if GD support for this file type is not available
// in version 1.6 of GD the support for GIF files was dropped see
// https://www.php.net/manual/en/function.imagegif.php#function.imagegif.notes
if (!function_exists('imagegif')) {
// save the error level and stop the execution of the script
$this->error = 6;
return false;
// if, for some reason, file could not be created
} elseif (@!imagegif($identifier, $this->target_path)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
}
break;
// if JPEG
case 'jpg':
case 'jpeg':
// if GD support for this file type is not available
if (!function_exists('imagejpeg')) {
// save the error level and stop the execution of the script
$this->error = 6;
return false;
// if, for some reason, file could not be created
} elseif (@!imagejpeg($identifier, $this->target_path, $this->jpeg_quality)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
}
break;
// if PNG
case 'png':
// if GD support for this file type is not available
if (!function_exists('imagepng')) {
// save the error level and stop the execution of the script
$this->error = 6;
return false;
// if, for some reason, file could not be created
} elseif (@!imagepng($identifier, $this->target_path, $this->png_compression)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
}
break;
// if WEBP
case 'webp':
// if GD support for this file type is not available
if (!function_exists('imagewebp')) {
// save the error level and stop the execution of the script
$this->error = 6;
return false;
// if, for some reason, file could not be created
} elseif (@!imagewebp($identifier, $this->target_path, $this->webp_quality)) {
// save the error level and stop the execution of the script
$this->error = 3;
return false;
}
break;
// if not a supported file extension
default:
// save the error level and stop the execution of the script
$this->error = 5;
return false;
}
// get a list of functions disabled via configuration
$disabled_functions = @ini_get('disable_functions');
// if the 'chmod' function is not disabled via configuration
if ($disabled_functions === '' || strpos('chmod', $disabled_functions) === false) {
// chmod the file
chmod($this->target_path, intval($this->chmod_value, 8));
// save the error level
} else {
$this->error = 8;
}
// if target file has to have the same timestamp as the source image
if ($this->preserve_time) {
// touch the newly created file
@touch($this->target_path, $this->source_time);
}
// free memory
imagedestroy($this->source_identifier);
imagedestroy($identifier);
// for PHP 8.0.0+ imagedestroy is no-op (https://php.watch/versions/8.0/gdimage)
// and we have to use unset()
if (version_compare(PHP_VERSION, '8.0.0', '>=')) {
unset($this->source_identifier);
unset($identifier);
}
// return true
return true;
}
}
Reference in New Issue View Git Blame Copy Permalink