vendor/pimcore/pimcore/lib/Image/Adapter/Imagick.php line 598

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Image\Adapter;
  18. use Pimcore\Cache;
  19. use Pimcore\Config;
  20. use Pimcore\File;
  21. use Pimcore\Image\Adapter;
  22. use Pimcore\Logger;
  23. use Pimcore\Model\Asset;
  25. class Imagick extends Adapter
  26. {
  27.     /**
  28.      * @var string|null
  29.      */
  30.     protected static $RGBColorProfile;
  32.     /**
  33.      * @var string|null
  34.      */
  35.     protected static $CMYKColorProfile;
  37.     /**
  38.      * @var \Imagick|null
  39.      */
  40.     protected $resource;
  42.     /**
  43.      * @var string
  44.      */
  45.     protected $imagePath;
  47.     /**
  48.      * @var array<string, bool>
  49.      */
  50.     protected static $supportedFormatsCache = [];
  52.     private ?array $initalOptions = null;
  54.     /**
  55.      * {@inheritdoc}
  56.      */
  57.     public function load($imagePath, $options = [])
  58.     {
  59.         $this->initalOptions ??= $options;
  61.         if (isset($options['preserveColor'])) {
  62.             // set this option to TRUE to skip all color transformations during the loading process
  63.             // this can massively improve performance if the color information doesn't matter, ...
  64.             // eg. when using this function to obtain dimensions from an image
  65.             $this->setPreserveColor($options['preserveColor']);
  66.         }
  68.         if (isset($options['asset']) && preg_match('@\.svgz?$@', $imagePath) && preg_match('@[^a-zA-Z0-9\-\.~_/]+@', $imagePath)) {
  69.             // Imagick/Inkscape delegate has problems with special characters in the file path, eg. "ß" causes
  70.             // Inkscape to completely go crazy -> Debian 8.10, Inkscape 0.48.5 r10040, Imagick 6.8.9-9 Q16, Imagick 3.4.3
  71.             // we create a local temp file, to workaround this problem
  72.             $imagePath = $options['asset']->getTemporaryFile();
  73.             $this->tmpFiles[] = $imagePath;
  74.         }
  76.         if ($this->resource) {
  77.             unset($this->resource);
  78.             $this->resource = null;
  79.         }
  81.         try {
  82.             $i = new \Imagick();
  83.             $this->imagePath = $imagePath;
  85.             if (isset($options['resolution'])) {
  86.                 $i->setResolution($options['resolution']['x'], $options['resolution']['y']);
  87.             }
  89.             $imagePathLoad = $imagePath;
  91.             $imagePathLoad = $imagePathLoad . '[0]';
  93.             if (!$i->readImage($imagePathLoad) || !@filesize($imagePath)) {
  94.                 return false;
  95.             }
  97.             $this->resource = $i;
  99.             if (!$this->reinitializing && !$this->isPreserveColor()) {
  100.                 if (method_exists($i, 'setColorspace')) {
  101.                     $i->setColorspace(\Imagick::COLORSPACE_SRGB);
  102.                 }
  104.                 if ($this->isVectorGraphic($imagePath)) {
  105.                     // only for vector graphics
  106.                     // the below causes problems with PSDs when target format is PNG32 (nobody knows why ;-))
  107.                     $i->setBackgroundColor(new \ImagickPixel('transparent'));
  108.                     //for certain edge-cases simply setting the background-color to transparent does not seem to work
  109.                     //workaround by using transparentPaintImage (somehow even works without setting a target. no clue why)
  110.                     $i->transparentPaintImage('', 1, 0, false);
  111.                 }
  113.                 $this->setColorspaceToRGB();
  114.             }
  116.             // set dimensions
  117.             $dimensions = $this->getDimensions();
  118.             $this->setWidth($dimensions['width']);
  119.             $this->setHeight($dimensions['height']);
  121.             if (!$this->sourceImageFormat) {
  122.                 $this->sourceImageFormat = $i->getImageFormat();
  123.             }
  125.             // check if image can have alpha channel
  126.             if (!$this->reinitializing) {
  127.                 $alphaChannel = $i->getImageAlphaChannel();
  128.                 if ($alphaChannel) {
  129.                     $this->setIsAlphaPossible(true);
  130.                 }
  131.             }
  133.             if ($this->checkPreserveAnimation($i->getImageFormat(), $i, false)) {
  134.                 if (!$this->resource->readImage($imagePath) || !filesize($imagePath)) {
  135.                     return false;
  136.                 }
  137.                 $this->resource = $this->resource->coalesceImages();
  138.             }
  140.             $isClipAutoSupport = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['thumbnails']['clip_auto_support'];
  141.             if ($isClipAutoSupport && !$this->reinitializing && $this->has8BIMClippingPath()) {
  142.                 // the following way of determining a clipping path is very resource intensive (using Imagick),
  143.                 // so we try with the approach in has8BIMClippingPath() instead
  144.                 // check for the existence of an embedded clipping path (8BIM / Adobe profile meta data)
  145.                 //$identifyRaw = $i->identifyImage(true)['rawOutput'];
  146.                 //if (strpos($identifyRaw, 'Clipping path') && strpos($identifyRaw, '<svg')) {
  147.                 // if there's a clipping path embedded, apply the first one
  148.                 try {
  149.                     $i->setImageAlphaChannel(\Imagick::ALPHACHANNEL_TRANSPARENT);
  150.                     $i->clipImage();
  151.                     $i->setImageAlphaChannel(\Imagick::ALPHACHANNEL_OPAQUE);
  152.                 } catch (\Exception $e) {
  153.                     Logger::info(sprintf('Although automatic clipping support is enabled, your current ImageMagick / Imagick version does not support this operation on the image %s', $imagePath));
  154.                 }
  155.                 //}
  156.             }
  157.         } catch (\Exception $e) {
  158.             Logger::error('Unable to load image ' . $imagePath . ': ' . $e);
  160.             return false;
  161.         }
  163.         $this->setModified(false);
  165.         return $this;
  166.     }
  168.     private function has8BIMClippingPath(): bool
  169.     {
  170.         $handle = fopen($this->imagePath, 'rb');
  171.         $chunk = fread($handle, 1024*1000); // read the first 1MB
  172.         fclose($handle);
  174.         // according to 8BIM format: https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577409_pgfId-1037504
  175.         // we're looking for the resource id 'Name of clipping path' which is 8BIM 2999 (decimal) or 0x0BB7 in hex
  176.         if (preg_match('/8BIM\x0b\xb7/', $chunk)) {
  177.             return true;
  178.         }
  180.         return false;
  181.     }
  183.     /**
  184.      * {@inheritdoc}
  185.      */
  186.     public function getContentOptimizedFormat()
  187.     {
  188.         $format = 'pjpeg';
  189.         if ($this->hasAlphaChannel()) {
  190.             $format = 'png32';
  191.         }
  193.         return $format;
  194.     }
  196.     /**
  197.      * {@inheritdoc}
  198.      */
  199.     public function save($path, $format = null, $quality = null)
  200.     {
  201.         if (!$format) {
  202.             $format = 'png32';
  203.         }
  205.         if ($format == 'original') {
  206.             $format = $this->sourceImageFormat;
  207.         }
  209.         $format = strtolower($format);
  211.         if ($format == 'png') {
  212.             // we need to force imagick to create png32 images, otherwise this can cause some strange effects
  213.             // when used with gray-scale images
  214.             $format = 'png32';
  215.         }
  217.         $originalFilename = null;
  218.         $i = $this->resource; // this is because of HHVM which has problems with $this->resource->writeImage();
  220.         if (in_array($format, ['jpeg', 'pjpeg', 'jpg']) && $this->isAlphaPossible) {
  221.             // set white background for transparent pixels
  222.             $i->setImageBackgroundColor('#ffffff');
  224.             if ($i->getImageAlphaChannel() !== 0) { // Note: returns (int) 0 if there's no AlphaChannel, PHP Docs are wrong. See: https://www.imagemagick.org/api/channel.php
  225.                 // Imagick version compatibility
  226.                 $alphaChannel = 11; // This works at least as far back as version 3.1.0~rc1-1
  227.                 if (defined('Imagick::ALPHACHANNEL_REMOVE')) {
  228.                     // Imagick::ALPHACHANNEL_REMOVE has been added in 3.2.0b2
  229.                     $alphaChannel = \Imagick::ALPHACHANNEL_REMOVE;
  230.                 }
  231.                 $i->setImageAlphaChannel($alphaChannel);
  232.             }
  234.             $i->mergeImageLayers(\Imagick::LAYERMETHOD_FLATTEN);
  235.         }
  237.         if (!$this->isPreserveMetaData()) {
  238.             $i->stripImage();
  239.             if ($format == 'png32') {
  240.                 // do not include any meta-data
  241.                 // this is due a bug in -strip, therefore we have to use this custom option
  242.                 // see also: https://github.com/ImageMagick/ImageMagick/issues/156
  243.                 $i->setOption('png:include-chunk', 'none');
  244.             }
  245.         }
  246.         if (!$this->isPreserveColor()) {
  247.             $i->profileImage('*', '');
  248.         }
  250.         if ($quality && !$this->isPreserveColor()) {
  251.             $i->setCompressionQuality((int) $quality);
  252.             $i->setImageCompressionQuality((int) $quality);
  253.         }
  255.         if ($format == 'tiff') {
  256.             $i->setCompression(\Imagick::COMPRESSION_LZW);
  257.         }
  259.         // force progressive JPEG if filesize >= 10k
  260.         // normally jpeg images are bigger than 10k so we avoid the double compression (baseline => filesize check => if necessary progressive)
  261.         // and check the dimensions here instead to faster generate the image
  262.         // progressive JPEG - better compression, smaller filesize, especially for web optimization
  263.         if ($format == 'jpeg' && !$this->isPreserveColor()) {
  264.             if (($this->getWidth() * $this->getHeight()) > 35000) {
  265.                 $i->setInterlaceScheme(\Imagick::INTERLACE_PLANE);
  266.             }
  267.         }
  269.         // Imagick isn't able to work with custom stream wrappers, so we make a workaround
  270.         $realTargetPath = null;
  271.         if (!stream_is_local($path)) {
  272.             $realTargetPath = $path;
  273.             $path = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/imagick-tmp-' . uniqid() . '.' . File::getFileExtension($path);
  274.         }
  276.         if (!stream_is_local($path)) {
  277.             $i->setImageFormat($format);
  278.             $success = File::put($path, $i->getImageBlob());
  279.         } else {
  280.             if ($this->checkPreserveAnimation($format, $i)) {
  281.                 $success = $i->writeImages('GIF:' . $path, true);
  282.             } else {
  283.                 $success = $i->writeImage($format . ':' . $path);
  284.             }
  285.         }
  287.         if (!$success) {
  288.             throw new \Exception('Unable to write image: ' . $path);
  289.         }
  291.         if ($realTargetPath) {
  292.             File::rename($path, $realTargetPath);
  293.         }
  295.         return $this;
  296.     }
  298.     /**
  299.      * @param string $format
  300.      * @param \Imagick|null $i
  301.      * @param bool $checkNumberOfImages
  302.      *
  303.      * @return bool
  304.      */
  305.     private function checkPreserveAnimation(string $format = '', \Imagick $i = null, bool $checkNumberOfImages = true)
  306.     {
  307.         if (!$this->isPreserveAnimation()) {
  308.             return false;
  309.         }
  311.         if (!$i) {
  312.             $i = $this->resource;
  313.         }
  315.         if ($i && $checkNumberOfImages && $i->getNumberImages() <= 1) {
  316.             return false;
  317.         }
  319.         if ($format && !in_array(strtolower($format), ['gif', 'original', 'auto'])) {
  320.             return false;
  321.         }
  323.         return true;
  324.     }
  326.     /**
  327.      * {@inheritdoc}
  328.      */
  329.     protected function destroy()
  330.     {
  331.         if ($this->resource) {
  332.             $this->resource->clear();
  333.             $this->resource->destroy();
  334.             $this->resource = null;
  335.         }
  336.     }
  338.     /**
  339.      * @return bool
  340.      */
  341.     private function hasAlphaChannel()
  342.     {
  343.         if ($this->isAlphaPossible) {
  344.             $width = $this->resource->getImageWidth(); // Get the width of the image
  345.             $height = $this->resource->getImageHeight(); // Get the height of the image
  347.             // We run the image pixel by pixel and as soon as we find a transparent pixel we stop and return true.
  348.             for ($i = 0; $i < $width; $i++) {
  349.                 for ($j = 0; $j < $height; $j++) {
  350.                     $pixel = $this->resource->getImagePixelColor($i, $j);
  351.                     $color = $pixel->getColor(1); // get the real alpha not just 1/0
  352.                     if ($color['a'] < 1) { // if there's an alpha pixel, return true
  353.                         return true;
  354.                     }
  355.                 }
  356.             }
  357.         }
  359.         // If we dont find any pixel the function will return false.
  360.         return false;
  361.     }
  363.     /**
  364.      * @return $this
  365.      */
  366.     private function setColorspaceToRGB()
  367.     {
  368.         $imageColorspace = $this->resource->getImageColorspace();
  370.         if (in_array($imageColorspace, [\Imagick::COLORSPACE_RGB, \Imagick::COLORSPACE_SRGB])) {
  371.             // no need to process (s)RGB images
  372.             return $this;
  373.         }
  375.         $profiles = $this->resource->getImageProfiles('icc', true);
  377.         if (isset($profiles['icc'])) {
  378.             if (strpos($profiles['icc'], 'RGB') !== false) {
  379.                 // no need to process (s)RGB images
  380.                 return $this;
  381.             }
  383.             // Workaround for ImageMagick (e.g. 6.9.10-23) bug, that let's it crash immediately if the tagged colorspace is
  384.             // different from the colorspace of the embedded icc color profile
  385.             // If that is the case we just ignore the color profiles
  386.             if (strpos($profiles['icc'], 'CMYK') !== false && $imageColorspace !== \Imagick::COLORSPACE_CMYK) {
  387.                 return $this;
  388.             }
  389.         }
  391.         if ($imageColorspace == \Imagick::COLORSPACE_CMYK) {
  392.             if (self::getCMYKColorProfile() && self::getRGBColorProfile()) {
  393.                 // if it doesn't have a CMYK ICC profile, we add one
  394.                 if (!isset($profiles['icc'])) {
  395.                     $this->resource->profileImage('icc', self::getCMYKColorProfile());
  396.                 }
  397.                 // then we add an RGB profile
  398.                 $this->resource->profileImage('icc', self::getRGBColorProfile());
  399.                 $this->resource->setImageColorspace(\Imagick::COLORSPACE_SRGB); // we have to use SRGB here, no clue why but it works
  400.             } else {
  401.                 $this->resource->setImageColorspace(\Imagick::COLORSPACE_SRGB);
  402.             }
  403.         } elseif ($imageColorspace == \Imagick::COLORSPACE_GRAY) {
  404.             $this->resource->setImageColorspace(\Imagick::COLORSPACE_SRGB);
  405.         } elseif (!in_array($imageColorspace, [\Imagick::COLORSPACE_RGB, \Imagick::COLORSPACE_SRGB])) {
  406.             $this->resource->setImageColorspace(\Imagick::COLORSPACE_SRGB);
  407.         } else {
  408.             // this is to handle all other embedded icc profiles
  409.             if (isset($profiles['icc'])) {
  410.                 try {
  411.                     // if getImageColorspace() says SRGB but the embedded icc profile is CMYK profileImage() will throw an exception
  412.                     $this->resource->profileImage('icc', self::getRGBColorProfile());
  413.                     $this->resource->setImageColorspace(\Imagick::COLORSPACE_SRGB);
  414.                 } catch (\Exception $e) {
  415.                     Logger::warn((string) $e);
  416.                 }
  417.             }
  418.         }
  420.         // this is a HACK to force grayscale images to be real RGB - truecolor, this is important if you want to use
  421.         // thumbnails in PDF's because they do not support "real" grayscale JPEGs or PNGs
  422.         // problem is described here: http://imagemagick.org/Usage/basics/#type
  423.         // and here: http://www.imagemagick.org/discourse-server/viewtopic.php?f=2&t=6888#p31891
  425.         // 20.7.2018: this seems to cause new issues with newer Imagick/PHP versions, so we take it out for now ...
  426.         //  not sure if this workaround is actually still necessary (wouldn't assume so).
  428.         /*$currentLocale = setlocale(LC_ALL, '0'); // this locale hack thing is also a hack for imagick
  429.         setlocale(LC_ALL, 'en'); // Set locale to "en" for ImagickDraw::point() to ensure the involved tostring() methods keep the decimal point
  431.         $draw = new \ImagickDraw();
  432.         $draw->setFillColor('#ff0000');
  433.         $draw->setfillopacity(.01);
  434.         $draw->point(floor($this->getWidth() / 2), floor($this->getHeight() / 2)); // place it in the middle of the image
  435.         $this->resource->drawImage($draw);
  437.         setlocale(LC_ALL, $currentLocale); // see setlocale() above, for details ;-)
  438.         */
  440.         return $this;
  441.     }
  443.     /**
  444.      * @internal
  445.      *
  446.      * @param string $CMYKColorProfile
  447.      */
  448.     public static function setCMYKColorProfile($CMYKColorProfile)
  449.     {
  450.         self::$CMYKColorProfile = $CMYKColorProfile;
  451.     }
  453.     /**
  454.      * @internal
  455.      *
  456.      * @return string
  457.      */
  458.     public static function getCMYKColorProfile()
  459.     {
  460.         if (!self::$CMYKColorProfile) {
  461.             $path = Config::getSystemConfiguration('assets')['icc_cmyk_profile'] ?? null;
  462.             if (!$path || !file_exists($path)) {
  463.                 $path = __DIR__ . '/../icc-profiles/ISOcoated_v2_eci.icc'; // default profile
  464.             }
  466.             if (file_exists($path)) {
  467.                 self::$CMYKColorProfile = file_get_contents($path);
  468.             }
  469.         }
  471.         return self::$CMYKColorProfile;
  472.     }
  474.     /**
  475.      * @internal
  476.      *
  477.      * @param string $RGBColorProfile
  478.      */
  479.     public static function setRGBColorProfile($RGBColorProfile)
  480.     {
  481.         self::$RGBColorProfile = $RGBColorProfile;
  482.     }
  484.     /**
  485.      * @internal
  486.      *
  487.      * @return string
  488.      */
  489.     public static function getRGBColorProfile()
  490.     {
  491.         if (!self::$RGBColorProfile) {
  492.             $path = Config::getSystemConfiguration('assets')['icc_rgb_profile'] ?? null;
  493.             if (!$path || !file_exists($path)) {
  494.                 $path = __DIR__ . '/../icc-profiles/sRGB_IEC61966-2-1_black_scaled.icc'; // default profile
  495.             }
  497.             if (file_exists($path)) {
  498.                 self::$RGBColorProfile = file_get_contents($path);
  499.             }
  500.         }
  502.         return self::$RGBColorProfile;
  503.     }
  505.     /**
  506.      * {@inheritdoc}
  507.      */
  508.     public function resize($width, $height)
  509.     {
  510.         $this->preModify();
  512.         // this is the check for vector formats because they need to have a resolution set
  513.         // this does only work if "resize" is the first step in the image-pipeline
  515.         if ($this->isVectorGraphic()) {
  516.             // the resolution has to be set before loading the image, that's why we have to destroy the instance and load it again
  517.             $res = $this->resource->getImageResolution();
  518.             if ($res['x'] && $res['y']) {
  519.                 $x_ratio = $res['x'] / $this->getWidth();
  520.                 $y_ratio = $res['y'] / $this->getHeight();
  521.                 $this->resource->removeImage();
  523.                 $newRes = ['x' => $width * $x_ratio, 'y' => $height * $y_ratio];
  525.                 // only use the calculated resolution if we need a higher one that the one we got from the metadata (getImageResolution)
  526.                 // this is because sometimes the quality is much better when using the "native" resolution from the metadata
  527.                 if ($newRes['x'] > $res['x'] && $newRes['y'] > $res['y']) {
  528.                     $res = $newRes;
  529.                 }
  530.             } else {
  531.                 // this is mostly for SVGs, it seems that getImageResolution() doesn't return a value anymore for SVGs
  532.                 // so we calculate the density ourselves, Inkscape/ImageMagick seem to use 96ppi, so that's how we get
  533.                 // the right values for -density (setResolution)
  534.                 $res = [
  535.                     'x' => ($width / $this->getWidth()) * 96,
  536.                     'y' => ($height / $this->getHeight()) * 96,
  537.                 ];
  538.             }
  540.             $this->resource->setResolution($res['x'], $res['y']);
  541.             $this->resource->readImage($this->imagePath);
  543.             if (!$this->isPreserveColor()) {
  544.                 $this->setColorspaceToRGB();
  545.             }
  546.         }
  548.         $width = (int)$width;
  549.         $height = (int)$height;
  551.         if ($this->getWidth() !== $width || $this->getHeight() !== $height) {
  552.             if ($this->checkPreserveAnimation()) {
  553.                 foreach ($this->resource as $i => $frame) {
  554.                     $frame->resizeimage($width, $height, \Imagick::FILTER_UNDEFINED, 1, false);
  555.                 }
  556.             } else {
  557.                 $this->resource->resizeimage($width, $height, \Imagick::FILTER_UNDEFINED, 1, false);
  558.             }
  559.             $this->setWidth($width);
  560.             $this->setHeight($height);
  561.         }
  563.         $this->postModify();
  565.         return $this;
  566.     }
  568.     /**
  569.      * {@inheritdoc}
  570.      */
  571.     public function crop($x, $y, $width, $height)
  572.     {
  573.         $this->preModify();
  575.         $this->resource->cropImage($width, $height, $x, $y);
  576.         $this->resource->setImagePage($width, $height, 0, 0);
  578.         $this->setWidth($width);
  579.         $this->setHeight($height);
  581.         $this->postModify();
  583.         return $this;
  584.     }
  586.     /**
  587.      * {@inheritdoc}
  588.      */
  589.     public function frame($width, $height, $forceResize = false)
  590.     {
  591.         $this->preModify();
  593.         $this->contain($width, $height, $forceResize);
  595.         $x = ($width - $this->getWidth()) / 2;
  596.         $y = ($height - $this->getHeight()) / 2;
  598.         $newImage = $this->createCompositeImageFromResource($width, $height, $x, $y);
  599.         $this->resource = $newImage;
  601.         $this->setWidth($width);
  602.         $this->setHeight($height);
  604.         $this->postModify();
  606.         $this->setIsAlphaPossible(true);
  608.         return $this;
  609.     }
  611.     /**
  612.      * {@inheritdoc}
  613.      */
  614.     public function trim($tolerance)
  615.     {
  616.         $this->preModify();
  618.         $this->resource->trimimage($tolerance);
  620.         $dimensions = $this->getDimensions();
  621.         $this->setWidth($dimensions['width']);
  622.         $this->setHeight($dimensions['height']);
  624.         $this->postModify();
  626.         return $this;
  627.     }
  629.     /**
  630.      * {@inheritdoc}
  631.      */
  632.     public function setBackgroundColor($color)
  633.     {
  634.         $this->preModify();
  635.         $newImage = $this->createCompositeImageFromResource($this->getWidth(), $this->getHeight(), 0, 0, $color);
  636.         $this->resource = $newImage;
  638.         $this->postModify();
  640.         $this->setIsAlphaPossible(false);
  642.         return $this;
  643.     }
  645.     /**
  646.      * @param int $width
  647.      * @param int $height
  648.      * @param string $color
  649.      *
  650.      * @return \Imagick
  651.      */
  652.     private function createImage($width, $height, $color = 'transparent')
  653.     {
  654.         $newImage = new \Imagick();
  655.         $newImage->newimage($width, $height, $color);
  656.         $newImage->setImageFormat($this->resource->getImageFormat());
  658.         return $newImage;
  659.     }
  661.     /**
  662.      * @param int $width
  663.      * @param int $height
  664.      * @param int $x
  665.      * @param int $y
  666.      * @param string $color
  667.      * @param int $composite
  668.      *
  669.      * @return \Imagick
  670.      */
  671.     private function createCompositeImageFromResource($width, $height, $x, $y, $color = 'transparent', $composite = \Imagick::COMPOSITE_DEFAULT)
  672.     {
  673.         $newImage = null;
  674.         if ($this->checkPreserveAnimation()) {
  675.             foreach ($this->resource as $i => $frame) {
  676.                 $imageFrame = $this->createImage($width, $height, $color);
  677.                 $imageFrame->compositeImage($frame, $composite, $x, $y);
  678.                 if (!$newImage) {
  679.                     $newImage = $imageFrame;
  680.                 } else {
  681.                     $newImage->addImage($imageFrame);
  682.                 }
  683.             }
  684.         } else {
  685.             $newImage = $this->createImage($width, $height, $color);
  686.             $newImage->compositeImage($this->resource, $composite, $x, $y);
  687.         }
  689.         return $newImage;
  690.     }
  692.     /**
  693.      * {@inheritdoc}
  694.      */
  695.     public function rotate($angle)
  696.     {
  697.         $this->preModify();
  699.         $this->resource->rotateImage(new \ImagickPixel('none'), $angle);
  700.         $this->setWidth($this->resource->getimagewidth());
  701.         $this->setHeight($this->resource->getimageheight());
  703.         $this->postModify();
  705.         $this->setIsAlphaPossible(true);
  707.         return $this;
  708.     }
  710.     /**
  711.      * {@inheritdoc}
  712.      */
  713.     public function roundCorners($width, $height)
  714.     {
  715.         $this->preModify();
  717.         $this->internalRoundCorners($width, $height);
  719.         $this->postModify();
  721.         $this->setIsAlphaPossible(true);
  723.         return $this;
  724.     }
  726.     /**
  727.      * Workaround for Imagick PHP extension v3.4.4 which removed Imagick::roundCorners
  728.      *
  729.      * @param int $width
  730.      * @param int $height
  731.      */
  732.     private function internalRoundCorners($width, $height)
  733.     {
  734.         $imageWidth = $this->resource->getImageWidth();
  735.         $imageHeight = $this->resource->getImageHeight();
  737.         $rectangle = new \ImagickDraw();
  738.         $rectangle->setFillColor(new \ImagickPixel('black'));
  739.         $rectangle->roundRectangle(0, 0, $imageWidth - 1, $imageHeight - 1, $width, $height);
  741.         $mask = new \Imagick();
  742.         $mask->newImage($imageWidth, $imageHeight, new \ImagickPixel('transparent'), 'png');
  743.         $mask->drawImage($rectangle);
  745.         $this->resource->compositeImage($mask, \Imagick::COMPOSITE_DSTIN, 0, 0);
  746.     }
  748.     /**
  749.      * {@inheritdoc}
  750.      */
  751.     public function setBackgroundImage($image, $mode = null)
  752.     {
  753.         $this->preModify();
  755.         $image = ltrim($image, '/');
  756.         $image = PIMCORE_WEB_ROOT . '/' . $image;
  758.         if (is_file($image)) {
  759.             $newImage = new \Imagick();
  761.             if ($mode == 'asTexture') {
  762.                 $newImage->newImage($this->getWidth(), $this->getHeight(), new \ImagickPixel());
  763.                 $texture = new \Imagick($image);
  764.                 $newImage = $newImage->textureImage($texture);
  765.             } else {
  766.                 $newImage->readimage($image);
  767.                 if ($mode == 'cropTopLeft') {
  768.                     $newImage->cropImage($this->getWidth(), $this->getHeight(), 0, 0);
  769.                 } else {
  770.                     // default behavior (fit)
  771.                     $newImage->resizeimage($this->getWidth(), $this->getHeight(), \Imagick::FILTER_UNDEFINED, 1, false);
  772.                 }
  773.             }
  775.             $newImage->compositeImage($this->resource, \Imagick::COMPOSITE_DEFAULT, 0, 0);
  776.             $this->resource = $newImage;
  777.         }
  779.         $this->postModify();
  781.         return $this;
  782.     }
  784.     /**
  785.      * {@inheritdoc}
  786.      */
  787.     public function addOverlay($image, $x = 0, $y = 0, $alpha = 100, $composite = 'COMPOSITE_DEFAULT', $origin = 'top-left')
  788.     {
  789.         $this->preModify();
  791.         // 100 alpha is default
  792.         if (empty($alpha)) {
  793.             $alpha = 100;
  794.         }
  795.         $alpha = round($alpha / 100, 1);
  797.         //Make sure the composite constant exists.
  798.         if (is_null(constant('Imagick::' . $composite))) {
  799.             $composite = 'COMPOSITE_DEFAULT';
  800.         }
  802.         $newImage = null;
  804.         if (is_string($image)) {
  805.             $asset = Asset\Image::getByPath($image);
  806.             if ($asset instanceof Asset\Image) {
  807.                 $image = $asset->getTemporaryFile();
  808.             } else {
  809.                 trigger_deprecation(
  810.                     'pimcore/pimcore',
  811.                     '10.3',
  812.                     'Using relative path for Image Thumbnail overlay is deprecated, use Asset Image path.'
  813.                 );
  815.                 $image = ltrim($image, '/');
  816.                 $image = PIMCORE_PROJECT_ROOT . '/' . $image;
  817.             }
  819.             $newImage = new \Imagick();
  820.             $newImage->readimage($image);
  821.         } elseif ($image instanceof \Imagick) {
  822.             $newImage = $image;
  823.         }
  825.         if ($newImage) {
  826.             if ($origin === 'top-right') {
  827.                 $x = $this->resource->getImageWidth() - $newImage->getImageWidth() - $x;
  828.             } elseif ($origin === 'bottom-left') {
  829.                 $y = $this->resource->getImageHeight() - $newImage->getImageHeight() - $y;
  830.             } elseif ($origin === 'bottom-right') {
  831.                 $x = $this->resource->getImageWidth() - $newImage->getImageWidth() - $x;
  832.                 $y = $this->resource->getImageHeight() - $newImage->getImageHeight() - $y;
  833.             } elseif ($origin === 'center') {
  834.                 $x = round($this->resource->getImageWidth() / 2) - round($newImage->getImageWidth() / 2) + $x;
  835.                 $y = round($this->resource->getImageHeight() / 2) - round($newImage->getImageHeight() / 2) + $y;
  836.             }
  838.             $newImage->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $alpha, \Imagick::CHANNEL_ALPHA);
  839.             $this->resource->compositeImage($newImage, constant('Imagick::' . $composite), (int)$x, (int)$y);
  840.         }
  842.         $this->postModify();
  844.         return $this;
  845.     }
  847.     /**
  848.      * {@inheritdoc}
  849.      */
  850.     public function addOverlayFit($image, $composite = 'COMPOSITE_DEFAULT')
  851.     {
  852.         $asset = Asset\Image::getByPath($image);
  853.         if ($asset instanceof Asset\Image) {
  854.             $image = $asset->getTemporaryFile();
  855.         } else {
  856.             trigger_deprecation(
  857.                 'pimcore/pimcore',
  858.                 '10.3',
  859.                 'Using relative path for Image Thumbnail overlay is deprecated, use Asset Image path.'
  860.             );
  862.             $image = ltrim($image, '/');
  863.             $image = PIMCORE_PROJECT_ROOT . '/' . $image;
  864.         }
  866.         $newImage = new \Imagick();
  867.         $newImage->readimage($image);
  868.         $newImage->resizeimage($this->getWidth(), $this->getHeight(), \Imagick::FILTER_UNDEFINED, 1, false);
  870.         $this->addOverlay($newImage, 0, 0, 100, $composite);
  872.         return $this;
  873.     }
  875.     /**
  876.      * {@inheritdoc}
  877.      */
  878.     public function applyMask($image)
  879.     {
  880.         $this->preModify();
  881.         $image = ltrim($image, '/');
  882.         $image = PIMCORE_PROJECT_ROOT . '/' . $image;
  884.         if (is_file($image)) {
  885.             $this->resource->setImageMatte(true);
  886.             $newImage = new \Imagick();
  887.             $newImage->readimage($image);
  888.             $newImage->resizeimage($this->getWidth(), $this->getHeight(), \Imagick::FILTER_UNDEFINED, 1, false);
  889.             $this->resource->compositeImage($newImage, \Imagick::COMPOSITE_COPYOPACITY, 0, 0, \Imagick::CHANNEL_ALPHA);
  890.         }
  892.         $this->postModify();
  894.         $this->setIsAlphaPossible(true);
  896.         return $this;
  897.     }
  899.     /**
  900.      * {@inheritdoc}
  901.      */
  902.     public function grayscale()
  903.     {
  904.         $this->preModify();
  905.         $this->resource->setImageType(\Imagick::IMGTYPE_GRAYSCALEMATTE);
  906.         $this->postModify();
  908.         return $this;
  909.     }
  911.     /**
  912.      * {@inheritdoc}
  913.      */
  914.     public function sepia()
  915.     {
  916.         $this->preModify();
  917.         $this->resource->sepiatoneimage(85);
  918.         $this->postModify();
  920.         return $this;
  921.     }
  923.     /**
  924.      * @param float $radius
  925.      * @param float $sigma
  926.      * @param float $amount
  927.      * @param float $threshold
  928.      *
  929.      * @return $this
  930.      */
  931.     public function sharpen($radius = 0, $sigma = 1.0, $amount = 1.0, $threshold = 0.05)
  932.     {
  933.         $this->preModify();
  934.         $this->resource->normalizeImage();
  935.         $this->resource->unsharpMaskImage($radius, $sigma, $amount, $threshold);
  936.         $this->postModify();
  938.         return $this;
  939.     }
  941.     /**
  942.      * {@inheritdoc}
  943.      */
  944.     public function gaussianBlur($radius = 0, $sigma = 1.0)
  945.     {
  946.         $this->preModify();
  947.         $this->resource->gaussianBlurImage($radius, $sigma);
  948.         $this->postModify();
  950.         return $this;
  951.     }
  953.     /**
  954.      * {@inheritdoc}
  955.      */
  956.     public function brightnessSaturation($brightness = 100, $saturation = 100, $hue = 100)
  957.     {
  958.         $this->preModify();
  959.         $this->resource->modulateImage($brightness, $saturation, $hue);
  960.         $this->postModify();
  962.         return $this;
  963.     }
  965.     /**
  966.      * {@inheritdoc}
  967.      */
  968.     public function mirror($mode)
  969.     {
  970.         $this->preModify();
  972.         if ($mode == 'vertical') {
  973.             $this->resource->flipImage();
  974.         } elseif ($mode == 'horizontal') {
  975.             $this->resource->flopImage();
  976.         }
  978.         $this->postModify();
  980.         return $this;
  981.     }
  983.     /**
  984.      * @param string $imagePath
  985.      *
  986.      * @return bool
  987.      */
  988.     public function isVectorGraphic($imagePath = null)
  989.     {
  990.         if (!$imagePath) {
  991.             $imagePath = $this->imagePath;
  992.         }
  994.         // we need to do this check first, because ImageMagick using the inkscape delegate returns "PNG" when calling
  995.         // getimageformat() onto SVG graphics, this is a workaround to avoid problems
  996.         if (preg_match("@\.(svgz?|eps|pdf|ps|ai|indd)$@i", $imagePath)) {
  997.             return true;
  998.         }
  1000.         try {
  1001.             if ($this->resource) {
  1002.                 $type = $this->resource->getimageformat();
  1003.                 $vectorTypes = [
  1004.                     'EPT',
  1005.                     'EPDF',
  1006.                     'EPI',
  1007.                     'EPS',
  1008.                     'EPS2',
  1009.                     'EPS3',
  1010.                     'EPSF',
  1011.                     'EPSI',
  1012.                     'EPT',
  1013.                     'PDF',
  1014.                     'PFA',
  1015.                     'PFB',
  1016.                     'PFM',
  1017.                     'PS',
  1018.                     'PS2',
  1019.                     'PS3',
  1020.                     'SVG',
  1021.                     'SVGZ',
  1022.                     'MVG',
  1023.                 ];
  1025.                 if (in_array(strtoupper($type), $vectorTypes)) {
  1026.                     return true;
  1027.                 }
  1028.             }
  1029.         } catch (\Exception $e) {
  1030.             Logger::err((string) $e);
  1031.         }
  1033.         return false;
  1034.     }
  1036.     /**
  1037.      * @return array
  1038.      */
  1039.     private function getDimensions()
  1040.     {
  1041.         if ($vectorDimensions = $this->getVectorFormatEmbeddedRasterDimensions()) {
  1042.             return $vectorDimensions;
  1043.         }
  1045.         return [
  1046.             'width' => $this->resource->getImageWidth(),
  1047.             'height' => $this->resource->getImageHeight(),
  1048.         ];
  1049.     }
  1051.     /**
  1052.      * @return array|null
  1053.      */
  1054.     private function getVectorFormatEmbeddedRasterDimensions()
  1055.     {
  1056.         if (in_array($this->resource->getimageformat(), ['EPT', 'EPDF', 'EPI', 'EPS', 'EPS2', 'EPS3', 'EPSF', 'EPSI', 'EPT', 'PDF', 'PFA', 'PFB', 'PFM', 'PS', 'PS2', 'PS3'])) {
  1057.             // we need a special handling for PhotoShop EPS
  1058.             $i = 0;
  1060.             $epsFile = fopen($this->imagePath, 'r');
  1061.             while (($eps_line = fgets($epsFile)) && ($i < 100)) {
  1062.                 if (preg_match('/%ImageData: ([0-9]+) ([0-9]+)/i', $eps_line, $matches)) {
  1063.                     return [
  1064.                         'width' => $matches[1],
  1065.                         'height' => $matches[2],
  1066.                     ];
  1067.                 }
  1068.                 $i++;
  1069.             }
  1070.         }
  1072.         return null;
  1073.     }
  1075.     /**
  1076.      * {@inheritdoc}
  1077.      */
  1078.     protected function getVectorRasterDimensions()
  1079.     {
  1080.         if ($vectorDimensions = $this->getVectorFormatEmbeddedRasterDimensions()) {
  1081.             return $vectorDimensions;
  1082.         }
  1084.         return parent::getVectorRasterDimensions();
  1085.     }
  1087.     /**
  1088.      * {@inheritdoc}
  1089.      */
  1090.     public function supportsFormat(string $format, bool $force = false)
  1091.     {
  1092.         if ($force) {
  1093.             return $this->checkFormatSupport($format);
  1094.         }
  1096.         if (!isset(self::$supportedFormatsCache[$format])) {
  1097.             // since determining if an image format is supported is quite expensive we use two-tiered caching
  1098.             // in-process caching (static variable) and the shared cache
  1099.             $cacheKey = 'imagick_format_' . $format;
  1100.             if (($cachedValue = Cache::load($cacheKey)) !== false) {
  1101.                 self::$supportedFormatsCache[$format] = (bool) $cachedValue;
  1102.             } else {
  1103.                 self::$supportedFormatsCache[$format] = $this->checkFormatSupport($format);
  1105.                 // we cache the status as an int, so that we know if the status was cached or not, with bool that wouldn't be possible, since load() returns false if item doesn't exists
  1106.                 Cache::save((int) self::$supportedFormatsCache[$format], $cacheKey, [], null, 999, true);
  1107.             }
  1108.         }
  1110.         return self::$supportedFormatsCache[$format];
  1111.     }
  1113.     /**
  1114.      * @param string $format
  1115.      *
  1116.      * @return bool
  1117.      */
  1118.     private function checkFormatSupport(string $format): bool
  1119.     {
  1120.         try {
  1121.             // we can't use \Imagick::queryFormats() here, because this doesn't consider configured delegates
  1122.             $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/imagick-format-support-detection-' . uniqid() . '.' . $format;
  1123.             $image = new \Imagick();
  1124.             $image->newImage(1, 1, new \ImagickPixel('red'));
  1125.             $image->writeImage($format . ':' . $tmpFile);
  1126.             unlink($tmpFile);
  1128.             return true;
  1129.         } catch (\Exception $e) {
  1130.             return false;
  1131.         }
  1132.     }
  1133. }