vendor/imagine/imagine/src/Gd/Imagine.php line 85

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Imagine package.
  5.  *
  6.  * (c) Bulat Shakirzyanov <mallluhuct@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Imagine\Gd;
  14. use Imagine\Exception\InvalidArgumentException;
  15. use Imagine\Exception\RuntimeException;
  16. use Imagine\Factory\ClassFactoryInterface;
  17. use Imagine\File\LoaderInterface;
  18. use Imagine\Image\AbstractImagine;
  19. use Imagine\Image\BoxInterface;
  20. use Imagine\Image\Metadata\MetadataBag;
  21. use Imagine\Image\Palette\Color\ColorInterface;
  22. use Imagine\Image\Palette\Color\RGB as RGBColor;
  23. use Imagine\Image\Palette\PaletteInterface;
  24. use Imagine\Image\Palette\RGB;
  25. use Imagine\Utils\ErrorHandling;
  27. /**
  28.  * Imagine implementation using the GD library.
  29.  */
  30. final class Imagine extends AbstractImagine
  31. {
  32.     /**
  33.      * Initialize the class.
  34.      */
  35.     public function __construct()
  36.     {
  37.         $this->requireGdVersion('2.0.1');
  38.     }
  40.     /**
  41.      * {@inheritdoc}
  42.      *
  43.      * @see \Imagine\Image\ImagineInterface::create()
  44.      */
  45.     public function create(BoxInterface $size, ColorInterface $color = null)
  46.     {
  47.         $width = $size->getWidth();
  48.         $height = $size->getHeight();
  50.         $resource = imagecreatetruecolor($width, $height);
  52.         if (false === $resource) {
  53.             throw new RuntimeException('Create operation failed');
  54.         }
  56.         $palette = null !== $color ? $color->getPalette() : new RGB();
  57.         $color = $color ? $color : $palette->color('fff');
  59.         if (!$color instanceof RGBColor) {
  60.             throw new InvalidArgumentException('GD driver only supports RGB colors');
  61.         }
  63.         $index = imagecolorallocatealpha($resource, $color->getRed(), $color->getGreen(), $color->getBlue(), round(127 * (100 - $color->getAlpha()) / 100));
  65.         if (false === $index) {
  66.             throw new RuntimeException('Unable to allocate color');
  67.         }
  69.         if (false === imagefill($resource, 0, 0, $index)) {
  70.             throw new RuntimeException('Could not set background color fill');
  71.         }
  73.         if ($color->getAlpha() <= 5) {
  74.             imagecolortransparent($resource, $index);
  75.         }
  77.         return $this->wrap($resource, $palette, new MetadataBag());
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      *
  83.      * @see \Imagine\Image\ImagineInterface::open()
  84.      */
  85.     public function open($path)
  86.     {
  87.         $loader = $path instanceof LoaderInterface ? $path : $this->getClassFactory()->createFileLoader($path);
  88.         $path = $loader->getPath();
  90.         $data = $loader->getData();
  92.         $resource = $this->createImageFromString($data);
  94.         if (!$resource instanceof \GdImage && !\is_resource($resource)) {
  95.             throw new RuntimeException(sprintf('Unable to open image %s', $path));
  96.         }
  98.         return $this->wrap($resource, new RGB(), $this->getMetadataReader()->readFile($loader));
  99.     }
  101.     /**
  102.      * {@inheritdoc}
  103.      *
  104.      * @see \Imagine\Image\ImagineInterface::load()
  105.      */
  106.     public function load($string)
  107.     {
  108.         return $this->doLoad($string, $this->getMetadataReader()->readData($string));
  109.     }
  111.     /**
  112.      * {@inheritdoc}
  113.      *
  114.      * @see \Imagine\Image\ImagineInterface::read()
  115.      */
  116.     public function read($resource)
  117.     {
  118.         if (!\is_resource($resource)) {
  119.             throw new InvalidArgumentException('Variable does not contain a stream resource');
  120.         }
  122.         $content = stream_get_contents($resource);
  124.         if (false === $content) {
  125.             throw new InvalidArgumentException('Cannot read resource content');
  126.         }
  128.         return $this->doLoad($content, $this->getMetadataReader()->readData($content, $resource));
  129.     }
  131.     /**
  132.      * {@inheritdoc}
  133.      *
  134.      * @see \Imagine\Image\ImagineInterface::font()
  135.      */
  136.     public function font($file, $size, ColorInterface $color)
  137.     {
  138.         return $this->getClassFactory()->createFont(ClassFactoryInterface::HANDLE_GD, $file, $size, $color);
  139.     }
  141.     /**
  142.      * @param resource|\GdImage $resource
  143.      * @param \Imagine\Image\Palette\PaletteInterface $palette
  144.      * @param \Imagine\Image\Metadata\MetadataBag $metadata
  145.      *
  146.      * @throws \Imagine\Exception\RuntimeException
  147.      *
  148.      * @return \Imagine\Image\ImageInterface
  149.      */
  150.     private function wrap($resource, PaletteInterface $palette, MetadataBag $metadata)
  151.     {
  152.         if (!imageistruecolor($resource)) {
  153.             if (\function_exists('imagepalettetotruecolor')) {
  154.                 if (false === imagepalettetotruecolor($resource)) {
  155.                     throw new RuntimeException('Could not convert a palette based image to true color');
  156.                 }
  157.             } else {
  158.                 list($width, $height) = array(imagesx($resource), imagesy($resource));
  160.                 // create transparent truecolor canvas
  161.                 $truecolor = imagecreatetruecolor($width, $height);
  162.                 $transparent = imagecolorallocatealpha($truecolor, 255, 255, 255, 127);
  164.                 imagealphablending($truecolor, false);
  165.                 imagefilledrectangle($truecolor, 0, 0, $width, $height, $transparent);
  166.                 imagealphablending($truecolor, false);
  168.                 imagecopy($truecolor, $resource, 0, 0, 0, 0, $width, $height);
  170.                 imagedestroy($resource);
  171.                 $resource = $truecolor;
  172.             }
  173.         }
  175.         if (false === imagealphablending($resource, false) || false === imagesavealpha($resource, true)) {
  176.             throw new RuntimeException('Could not set alphablending, savealpha and antialias values');
  177.         }
  179.         if (\function_exists('imageantialias')) {
  180.             imageantialias($resource, true);
  181.         }
  183.         return $this->getClassFactory()->createImage(ClassFactoryInterface::HANDLE_GD, $resource, $palette, $metadata);
  184.     }
  186.     /**
  187.      * @param string $version
  188.      *
  189.      * @throws \Imagine\Exception\RuntimeException
  190.      */
  191.     private function requireGdVersion($version)
  192.     {
  193.         if (!\function_exists('gd_info')) {
  194.             throw new RuntimeException('Gd not installed');
  195.         }
  196.         if (version_compare(GD_VERSION, $version, '<')) {
  197.             throw new RuntimeException(sprintf('GD2 version %s or higher is required, %s provided', $version, GD_VERSION));
  198.         }
  199.     }
  201.     /**
  202.      * @param string $string
  203.      * @param \Imagine\Image\Metadata\MetadataBag $metadata
  204.      *
  205.      * @throws \Imagine\Exception\RuntimeException
  206.      *
  207.      * @return \Imagine\Image\ImageInterface
  208.      */
  209.     private function doLoad($string, MetadataBag $metadata)
  210.     {
  211.         $resource = $this->createImageFromString($string);
  213.         if (!$resource instanceof \GdImage && !\is_resource($resource)) {
  214.             throw new RuntimeException('An image could not be created from the given input');
  215.         }
  217.         return $this->wrap($resource, new RGB(), $metadata);
  218.     }
  220.     /**
  221.      * Check if the raw image data represents an image in WebP format.
  222.      *
  223.      * @param string $data
  224.      *
  225.      * @return bool
  226.      */
  227.     private function isWebP(&$data)
  228.     {
  229.         return substr($data, 8, 7) === 'WEBPVP8';
  230.     }
  232.     /**
  233.      * Create an image resource starting from its raw daa.
  234.      *
  235.      * @param string $string
  236.      *
  237.      * @return resource|\GdImage|false
  238.      */
  239.     private function createImageFromString(&$string)
  240.     {
  241.         return ErrorHandling::ignoring(-1, function () use (&$string) {
  242.             //  imagecreatefromstring() does not support webp images before PHP 7.3.0
  243.             if (PHP_VERSION_ID < 70300 && function_exists('imagecreatefromwebp') && $this->isWebP($string)) {
  244.                 return @imagecreatefromwebp('data:image/webp;base64,' . base64_encode($string));
  245.             }
  247.             return @imagecreatefromstring($string);
  248.         });
  249.     }
  250. }