Your IP : 10.10.0.253
<?php
/**
* @version $Id: ImageType_GD.php 10831 2013-05-29 19:32:17Z btowles $
* @author RocketTheme http://www.rockettheme.com
* @copyright Copyright (C) 2007 - 2020 RocketTheme, LLC
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPLv2 only
*
* Derived from
*
* PhpThumb GD Thumb Class Definition File
*
* This file contains the definition for the RokCommon_Image_ImageType_GD object
*
* PHP Version 5 with GD 2.0+
* PhpThumb : PHP Thumb Library <http://phpthumb.gxdlabs.com>
* Copyright (c) 2009, Ian Selby/Gen X Design
*
* Author(s): Ian Selby <ian@gen-x-design.com>
*
* Licensed under the MIT License
* Redistributions of files must retain the above copyright notice.
*
* @author Ian Selby <ian@gen-x-design.com>
* @copyright Copyright (c) 2009 Gen X Design
* @link http://phpthumb.gxdlabs.com
* @license http://www.opensource.org/licenses/mit-license.php The MIT License
* @version 3.0
* @package PhpThumb
* @filesource
*/
/**
* RokCommon_Image_ImageType_GD Class Definition
*
* This is the GD Implementation of the PHP Thumb library.
*
* @package PhpThumb
* @subpackage Core
*/
class RokCommon_Image_ImageType_GD extends RokCommon_Image_AbstractImageType
{
/**
* The prior image (before manipulation)
*
* @var resource
*/
protected $oldImage;
/**
* The working image (used during manipulation)
*
* @var resource
*/
protected $workingImage;
/**
* The current dimensions of the image
*
* @var array
*/
protected $currentDimensions;
/**
* The new, calculated dimensions of the image
*
* @var array
*/
protected $newDimensions;
/**
* The maximum width an image can be after resizing (in pixels)
*
* @var int
*/
protected $maxWidth;
/**
* The maximum height an image can be after resizing (in pixels)
*
* @var int
*/
protected $maxHeight;
/**
* The percentage to resize the image by
*
* @var int
*/
protected $percent;
/**
* Class Constructor
*
* @return RokCommon_Image_ImageType_GD
*
* @param string $fileName
*/
public function __construct($fileName, array $options = array(), $isDataStream = false)
{
parent::__construct($fileName, $options, $isDataStream);
$this->determineFormat();
if ($this->isDataStream === false) {
$this->verifyFormatCompatiblity();
}
switch ($this->format) {
case 'GIF':
$this->oldImage = imagecreatefromgif($this->fileName);
break;
case 'JPG':
$this->oldImage = imagecreatefromjpeg($this->fileName);
break;
case 'PNG':
$this->oldImage = imagecreatefrompng($this->fileName);
break;
case 'STRING':
$this->oldImage = imagecreatefromstring($this->fileName);
break;
}
$this->currentDimensions = array(
'width' => imagesx($this->oldImage),
'height' => imagesy($this->oldImage)
);
$this->setOptions($options);
// TODO: Port gatherImageMeta to a separate function that can be called to extract exif data
}
/**
* Class Destructor
*
*/
public function __destruct()
{
if (is_resource($this->oldImage)) {
imagedestroy($this->oldImage);
}
if (is_resource($this->workingImage)) {
imagedestroy($this->workingImage);
}
}
##############################
# ----- API FUNCTIONS ------ #
##############################
/**
* Resizes an image to be no larger than $maxWidth or $maxHeight
*
* If either param is set to zero, then that dimension will not be considered as a part of the resize.
* Additionally, if $this->options['resizeUp'] is set to true (false by default), then this function will
* also scale the image up to the maximum dimensions provided.
*
* @param int $maxWidth The maximum width of the image in pixels
* @param int $maxHeight The maximum height of the image in pixels
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException
*/
public function resize($maxWidth = 0, $maxHeight = 0)
{
// make sure our arguments are valid
if (!is_numeric($maxWidth)) {
throw new InvalidArgumentException('$maxWidth must be numeric');
}
if (!is_numeric($maxHeight)) {
throw new InvalidArgumentException('$maxHeight must be numeric');
}
// make sure we're not exceeding our image size if we're not supposed to
if ($this->options['resizeUp'] === false) {
$this->maxHeight = (intval($maxHeight) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $maxHeight;
$this->maxWidth = (intval($maxWidth) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $maxWidth;
} else {
$this->maxHeight = intval($maxHeight);
$this->maxWidth = intval($maxWidth);
}
// get the new dimensions...
$this->calcImageSize($this->currentDimensions['width'], $this->currentDimensions['height']);
// create the working image
if (function_exists('imagecreatetruecolor')) {
$this->workingImage = imagecreatetruecolor($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
} else {
$this->workingImage = imagecreate($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
}
$this->preserveAlpha();
// and create the newly sized image
imagecopyresampled($this->workingImage, $this->oldImage, 0, 0, 0, 0, $this->newDimensions['newWidth'], $this->newDimensions['newHeight'], $this->currentDimensions['width'], $this->currentDimensions['height']);
// update all the variables and resources to be correct
$this->oldImage = $this->workingImage;
$this->currentDimensions['width'] = $this->newDimensions['newWidth'];
$this->currentDimensions['height'] = $this->newDimensions['newHeight'];
return $this;
}
/**
* Adaptively Resizes the Image
*
* This function attempts to get the image to as close to the provided dimensions as possible, and then crops the
* remaining overflow (from the center) to get the image to be the size specified
*
* @param int $maxWidth
* @param int $maxHeight
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException
*/
public function adaptiveResize($width, $height)
{
// make sure our arguments are valid
if (!is_numeric($width) || $width == 0) {
throw new InvalidArgumentException('$width must be numeric and greater than zero');
}
if (!is_numeric($height) || $height == 0) {
throw new InvalidArgumentException('$height must be numeric and greater than zero');
}
// make sure we're not exceeding our image size if we're not supposed to
if ($this->options['resizeUp'] === false) {
$this->maxHeight = (intval($height) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $height;
$this->maxWidth = (intval($width) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $width;
} else {
$this->maxHeight = intval($height);
$this->maxWidth = intval($width);
}
$this->calcImageSizeStrict($this->currentDimensions['width'], $this->currentDimensions['height']);
// resize the image to be close to our desired dimensions
$this->resize($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
// reset the max dimensions...
if ($this->options['resizeUp'] === false) {
$this->maxHeight = (intval($height) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $height;
$this->maxWidth = (intval($width) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $width;
} else {
$this->maxHeight = intval($height);
$this->maxWidth = intval($width);
}
// create the working image
if (function_exists('imagecreatetruecolor')) {
$this->workingImage = imagecreatetruecolor($this->maxWidth, $this->maxHeight);
} else {
$this->workingImage = imagecreate($this->maxWidth, $this->maxHeight);
}
$this->preserveAlpha();
$cropWidth = $this->maxWidth;
$cropHeight = $this->maxHeight;
$cropX = 0;
$cropY = 0;
// now, figure out how to crop the rest of the image...
if ($this->currentDimensions['width'] > $this->maxWidth) {
$cropX = intval(($this->currentDimensions['width'] - $this->maxWidth) / 2);
} elseif ($this->currentDimensions['height'] > $this->maxHeight) {
$cropY = intval(($this->currentDimensions['height'] - $this->maxHeight) / 2);
}
imagecopyresampled($this->workingImage, $this->oldImage, 0, 0, $cropX, $cropY, $cropWidth, $cropHeight, $cropWidth, $cropHeight);
// update all the variables and resources to be correct
$this->oldImage = $this->workingImage;
$this->currentDimensions['width'] = $this->maxWidth;
$this->currentDimensions['height'] = $this->maxHeight;
return $this;
}
/**
* Resizes an image by a given percent uniformly
*
* Percentage should be whole number representation (i.e. 1-100)
*
* @param int $percent
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException
*/
public function resizePercent($percent = 0)
{
if (!is_numeric($percent)) {
throw new InvalidArgumentException ('$percent must be numeric');
}
$this->percent = intval($percent);
$this->calcImageSizePercent($this->currentDimensions['width'], $this->currentDimensions['height']);
if (function_exists('imagecreatetruecolor')) {
$this->workingImage = imagecreatetruecolor($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
} else {
$this->workingImage = imagecreate($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
}
$this->preserveAlpha();
ImageCopyResampled($this->workingImage, $this->oldImage, 0, 0, 0, 0, $this->newDimensions['newWidth'], $this->newDimensions['newHeight'], $this->currentDimensions['width'], $this->currentDimensions['height']);
$this->oldImage = $this->workingImage;
$this->currentDimensions['width'] = $this->newDimensions['newWidth'];
$this->currentDimensions['height'] = $this->newDimensions['newHeight'];
return $this;
}
/**
* Crops an image from the center with provided dimensions
*
* If no height is given, the width will be used as a height, thus creating a square crop
*
* @param int $cropWidth
* @param int $cropHeight
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException
*/
public function cropFromCenter($cropWidth, $cropHeight = null)
{
if (!is_numeric($cropWidth)) {
throw new InvalidArgumentException('$cropWidth must be numeric');
}
if ($cropHeight !== null && !is_numeric($cropHeight)) {
throw new InvalidArgumentException('$cropHeight must be numeric');
}
if ($cropHeight === null) {
$cropHeight = $cropWidth;
}
$cropWidth = ($this->currentDimensions['width'] < $cropWidth) ? $this->currentDimensions['width'] : $cropWidth;
$cropHeight = ($this->currentDimensions['height'] < $cropHeight) ? $this->currentDimensions['height'] : $cropHeight;
$cropX = intval(($this->currentDimensions['width'] - $cropWidth) / 2);
$cropY = intval(($this->currentDimensions['height'] - $cropHeight) / 2);
$this->crop($cropX, $cropY, $cropWidth, $cropHeight);
return $this;
}
/**
* Vanilla Cropping - Crops from x,y with specified width and height
*
* @param int $startX
* @param int $startY
* @param int $cropWidth
* @param int $cropHeight
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException
*/
public function crop($startX, $startY, $cropWidth, $cropHeight)
{
// validate input
if (!is_numeric($startX)) {
throw new InvalidArgumentException('$startX must be numeric');
}
if (!is_numeric($startY)) {
throw new InvalidArgumentException('$startY must be numeric');
}
if (!is_numeric($cropWidth)) {
throw new InvalidArgumentException('$cropWidth must be numeric');
}
if (!is_numeric($cropHeight)) {
throw new InvalidArgumentException('$cropHeight must be numeric');
}
// do some calculations
$cropWidth = ($this->currentDimensions['width'] < $cropWidth) ? $this->currentDimensions['width'] : $cropWidth;
$cropHeight = ($this->currentDimensions['height'] < $cropHeight) ? $this->currentDimensions['height'] : $cropHeight;
// ensure everything's in bounds
if (($startX + $cropWidth) > $this->currentDimensions['width']) {
$startX = ($this->currentDimensions['width'] - $cropWidth);
}
if (($startY + $cropHeight) > $this->currentDimensions['height']) {
$startY = ($this->currentDimensions['height'] - $cropHeight);
}
if ($startX < 0) {
$startX = 0;
}
if ($startY < 0) {
$startY = 0;
}
// create the working image
if (function_exists('imagecreatetruecolor')) {
$this->workingImage = imagecreatetruecolor($cropWidth, $cropHeight);
} else {
$this->workingImage = imagecreate($cropWidth, $cropHeight);
}
$this->preserveAlpha();
imagecopyresampled($this->workingImage, $this->oldImage, 0, 0, $startX, $startY, $cropWidth, $cropHeight, $cropWidth, $cropHeight);
$this->oldImage = $this->workingImage;
$this->currentDimensions['width'] = $cropWidth;
$this->currentDimensions['height'] = $cropHeight;
return $this;
}
/**
* Rotates image either 90 degrees clockwise or counter-clockwise
*
* @param string $direction
*
* @retunrn RokCommon_Image_ImageType_GD
*/
public function rotateImage($direction = 'CW')
{
if ($direction == 'CW') {
$this->rotateImageNDegrees(270);
} else {
$this->rotateImageNDegrees(90);
}
return $this;
}
/**
* Rotates image specified number of degrees
*
* @param int $degrees
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException, RuntimeException
*/
public function rotateImageNDegrees($degrees, $bgColor = 0)
{
if (!is_numeric($degrees)) {
throw new InvalidArgumentException('$degrees must be numeric');
}
if (!function_exists('imagerotate')) {
throw new RuntimeException('Your version of GD does not support image rotation.');
}
$this->workingImage = imagerotate($this->oldImage, $degrees, $bgColor);
$this->preserveAlpha();
$newWidth = $this->currentDimensions['width'];
$newHeight = $this->currentDimensions['height'];
$this->oldImage = $this->workingImage;
$this->currentDimensions['width'] = $newWidth;
$this->currentDimensions['height'] = $newHeight;
return $this;
}
/**
* Shows an image
*
* This function will show the current image by first sending the appropriate header
* for the format, and then outputting the image data. If headers have already been sent,
* a runtime exception will be thrown
*
* @param bool $rawData Whether or not the raw image stream should be output
*
* @return RokCommon_Image_ImageType_GD
* @throws RuntimeException
*/
public function show($rawData = false)
{
$this->preserveAlpha();
if (headers_sent()) {
throw new RuntimeException('Cannot show image, headers have already been sent');
}
switch ($this->format) {
case 'GIF':
if ($rawData === false) {
header('Content-type: image/gif');
}
imagegif($this->oldImage);
break;
case 'JPG':
if ($rawData === false) {
header('Content-type: image/jpeg');
}
imagejpeg($this->oldImage, null, $this->options['jpegQuality']);
break;
case 'PNG':
case 'STRING':
if ($rawData === false) {
header('Content-type: image/png');
}
imagepng($this->oldImage);
break;
}
return $this;
}
/**
* Returns the Working Image as a String
*
* This function is useful for getting the raw image data as a string for storage in
* a database, or other similar things.
*
* @return string
*/
public function getImageAsString()
{
$data = null;
ob_start();
$this->show(true);
$data = ob_get_contents();
ob_end_clean();
return $data;
}
/**
* Saves an image
*
* This function will make sure the target directory is writeable, and then save the image.
*
* If the target directory is not writeable, the function will try to correct the permissions (if allowed, this
* is set as an option ($this->options['correctPermissions']). If the target cannot be made writeable, then a
* RuntimeException is thrown.
*
* TODO: Create additional paramter for color matte when saving images with alpha to non-alpha formats (i.e. PNG => JPG)
*
* @param string $fileName The full path and filename of the image to save
* @param string $format The format to save the image in (optional, must be one of [GIF,JPG,PNG]
*
* @return RokCommon_Image_ImageType_GD
* @throws InvalidArgumentException, RuntimeException
*/
public function save($fileName, $format = null)
{
$validFormats = array('GIF', 'JPG', 'PNG');
$format = ($format !== null) ? strtoupper($format) : $this->format;
if (!in_array($format, $validFormats)) {
throw new InvalidArgumentException ('Invalid format type specified in save function: ' . $format);
}
// make sure the directory is writeable
if (!is_writeable(dirname($fileName))) {
// try to correct the permissions
if ($this->options['correctPermissions'] === true) {
@chmod(dirname($fileName), 0777);
// throw an exception if not writeable
if (!is_writeable(dirname($fileName))) {
throw new RuntimeException ('File is not writeable, and could not correct permissions: ' . $fileName);
}
} // throw an exception if not writeable
else {
throw new RuntimeException ('File not writeable: ' . $fileName);
}
}
switch ($format) {
case 'GIF':
imagegif($this->oldImage, $fileName);
break;
case 'JPG':
imagejpeg($this->oldImage, $fileName, $this->options['jpegQuality']);
break;
case 'PNG':
imagepng($this->oldImage, $fileName);
break;
}
return $this;
}
#################################
# ----- GETTERS / SETTERS ----- #
#################################
/**
* @return array
*/
protected function getOptionDefaults()
{
$defaultOptions = array(
'resizeUp' => false,
'jpegQuality' => 100,
'correctPermissions' => false,
'preserveAlpha' => true,
'alphaMaskColor' => array(255, 255, 255),
'preserveTransparency' => true,
'transparencyMaskColor' => array(0, 0, 0)
);
return $defaultOptions;
}
/**
* Gets the height of the current image
*
* @return int the height in pixels of the current image
*/
public function getHeight()
{
return $this->currentDimensions['height'];
}
/**
* Gets the width of the current image
*
* @return int the width of the current image in pixels
*/
public function getWidth()
{
return $this->currentDimensions['width'];
}
#################################
# ----- UTILITY FUNCTIONS ----- #
#################################
/**
* Calculates a new width and height for the image based on $this->maxWidth and the provided dimensions
*
* @return array
*
* @param int $width
* @param int $height
*/
protected function calcWidth($width, $height)
{
$newWidthPercentage = (100 * $this->maxWidth) / $width;
$newHeight = ($height * $newWidthPercentage) / 100;
return array(
'newWidth' => intval($this->maxWidth),
'newHeight' => intval($newHeight)
);
}
/**
* Calculates a new width and height for the image based on $this->maxWidth and the provided dimensions
*
* @return array
*
* @param int $width
* @param int $height
*/
protected function calcHeight($width, $height)
{
$newHeightPercentage = (100 * $this->maxHeight) / $height;
$newWidth = ($width * $newHeightPercentage) / 100;
return array(
'newWidth' => ceil($newWidth),
'newHeight' => ceil($this->maxHeight)
);
}
/**
* Calculates a new width and height for the image based on $this->percent and the provided dimensions
*
* @return array
*
* @param int $width
* @param int $height
*/
protected function calcPercent($width, $height)
{
$newWidth = ($width * $this->percent) / 100;
$newHeight = ($height * $this->percent) / 100;
return array(
'newWidth' => ceil($newWidth),
'newHeight' => ceil($newHeight)
);
}
/**
* Calculates the new image dimensions
*
* These calculations are based on both the provided dimensions and $this->maxWidth and $this->maxHeight
*
* @param int $width
* @param int $height
*/
protected function calcImageSize($width, $height)
{
$newSize = array(
'newWidth' => $width,
'newHeight' => $height
);
if ($this->maxWidth > 0) {
$newSize = $this->calcWidth($width, $height);
if ($this->maxHeight > 0 && $newSize['newHeight'] > $this->maxHeight) {
$newSize = $this->calcHeight($newSize['newWidth'], $newSize['newHeight']);
}
}
if ($this->maxHeight > 0) {
$newSize = $this->calcHeight($width, $height);
if ($this->maxWidth > 0 && $newSize['newWidth'] > $this->maxWidth) {
$newSize = $this->calcWidth($newSize['newWidth'], $newSize['newHeight']);
}
}
$this->newDimensions = $newSize;
}
/**
* Calculates new image dimensions, not allowing the width and height to be less than either the max width or height
*
* @param int $width
* @param int $height
*/
protected function calcImageSizeStrict($width, $height)
{
$newDimensions = array(
'newWidth' => 0,
'newHeight'=> 0
);
// first, we need to determine what the longest resize dimension is..
if ($this->maxWidth >= $this->maxHeight) {
// and determine the longest original dimension
if ($width > $height) {
$newDimensions = $this->calcHeight($width, $height);
if ($newDimensions['newWidth'] < $this->maxWidth) {
$newDimensions = $this->calcWidth($width, $height);
}
} elseif ($height >= $width) {
$newDimensions = $this->calcWidth($width, $height);
if ($newDimensions['newHeight'] < $this->maxHeight) {
$newDimensions = $this->calcHeight($width, $height);
}
}
} elseif ($this->maxHeight > $this->maxWidth) {
if ($width >= $height) {
$newDimensions = $this->calcWidth($width, $height);
if ($newDimensions['newHeight'] < $this->maxHeight) {
$newDimensions = $this->calcHeight($width, $height);
}
} elseif ($height > $width) {
$newDimensions = $this->calcHeight($width, $height);
if ($newDimensions['newWidth'] < $this->maxWidth) {
$newDimensions = $this->calcWidth($width, $height);
}
}
}
$this->newDimensions = $newDimensions;
}
/**
* Calculates new dimensions based on $this->percent and the provided dimensions
*
* @param int $width
* @param int $height
*/
protected function calcImageSizePercent($width, $height)
{
if ($this->percent > 0) {
$this->newDimensions = $this->calcPercent($width, $height);
}
}
/**
* Determines the file format by mime-type
*
* This function will throw exceptions for invalid images / mime-types
*
* @throws RokCommon_Image_Exception
*/
protected function determineFormat()
{
if ($this->isDataStream === true) {
$this->format = 'STRING';
return;
}
$formatInfo = getimagesize($this->fileName);
// non-image files will return false
if ($formatInfo === false) {
if ($this->remoteImage) {
throw new RokCommon_Image_Exception('Could not determine format of remote image: ' . $this->fileName);
} else {
throw new RokCommon_Image_Exception('File is not a valid image: ' . $this->fileName);
}
}
$mimeType = isset($formatInfo['mime']) ? $formatInfo['mime'] : null;
switch ($mimeType) {
case 'image/gif':
$this->format = 'GIF';
break;
case 'image/jpeg':
$this->format = 'JPG';
break;
case 'image/png':
$this->format = 'PNG';
break;
default:
throw new RokCommon_Image_Exception('Image format not supported: ' . $mimeType);
}
}
/**
* Makes sure the correct GD implementation exists for the file type
* @throws RokCommon_Image_Exception
*/
protected function verifyFormatCompatiblity()
{
$isCompatible = true;
$gdInfo = gd_info();
switch ($this->format) {
case 'GIF':
$isCompatible = $gdInfo['GIF Create Support'];
break;
case 'JPG':
$isCompatible = (isset($gdInfo['JPG Support']) || isset($gdInfo['JPEG Support'])) ? true : false;
break;
case 'PNG':
$isCompatible = $gdInfo[$this->format . ' Support'];
break;
default:
$isCompatible = false;
}
if (!$isCompatible) {
// one last check for "JPEG" instead
$isCompatible = $gdInfo['JPEG Support'];
if (!$isCompatible) {
throw new RokCommon_Image_Exception('Your GD installation does not support ' . $this->format . ' image types');
}
}
}
/**
* Preserves the alpha or transparency for PNG and GIF files
*
* Alpha / transparency will not be preserved if the appropriate options are set to false.
* Also, the GIF transparency is pretty skunky (the results aren't awesome), but it works like a
* champ... that's the nature of GIFs tho, so no huge surprise.
*
* This functionality was originally suggested by commenter Aimi (no links / site provided) - Thanks! :)
*
*/
protected function preserveAlpha()
{
if (($this->format == 'PNG' || $this->format == 'STRING') && $this->options['preserveAlpha'] === true) {
imagealphablending($this->workingImage, false);
$colorTransparent = imagecolorallocatealpha($this->workingImage, $this->options['alphaMaskColor'][0], $this->options['alphaMaskColor'][1], $this->options['alphaMaskColor'][2], 0);
imagefill($this->workingImage, 0, 0, $colorTransparent);
imagesavealpha($this->workingImage, true);
}
// preserve transparency in GIFs... this is usually pretty rough tho
if ($this->format == 'GIF' && $this->options['preserveTransparency'] === true) {
$colorTransparent = imagecolorallocate($this->workingImage, $this->options['transparencyMaskColor'][0], $this->options['transparencyMaskColor'][1], $this->options['transparencyMaskColor'][2]);
imagecolortransparent($this->workingImage, $colorTransparent);
imagetruecolortopalette($this->workingImage, true, 256);
}
}
}