662 lines
19 KiB
Text
662 lines
19 KiB
Text
|
<?php namespace ProcessWire;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ImageSizer Engine IMagick by Horst
|
||
|
|
*
|
||
|
|
* @todo some class properties need phpdoc
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
class ImageSizerEngineIMagick extends ImageSizerEngine {
|
||
|
|
|
||
|
|
public static function getModuleInfo() {
|
||
|
|
return array(
|
||
|
|
'title' => 'IMagick Image Sizer',
|
||
|
|
'version' => 3,
|
||
|
|
'summary' => "Upgrades image manipulations to use PHP's ImageMagick library when possible.",
|
||
|
|
'author' => 'Horst Nogajski',
|
||
|
|
'autoload' => false,
|
||
|
|
'singular' => false,
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The (main) IMagick bitimage handler for regular image variations, (JPEG PNG)
|
||
|
|
*
|
||
|
|
* @var \IMagick|null
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $im = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The (optionally) IMagick bitimage handler for additional WebP copies
|
||
|
|
*
|
||
|
|
* @var \IMagick|null
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $imWebp = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Static cache of formats and whether or not supported, as used by the supportsFormat() method (RJC)
|
||
|
|
*
|
||
|
|
* @var array of ['FORMAT' => true|false]
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
static protected $formatSupport = array();
|
||
|
|
|
||
|
|
// @todo the following need phpdoc
|
||
|
|
protected $workspaceColorspace;
|
||
|
|
protected $imageFormat;
|
||
|
|
protected $imageColorspace;
|
||
|
|
protected $imageMetadata;
|
||
|
|
protected $imageDepth;
|
||
|
|
protected $imageGamma;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $hasICC;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $hasIPTC;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $hasEXIF;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected $hasXMP;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Class constructor
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function __construct() {
|
||
|
|
// set a lower default quality of 80, which is more like 90 in GD
|
||
|
|
$this->setQuality(80);
|
||
|
|
parent::__construct();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Class destructor
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function __destruct() {
|
||
|
|
$this->release();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Release resources used by IMagick
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function release() {
|
||
|
|
if(is_object($this->im)) {
|
||
|
|
$this->im->clear();
|
||
|
|
$this->im->destroy();
|
||
|
|
}
|
||
|
|
if(is_object($this->imWebp)) {
|
||
|
|
$this->imWebp->clear();
|
||
|
|
$this->imWebp->destroy();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get valid image source formats
|
||
|
|
*
|
||
|
|
* @return array
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function validSourceImageFormats() {
|
||
|
|
// 2019/06/07: “PNG8” removed because some versions of ImageMagick have some bug, may be able to add back later
|
||
|
|
return array('JPG', 'JPEG', 'PNG24', 'PNG', 'GIF', 'GIF87');
|
||
|
|
//return array(
|
||
|
|
// 'PNG', 'PNG8', 'PNG24',
|
||
|
|
// 'JPG', 'JPEG',
|
||
|
|
// 'GIF', 'GIF87'
|
||
|
|
//);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get valid target image formats
|
||
|
|
*
|
||
|
|
* @return array
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function validTargetImageFormats() {
|
||
|
|
$formats = $this->validSourceImageFormats();
|
||
|
|
if($this->supportsFormat('WEBP')) $formats[] = 'WEBP';
|
||
|
|
return $formats;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get library version string
|
||
|
|
*
|
||
|
|
* @return string Returns version string or blank string if not applicable/available
|
||
|
|
* @since 3.0.138
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function getLibraryVersion() {
|
||
|
|
$a = \Imagick::getVersion();
|
||
|
|
return "$a[versionString] n=$a[versionNumber]";
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Is the given image format supported by this IMagick for source and target? (RJC)
|
||
|
|
*
|
||
|
|
* @param string $format String like png, jpg, jpg, png8, png24, png24-trans, png24-alpha, etc.
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function supportsFormat($format) {
|
||
|
|
if(strpos($format, '-')) list($format,) = explode('-', $format);
|
||
|
|
$format = strtoupper($format);
|
||
|
|
if(isset(self::$formatSupport[$format])) return self::$formatSupport[$format];
|
||
|
|
try {
|
||
|
|
$im = new \IMagick();
|
||
|
|
$formats = $im->queryformats($format);
|
||
|
|
$supported = count($formats) > 0;
|
||
|
|
} catch(\Exception $e) {
|
||
|
|
$supported = false;
|
||
|
|
}
|
||
|
|
self::$formatSupport[$format] = $supported;
|
||
|
|
return $supported;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Is IMagick supported? Is the current image(sub)format supported?
|
||
|
|
*
|
||
|
|
* @param string $action
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function supported($action = 'imageformat') {
|
||
|
|
|
||
|
|
// first we check parts that are mandatory for all $actions
|
||
|
|
if(!class_exists("\\IMagick")) return false;
|
||
|
|
|
||
|
|
// and if it passes the mandatory requirements, we check particularly aspects here
|
||
|
|
$supported = false;
|
||
|
|
if($action === 'imageformat') {
|
||
|
|
// compare current imagefile infos fetched from ImageInspector
|
||
|
|
$requested = $this->getImageInfo(false);
|
||
|
|
$supported = $this->supportsFormat($requested);
|
||
|
|
} else if($action === 'webp') {
|
||
|
|
$supported = $this->supportsFormat('WEBP');
|
||
|
|
} else if($action === 'install') {
|
||
|
|
$supported = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return $supported;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Process the image resize
|
||
|
|
*
|
||
|
|
* Processing is as follows:
|
||
|
|
* 1. first do a check if the given image(type) can be processed, if not do an early return false
|
||
|
|
* 2. than (try) to process all required steps, if one failes, return false
|
||
|
|
* 3. if all is successful, finally return true
|
||
|
|
*
|
||
|
|
* @param string $srcFilename Source file
|
||
|
|
* @param string $dstFilename Destination file
|
||
|
|
* @param int $fullWidth Current width
|
||
|
|
* @param int $fullHeight Current height
|
||
|
|
* @param int $finalWidth Requested final width
|
||
|
|
* @param int $finalHeight Requested final height
|
||
|
|
* @return bool True if successful, false if not
|
||
|
|
* @throws WireException
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function processResize($srcFilename, $dstFilename, $fullWidth, $fullHeight, $finalWidth, $finalHeight) {
|
||
|
|
|
||
|
|
$this->setTimeLimit(120);
|
||
|
|
|
||
|
|
// start image magick
|
||
|
|
$this->im = new \IMagick();
|
||
|
|
|
||
|
|
// set the working colorspace: COLORSPACE_RGB or COLORSPACE_SRGB ( whats about COLORSPACE_GRAY ??)
|
||
|
|
$this->workspaceColorspace = \Imagick::COLORSPACE_SRGB;
|
||
|
|
$this->im->setColorspace($this->workspaceColorspace);
|
||
|
|
|
||
|
|
if(!$this->im->readImage($srcFilename)) { // actually we get a filecopy from origFilename to destFilename from PageImage
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check validity against image magick
|
||
|
|
if(!$this->im->valid()) {
|
||
|
|
$this->release();
|
||
|
|
throw new WireException(sprintf($this->_("loaded file '%s' is not a valid image"), basename($srcFilename)));
|
||
|
|
}
|
||
|
|
|
||
|
|
// get image format
|
||
|
|
$this->imageFormat = strtoupper($this->im->getImageFormat());
|
||
|
|
|
||
|
|
// only for JPEGs and 24bit PNGs
|
||
|
|
if(!in_array($this->imageFormat, $this->validSourceImageFormats())) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check validity against PW (this does not seem to be reachable due to above code, so commented it out —Ryan)
|
||
|
|
// if(!in_array($this->imageFormat, $this->validSourceImageFormats())) {
|
||
|
|
// $this->release();
|
||
|
|
// throw new WireException(sprintf($this->_("loaded file '%s' is not in the list of valid images"), basename($dstFilename)));
|
||
|
|
// }
|
||
|
|
|
||
|
|
// check and retrieve different image parts and information: ICC, Colorspace, Colordepth, Metadata, etc
|
||
|
|
$this->imageColorspace = $this->im->getImageColorspace();
|
||
|
|
$this->workspaceColorspace = \Imagick::COLORSPACE_GRAY == $this->imageColorspace ? \Imagick::COLORSPACE_GRAY : $this->workspaceColorspace;
|
||
|
|
$this->im->setColorspace($this->workspaceColorspace);
|
||
|
|
$this->imageMetadata = $this->im->getImageProfiles('*');
|
||
|
|
if(!is_array($this->imageMetadata)) $this->imageMetadata = array();
|
||
|
|
$this->hasICC = array_key_exists('icc', $this->imageMetadata);
|
||
|
|
$this->hasIPTC = array_key_exists('iptc', $this->imageMetadata);
|
||
|
|
$this->hasEXIF = array_key_exists('exif', $this->imageMetadata);
|
||
|
|
$this->hasXMP = array_key_exists('xmp', $this->imageMetadata);
|
||
|
|
$this->imageType = $this->im->getImageType();
|
||
|
|
$this->imageDepth = $this->im->getImageDepth();
|
||
|
|
$this->imageGamma = $this->im->getImageGamma();
|
||
|
|
|
||
|
|
if(0 == $this->imageGamma) {
|
||
|
|
// we seem to running on a IMagick version that lacks some features,
|
||
|
|
// at least the 'getImageGamma()', therefor we asume a Gamma of 2.2 here
|
||
|
|
$this->imageGamma = 0.454545;
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove not wanted / needed Metadata = this is the same behave as processed via GD-lib
|
||
|
|
foreach(array_keys($this->imageMetadata) as $k) {
|
||
|
|
#if('icc'==$k) continue; // we keep embedded icc profiles
|
||
|
|
#if('iptc' == $k) continue; // we keep embedded iptc data
|
||
|
|
#if('exif'==$k && $this->data['keepEXIF']) continue; // we have to keep exif data too
|
||
|
|
#if('xmp'==$k && $this->data['keepXMP']) continue; // we have to keep xmp data too
|
||
|
|
$this->im->profileImage("$k", null); // remove this one
|
||
|
|
}
|
||
|
|
|
||
|
|
$this->im->setImageDepth(16);
|
||
|
|
|
||
|
|
$resetGamma = false;
|
||
|
|
if($this->imageGamma && $this->imageGamma != 1) {
|
||
|
|
$resetGamma = $this->im->gammaImage($this->imageGamma);
|
||
|
|
}
|
||
|
|
|
||
|
|
$orientations = null;
|
||
|
|
if($this->autoRotation !== true) {
|
||
|
|
$needRotation = false;
|
||
|
|
} else if($this->checkOrientation($orientations) && (!empty($orientations[0]) || !empty($orientations[1]))) {
|
||
|
|
$needRotation = true;
|
||
|
|
} else {
|
||
|
|
$needRotation = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if($this->rotate || $needRotation) { // @horst
|
||
|
|
if($this->rotate) {
|
||
|
|
$degrees = $this->rotate;
|
||
|
|
} else if((is_float($orientations[0]) || is_int($orientations[0])) && $orientations[0] > -361 && $orientations[0] < 361) {
|
||
|
|
$degrees = $orientations[0];
|
||
|
|
} else {
|
||
|
|
$degrees = false;
|
||
|
|
}
|
||
|
|
if($degrees !== false && !in_array($degrees, array(-360, 0, 360))) {
|
||
|
|
$this->im->rotateImage(new \IMagickPixel('none'), $degrees);
|
||
|
|
if(abs($degrees) == 90 || abs($degrees) == 270) {
|
||
|
|
// we have to swap width & height now!
|
||
|
|
$tmp = array($this->getWidth(), $this->getHeight());
|
||
|
|
$this->setImageInfo($tmp[1], $tmp[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if($this->flip || $needRotation) {
|
||
|
|
$vertical = null;
|
||
|
|
if($this->flip) {
|
||
|
|
$vertical = $this->flip == 'v';
|
||
|
|
} else if($orientations[1] > 0) {
|
||
|
|
$vertical = $orientations[1] == 2;
|
||
|
|
}
|
||
|
|
if(!is_null($vertical)) {
|
||
|
|
$res = $vertical ? $this->im->flipImage() : $this->im->flopImage();
|
||
|
|
if(!$res) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
$zoom = $this->getFocusZoomPercent();
|
||
|
|
if($zoom > 1) {
|
||
|
|
// we need to configure a cropExtra call to respect the zoom factor
|
||
|
|
$this->cropExtra = $this->getFocusZoomCropDimensions($zoom, $fullWidth, $fullHeight, $finalWidth, $finalHeight);
|
||
|
|
$this->cropping = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_array($this->cropExtra) && 4 == count($this->cropExtra)) { // crop before resize
|
||
|
|
list($cropX, $cropY, $cropWidth, $cropHeight) = $this->cropExtra;
|
||
|
|
#list($x, $y, $w, $h) = $this->cropExtra;
|
||
|
|
if(!$this->im->cropImage($cropWidth, $cropHeight, $cropX, $cropY)) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
$this->im->setImagePage(0, 0, 0, 0); //remove the canvas
|
||
|
|
$this->setImageInfo($this->im->getImageWidth(), $this->im->getImageHeight());
|
||
|
|
}
|
||
|
|
|
||
|
|
$bgX = $bgY = 0;
|
||
|
|
$bgWidth = $fullWidth;
|
||
|
|
$bgHeight = $fullHeight;
|
||
|
|
$resizemethod = $this->getResizeMethod($bgWidth, $bgHeight, $finalWidth, $finalHeight, $bgX, $bgY);
|
||
|
|
|
||
|
|
if(0 == $resizemethod) {
|
||
|
|
$this->sharpening = 'none'; // no need for sharpening because we use original copy without scaling
|
||
|
|
// oh, do we need to save with more compression for JPEGs ??
|
||
|
|
#return true;
|
||
|
|
|
||
|
|
} else if(2 == $resizemethod) { // 2 = resize with aspect ratio
|
||
|
|
if(!$this->im->resizeImage($finalWidth, $finalHeight, \Imagick::FILTER_LANCZOS, 1)) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
$this->setImageInfo($this->im->getImageWidth(), $this->im->getImageHeight());
|
||
|
|
|
||
|
|
} else if(4 == $resizemethod) { // 4 = resize and crop from center with aspect ratio
|
||
|
|
if(!$this->im->resizeImage($bgWidth, $bgHeight, \Imagick::FILTER_LANCZOS, 1)) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
$this->setImageInfo($this->im->getImageWidth(), $this->im->getImageHeight());
|
||
|
|
if(!$this->im->cropImage($finalWidth, $finalHeight, $bgX, $bgY)) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
$this->im->setImagePage(0, 0, 0, 0); //remove the canvas
|
||
|
|
$this->setImageInfo($this->im->getImageWidth(), $this->im->getImageHeight());
|
||
|
|
}
|
||
|
|
|
||
|
|
if($this->sharpening && $this->sharpening != 'none') {
|
||
|
|
$this->imSharpen($this->sharpening);
|
||
|
|
}
|
||
|
|
|
||
|
|
// optionally apply interlace bit to the final image. This will result in progressive JPEGs
|
||
|
|
if($this->interlace && in_array(strtoupper($this->imageFormat), array('JPG', 'JPEG'))) {
|
||
|
|
$this->im->setInterlaceScheme(\Imagick::INTERLACE_JPEG);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(isset($resetGamma) && $this->imageGamma && $this->imageGamma != 1) {
|
||
|
|
$this->im->gammaImage(1 / $this->imageGamma);
|
||
|
|
}
|
||
|
|
|
||
|
|
$this->im->setImageDepth(($this->imageDepth > 8 ? 8 : $this->imageDepth));
|
||
|
|
|
||
|
|
// determine whether webp should be created as well (or on its own)
|
||
|
|
$webpOnly = $this->webpOnly && $this->supported('webp');
|
||
|
|
$webpAdd = $webpOnly || ($this->webpAdd && $this->supported('webp'));
|
||
|
|
|
||
|
|
if($webpOnly) {
|
||
|
|
// only a webp file will be created
|
||
|
|
$this->imWebp = $this->im;
|
||
|
|
} else {
|
||
|
|
if($webpAdd) $this->imWebp = clone $this->im; // make a copy before compressions take effect
|
||
|
|
$this->im->setImageFormat($this->imageFormat);
|
||
|
|
$this->im->setImageType($this->imageType);
|
||
|
|
if(in_array(strtoupper($this->imageFormat), array('JPG', 'JPEG'))) {
|
||
|
|
$this->im->setImageCompression(\Imagick::COMPRESSION_JPEG);
|
||
|
|
$this->im->setImageCompressionQuality($this->quality);
|
||
|
|
} else if(in_array(strtoupper($this->imageFormat), array('PNG', 'PNG8', 'PNG24'))) {
|
||
|
|
$this->im->setImageCompression(\Imagick::COMPRESSION_ZIP);
|
||
|
|
$this->im->setImageCompressionQuality($this->quality);
|
||
|
|
} else {
|
||
|
|
$this->im->setImageCompression(\Imagick::COMPRESSION_UNDEFINED);
|
||
|
|
$this->im->setImageCompressionQuality($this->quality);
|
||
|
|
}
|
||
|
|
|
||
|
|
// write to file
|
||
|
|
if(file_exists($dstFilename)) $this->wire('files')->unlink($dstFilename);
|
||
|
|
@clearstatcache(dirname($dstFilename));
|
||
|
|
##if(!$this->im->writeImage($this->destFilename)) {
|
||
|
|
// We use this approach for saving so that it behaves the same like core ImageSizer with images that
|
||
|
|
// have a wrong extension in their filename. When using writeImage() it automatically corrects the
|
||
|
|
// mimetype to match the fileextension, <- we want to avoid this!
|
||
|
|
if(!file_put_contents($dstFilename, $this->im)) {
|
||
|
|
$this->release();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// set modified flag and delete optional webp dependency file
|
||
|
|
$this->modified = true;
|
||
|
|
$return = true;
|
||
|
|
|
||
|
|
// if there is a corresponding webp file present, remove it
|
||
|
|
$pathinfo = pathinfo($srcFilename);
|
||
|
|
$webpFilename = $pathinfo['dirname'] . '/' . $pathinfo['filename'] . '.webp';
|
||
|
|
if(file_exists($webpFilename)) $this->wire('files')->unlink($webpFilename);
|
||
|
|
|
||
|
|
// optionally create a WebP dependency file
|
||
|
|
if($webpAdd) {
|
||
|
|
// prepare for webp output
|
||
|
|
$this->imWebp->setImageFormat('webp');
|
||
|
|
$this->imWebp->setImageCompressionQuality($this->webpQuality);
|
||
|
|
$this->imWebp->setOption('webp:method', '6');
|
||
|
|
//$this->imWebp->setOption('webp:lossless', 'true'); // is this useful?
|
||
|
|
//$this->imWebp->setImageAlphaChannel(imagick::ALPHACHANNEL_ACTIVATE); // is this useful?
|
||
|
|
//$this->imWebp->setBackgroundColor(new ImagickPixel('transparent')); // is this useful?
|
||
|
|
// save to file
|
||
|
|
$return = $this->imWebp->writeImage($webpFilename);
|
||
|
|
}
|
||
|
|
|
||
|
|
// release and return to event-object
|
||
|
|
$this->release();
|
||
|
|
|
||
|
|
return $return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Process rotate of an image
|
||
|
|
*
|
||
|
|
* @param string $srcFilename
|
||
|
|
* @param string $dstFilename
|
||
|
|
* @param int $degrees Clockwise degrees, i.e. 90, 180, 270, -90, -180, -270
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function processRotate($srcFilename, $dstFilename, $degrees) {
|
||
|
|
|
||
|
|
$success = false;
|
||
|
|
$imagick = $this->getImagick($srcFilename);
|
||
|
|
if($imagick->rotateImage(new \ImagickPixel('#00000000'), $degrees)) {
|
||
|
|
$success = $this->processSave($imagick, $dstFilename);
|
||
|
|
}
|
||
|
|
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Process vertical or horizontal flip of an image
|
||
|
|
*
|
||
|
|
* @param string $srcFilename
|
||
|
|
* @param string $dstFilename
|
||
|
|
* @param string $flipType Specify vertical, horizontal or both
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function processFlip($srcFilename, $dstFilename, $flipType) {
|
||
|
|
|
||
|
|
$imagick = $this->getImagick($srcFilename);
|
||
|
|
|
||
|
|
if($flipType == 'vertical') {
|
||
|
|
$success = $imagick->flipImage();
|
||
|
|
} else if($flipType == 'horizontal') {
|
||
|
|
$success = $imagick->flopImage();
|
||
|
|
} else {
|
||
|
|
$success = $imagick->flipImage() && $imagick->flopImage();
|
||
|
|
}
|
||
|
|
|
||
|
|
if($success) $success = $this->processSave($imagick, $dstFilename);
|
||
|
|
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reduce dimensions of image by half (using Imagick minifyImage method)
|
||
|
|
*
|
||
|
|
* @param string $dstFilename If different from filename specified by setFilename()
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function reduceByHalf($dstFilename = '') {
|
||
|
|
$imagick = $this->getImagick($this->filename);
|
||
|
|
$success = $imagick->minifyImage();
|
||
|
|
if($success) $success = $this->processSave($imagick, $dstFilename);
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert image to greyscale
|
||
|
|
*
|
||
|
|
* @param string $dstFilename
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function convertToGreyscale($dstFilename = '') {
|
||
|
|
$imagick = $this->getImagick($this->filename);
|
||
|
|
$success = $imagick->transformImageColorspace(\imagick::COLORSPACE_GRAY);
|
||
|
|
if($success) $success = $this->processSave($imagick, $dstFilename);
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert image to sepia
|
||
|
|
*
|
||
|
|
* @param string $dstFilename
|
||
|
|
* @param float|int $sepia Sepia threshold
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function convertToSepia($dstFilename = '', $sepia = 55) {
|
||
|
|
$sepia += 35;
|
||
|
|
$imagick = $this->getImagick($this->filename);
|
||
|
|
$success = $imagick->sepiaToneImage((float) $sepia);
|
||
|
|
if($success) $success = $this->processSave($imagick, $dstFilename);
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Save action image to file
|
||
|
|
*
|
||
|
|
* @param \IMagick $imagick
|
||
|
|
* @param string $dstFilename
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function processSave(\IMagick $imagick, $dstFilename) {
|
||
|
|
if(empty($dstFilename)) $dstFilename = $this->filename;
|
||
|
|
$ext = strtolower(pathinfo($dstFilename, PATHINFO_EXTENSION));
|
||
|
|
if(in_array($ext, array('jpg', 'jpeg'))) {
|
||
|
|
if($this->interlace) {
|
||
|
|
$imagick->setInterlaceScheme(\Imagick::INTERLACE_JPEG);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$imagick->setImageCompressionQuality($this->quality);
|
||
|
|
$fp = fopen($dstFilename, 'wb');
|
||
|
|
if($fp === false) return false;
|
||
|
|
$success = $imagick->writeImageFile($fp);
|
||
|
|
fclose($fp);
|
||
|
|
return $success;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get instance of Imagick
|
||
|
|
*
|
||
|
|
* @param string $filename Optional filename to read
|
||
|
|
* @return \Imagick
|
||
|
|
* @throws WireException
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function getImagick($filename = '') {
|
||
|
|
$imagick = new \Imagick();
|
||
|
|
if($filename) {
|
||
|
|
if(!$imagick->readImage($filename)) {
|
||
|
|
throw new WireException("Imagick unable to load file: " . basename($filename));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return $imagick;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sharpen the image
|
||
|
|
*
|
||
|
|
* @param string $mode May be none|string|medium|soft
|
||
|
|
* @return bool
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
protected function imSharpen($mode) {
|
||
|
|
if('none' == $mode) return true;
|
||
|
|
$mp = intval($this->finalHeight * $this->finalWidth);
|
||
|
|
if($mp > 1440000) {
|
||
|
|
switch($mode) {
|
||
|
|
case 'strong':
|
||
|
|
$m = array(0, 0.5, 4.6, 0.03);
|
||
|
|
break;
|
||
|
|
case 'medium':
|
||
|
|
$m = array(0, 0.5, 3.0, 0.04);
|
||
|
|
break;
|
||
|
|
case 'soft':
|
||
|
|
default:
|
||
|
|
$m = array(0, 0.5, 2.3, 0.07);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else if($mp > 480000) {
|
||
|
|
switch($mode) {
|
||
|
|
case 'strong':
|
||
|
|
$m = array(0, 0.5, 3.0, 0.04);
|
||
|
|
break;
|
||
|
|
case 'medium':
|
||
|
|
$m = array(0, 0.5, 2.3, 0.06);
|
||
|
|
break;
|
||
|
|
case 'soft':
|
||
|
|
default:
|
||
|
|
$m = array(0, 0.5, 1.8, 0.08);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
switch($mode) {
|
||
|
|
case 'strong':
|
||
|
|
$m = array(0, 0.5, 2.0, 0.06);
|
||
|
|
break;
|
||
|
|
case 'medium':
|
||
|
|
$m = array(0, 0.5, 1.7, 0.08);
|
||
|
|
break;
|
||
|
|
case 'soft':
|
||
|
|
default:
|
||
|
|
$m = array(0, 0.5, 1.2, 0.1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$this->im->unsharpMaskImage($m[0], $m[1], $m[2], $m[3]);
|
||
|
|
$this->modified = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Module install
|
||
|
|
*
|
||
|
|
* @throws WireException
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function ___install() {
|
||
|
|
if(!$this->supported('install')) {
|
||
|
|
throw new WireException("This module requires that you have PHP's IMagick (Image Magick) extension installed");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|