vendor/pimcore/pimcore/lib/Image/Adapter/GD.php line 192

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\Image\Adapter;
  20. class GD extends Adapter
  21. {
  22.     /**
  23.      * @var string
  24.      */
  25.     protected $path;
  27.     /**
  28.      * @var resource|\GdImage|false
  29.      */
  30.     protected $resource;
  32.     /**
  33.      * {@inheritdoc}
  34.      */
  35.     public function load($imagePath, $options = [])
  36.     {
  37.         $this->path = $imagePath;
  38.         if (!$this->resource = @imagecreatefromstring(file_get_contents($this->path))) {
  39.             return false;
  40.         }
  42.         // set dimensions
  43.         list($width, $height) = getimagesize($this->path);
  44.         $this->setWidth($width);
  45.         $this->setHeight($height);
  47.         if (!$this->sourceImageFormat) {
  48.             $this->sourceImageFormat = \Pimcore\File::getFileExtension($imagePath);
  49.         }
  51.         if (in_array(\Pimcore\File::getFileExtension($imagePath), ['png', 'gif'])) {
  52.             // in GD only gif and PNG can have an alphachannel
  53.             $this->setIsAlphaPossible(true);
  54.         }
  56.         $this->setModified(false);
  58.         return $this;
  59.     }
  61.     /**
  62.      * {@inheritdoc}
  63.      */
  64.     public function getContentOptimizedFormat()
  65.     {
  66.         $format = 'pjpeg';
  67.         if ($this->hasAlphaChannel()) {
  68.             $format = 'png';
  69.         }
  71.         return $format;
  72.     }
  74.     /**
  75.      * {@inheritdoc}
  76.      */
  77.     public function save($path, $format = null, $quality = null)
  78.     {
  79.         if (!$format || $format == 'png32') {
  80.             $format = 'png';
  81.         }
  83.         if ($format == 'original') {
  84.             $format = $this->sourceImageFormat;
  85.         }
  87.         $format = strtolower($format);
  89.         // progressive jpeg
  90.         if ($format == 'pjpeg') {
  91.             imageinterlace($this->resource, true);
  92.             $format = 'jpeg';
  93.         }
  95.         if ($format == 'jpg') {
  96.             $format = 'jpeg';
  97.         }
  99.         $functionName = 'image' . $format;
  100.         if (!function_exists($functionName)) {
  101.             $functionName = 'imagepng';
  102.         }
  104.         // always create a PNG24
  105.         if ($format == 'png') {
  106.             imagesavealpha($this->resource, true);
  107.         }
  109.         if ($functionName === 'imagejpeg' || $functionName === 'imagewebp') {
  110.             $functionName($this->resource, $path, $quality);
  111.         } else {
  112.             $functionName($this->resource, $path);
  113.         }
  115.         return $this;
  116.     }
  118.     /**
  119.      * @return bool
  120.      */
  121.     private function hasAlphaChannel()
  122.     {
  123.         if ($this->isAlphaPossible) {
  124.             $width = imagesx($this->resource); // Get the width of the image
  125.             $height = imagesy($this->resource); // Get the height of the image
  127.             // We run the image pixel by pixel and as soon as we find a transparent pixel we stop and return true.
  128.             for ($i = 0; $i < $width; $i++) {
  129.                 for ($j = 0; $j < $height; $j++) {
  130.                     $rgba = imagecolorat($this->resource, $i, $j);
  131.                     if (($rgba & 0x7F000000) >> 24) {
  132.                         return true;
  133.                     }
  134.                 }
  135.             }
  136.         }
  138.         // If we dont find any pixel the function will return false.
  139.         return false;
  140.     }
  142.     /**
  143.      * {@inheritdoc}
  144.      */
  145.     protected function destroy()
  146.     {
  147.         if ($this->resource) {
  148.             imagedestroy($this->resource);
  149.         }
  150.     }
  152.     /**
  153.      * @param int $width
  154.      * @param int $height
  155.      *
  156.      * @return \GdImage|false
  157.      */
  158.     private function createImage($width, $height)
  159.     {
  160.         $newImg = imagecreatetruecolor($width, $height);
  162.         imagesavealpha($newImg, true);
  163.         imagealphablending($newImg, false);
  164.         $trans_colour = imagecolorallocatealpha($newImg, 0, 0, 0, 127);
  165.         imagefill($newImg, 0, 0, $trans_colour);
  167.         return $newImg;
  168.     }
  170.     /**
  171.      * {@inheritdoc}
  172.      */
  173.     public function resize($width, $height)
  174.     {
  175.         $this->preModify();
  177.         $newImg = $this->createImage($width, $height);
  178.         imagecopyresampled($newImg, $this->resource, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
  179.         $this->resource = $newImg;
  181.         $this->setWidth($width);
  182.         $this->setHeight($height);
  184.         $this->postModify();
  186.         return $this;
  187.     }
  189.     /**
  190.      * {@inheritdoc}
  191.      */
  192.     public function crop($x, $y, $width, $height)
  193.     {
  194.         $this->preModify();
  196.         $x = min($this->getWidth(), max(0, $x));
  197.         $y = min($this->getHeight(), max(0, $y));
  198.         $width = min($width, $this->getWidth() - $x);
  199.         $height = min($height, $this->getHeight() - $y);
  200.         $new_img = $this->createImage($width, $height);
  202.         imagecopy($new_img, $this->resource, 0, 0, $x, $y, $width, $height);
  204.         $this->resource = $new_img;
  206.         $this->setWidth($width);
  207.         $this->setHeight($height);
  209.         $this->postModify();
  211.         return $this;
  212.     }
  214.     /**
  215.      * {@inheritdoc}
  216.      */
  217.     public function frame($width, $height, $forceResize = false)
  218.     {
  219.         $this->preModify();
  221.         $this->contain($width, $height, $forceResize);
  223.         $x = ($width - $this->getWidth()) / 2;
  224.         $y = ($height - $this->getHeight()) / 2;
  226.         $newImage = $this->createImage($width, $height);
  227.         imagecopy($newImage, $this->resource, $x, $y, 0, 0, $this->getWidth(), $this->getHeight());
  228.         $this->resource = $newImage;
  230.         $this->setWidth($width);
  231.         $this->setHeight($height);
  233.         $this->postModify();
  235.         $this->setIsAlphaPossible(true);
  237.         return $this;
  238.     }
  240.     /**
  241.      * {@inheritdoc}
  242.      */
  243.     public function setBackgroundColor($color)
  244.     {
  245.         $this->preModify();
  247.         list($r, $g, $b) = $this->colorhex2colorarray($color);
  249.         // just imagefill() on the existing image doesn't work, so we have to create a new image, fill it and then merge
  250.         // the source image with the background-image together
  251.         $newImg = imagecreatetruecolor($this->getWidth(), $this->getHeight());
  252.         $color = imagecolorallocate($newImg, $r, $g, $b);
  253.         imagefill($newImg, 0, 0, $color);
  255.         imagecopy($newImg, $this->resource, 0, 0, 0, 0, $this->getWidth(), $this->getHeight());
  256.         $this->resource = $newImg;
  258.         $this->postModify();
  260.         $this->setIsAlphaPossible(false);
  262.         return $this;
  263.     }
  265.     /**
  266.      * {@inheritdoc}
  267.      */
  268.     public function setBackgroundImage($image, $mode = null)
  269.     {
  270.         $this->preModify();
  272.         $image = ltrim($image, '/');
  273.         $image = PIMCORE_WEB_ROOT . '/' . $image;
  275.         if (is_file($image)) {
  276.             $backgroundImage = imagecreatefromstring(file_get_contents($image));
  277.             list($backgroundImageWidth, $backgroundImageHeight) = getimagesize($image);
  279.             $newImg = $this->createImage($this->getWidth(), $this->getHeight());
  281.             if ($mode == 'cropTopLeft') {
  282.                 imagecopyresampled($newImg, $backgroundImage, 0, 0, 0, 0, $this->getWidth(), $this->getHeight(), $this->getWidth(), $this->getHeight());
  283.             } elseif ($mode == 'asTexture') {
  284.                 imagesettile($newImg, $backgroundImage);
  285.                 imagefilledrectangle($newImg, 0, 0, $this->getWidth(), $this->getHeight(), IMG_COLOR_TILED);
  286.             } else {
  287.                 // default behavior (fit)
  288.                 imagecopyresampled($newImg, $backgroundImage, 0, 0, 0, 0, $this->getWidth(), $this->getHeight(), $backgroundImageWidth, $backgroundImageHeight);
  289.             }
  291.             imagealphablending($newImg, true);
  292.             imagecopyresampled($newImg, $this->resource, 0, 0, 0, 0, $this->getWidth(), $this->getHeight(), $this->getWidth(), $this->getHeight());
  294.             $this->resource = $newImg;
  295.         }
  297.         $this->postModify();
  299.         return $this;
  300.     }
  302.     /**
  303.      * {@inheritdoc}
  304.      */
  305.     public function grayscale()
  306.     {
  307.         $this->preModify();
  309.         imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
  311.         $this->postModify();
  313.         return $this;
  314.     }
  316.     /**
  317.      * {@inheritdoc}
  318.      */
  319.     public function sepia()
  320.     {
  321.         $this->preModify();
  323.         imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
  324.         imagefilter($this->resource, IMG_FILTER_COLORIZE, 100, 50, 0);
  326.         $this->postModify();
  328.         return $this;
  329.     }
  331.     /**
  332.      * {@inheritdoc}
  333.      */
  334.     public function addOverlay($image, $x = 0, $y = 0, $alpha = 100, $composite = 'COMPOSITE_DEFAULT', $origin = 'top-left')
  335.     {
  336.         $this->preModify();
  338.         $image = ltrim($image, '/');
  339.         $image = PIMCORE_PROJECT_ROOT . '/' . $image;
  341.         if (is_file($image)) {
  342.             list($oWidth, $oHeight) = getimagesize($image);
  344.             if ($origin === 'top-right') {
  345.                 $x = $this->getWidth() - $oWidth - $x;
  346.             } elseif ($origin === 'bottom-left') {
  347.                 $y = $this->getHeight() - $oHeight - $y;
  348.             } elseif ($origin === 'bottom-right') {
  349.                 $x = $this->getWidth() - $oWidth - $x;
  350.                 $y = $this->getHeight() - $oHeight - $y;
  351.             } elseif ($origin === 'center') {
  352.                 $x = round($this->getWidth() / 2) - round($oWidth / 2) + $x;
  353.                 $y = round($this->getHeight() / 2) - round($oHeight / 2) + $y;
  354.             }
  356.             $overlay = imagecreatefromstring(file_get_contents($image));
  357.             imagealphablending($this->resource, true);
  358.             imagecopyresampled($this->resource, $overlay, $x, $y, 0, 0, $oWidth, $oHeight, $oWidth, $oHeight);
  359.         }
  361.         $this->postModify();
  363.         return $this;
  364.     }
  366.     /**
  367.      * {@inheritdoc}
  368.      */
  369.     public function mirror($mode)
  370.     {
  371.         $this->preModify();
  373.         if ($mode == 'vertical') {
  374.             imageflip($this->resource, IMG_FLIP_VERTICAL);
  375.         } elseif ($mode == 'horizontal') {
  376.             imageflip($this->resource, IMG_FLIP_HORIZONTAL);
  377.         }
  379.         $this->postModify();
  381.         return $this;
  382.     }
  384.     /**
  385.      * {@inheritdoc}
  386.      */
  387.     public function rotate($angle)
  388.     {
  389.         $this->preModify();
  390.         $angle = 360 - $angle;
  391.         $this->resource = imagerotate($this->resource, $angle, imagecolorallocatealpha($this->resource, 0, 0, 0, 127));
  393.         $this->setWidth(imagesx($this->resource));
  394.         $this->setHeight(imagesy($this->resource));
  396.         $this->postModify();
  398.         $this->setIsAlphaPossible(true);
  400.         return $this;
  401.     }
  403.     protected static $supportedFormatsCache = [];
  405.     /**
  406.      * {@inheritdoc}
  407.      */
  408.     public function supportsFormat(string $format, bool $force = false)
  409.     {
  410.         if (!isset(self::$supportedFormatsCache[$format]) || $force) {
  411.             $info = gd_info();
  412.             $mappings = [
  413.                 'jpg' => 'JPEG Support',
  414.                 'jpeg' => 'JPEG Support',
  415.                 'pjpeg' => 'JPEG Support',
  416.                 'webp' => 'WebP Support',
  417.                 'gif' => 'GIF Create Support',
  418.                 'png' => 'PNG Support',
  419.             ];
  421.             if (isset($mappings[$format]) && isset($info[$mappings[$format]]) && $info[$mappings[$format]]) {
  422.                 self::$supportedFormatsCache[$format] = true;
  423.             } else {
  424.                 self::$supportedFormatsCache[$format] = false;
  425.             }
  426.         }
  428.         return self::$supportedFormatsCache[$format];
  429.     }
  430. }