vendor/imagine/imagine/src/Gd/Image.php line 558

  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\Driver\InfoProvider;
  15. use Imagine\Exception\InvalidArgumentException;
  16. use Imagine\Exception\OutOfBoundsException;
  17. use Imagine\Exception\RuntimeException;
  18. use Imagine\Factory\ClassFactoryInterface;
  19. use Imagine\Image\AbstractImage;
  20. use Imagine\Image\BoxInterface;
  21. use Imagine\Image\Fill\FillInterface;
  22. use Imagine\Image\Format;
  23. use Imagine\Image\ImageInterface;
  24. use Imagine\Image\Metadata\MetadataBag;
  25. use Imagine\Image\Palette\Color\ColorInterface;
  26. use Imagine\Image\Palette\Color\RGB as RGBColor;
  27. use Imagine\Image\Palette\PaletteInterface;
  28. use Imagine\Image\Point;
  29. use Imagine\Image\PointInterface;
  30. use Imagine\Image\ProfileInterface;
  31. use Imagine\Utils\ErrorHandling;
  33. /**
  34.  * Image implementation using the GD library.
  35.  */
  36. final class Image extends AbstractImage implements InfoProvider
  37. {
  38.     /**
  39.      * @var resource|\GdImage
  40.      */
  41.     private $resource;
  43.     /**
  44.      * @var \Imagine\Gd\Layers|null
  45.      */
  46.     private $layers;
  48.     /**
  49.      * @var \Imagine\Image\Palette\PaletteInterface
  50.      */
  51.     private $palette;
  53.     /**
  54.      * Constructs a new Image instance.
  55.      *
  56.      * @param resource|\GdImage $resource
  57.      * @param \Imagine\Image\Palette\PaletteInterface $palette
  58.      * @param \Imagine\Image\Metadata\MetadataBag $metadata
  59.      */
  60.     public function __construct($resource, PaletteInterface $palette, MetadataBag $metadata)
  61.     {
  62.         $this->metadata = $metadata;
  63.         $this->palette = $palette;
  64.         $this->resource = $resource;
  65.     }
  67.     /**
  68.      * Makes sure the current image resource is destroyed.
  69.      */
  70.     public function __destruct()
  71.     {
  72.         if ($this->resource) {
  73.             if (is_resource($this->resource) && get_resource_type($this->resource) === 'gd' || $this->resource instanceof \GdImage) {
  74.                 imagedestroy($this->resource);
  75.             }
  76.             $this->resource = null;
  77.         }
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      *
  83.      * @see \Imagine\Image\AbstractImage::__clone()
  84.      */
  85.     public function __clone()
  86.     {
  87.         parent::__clone();
  88.         $size = $this->getSize();
  89.         $copy = $this->createImage($size, 'copy');
  90.         if (imagecopy($copy, $this->resource, 0, 0, 0, 0, $size->getWidth(), $size->getHeight()) === false) {
  91.             imagedestroy($copy);
  92.             throw new RuntimeException('Image copy operation failed');
  93.         }
  94.         $this->resource = $copy;
  95.         $this->palette = clone $this->palette;
  96.         if ($this->layers !== null) {
  97.             $this->layers = $this->getClassFactory()->createLayers(ClassFactoryInterface::HANDLE_GD, $this, $this->layers->key());
  98.         }
  99.     }
  101.     /**
  102.      * {@inheritdoc}
  103.      *
  104.      * @see \Imagine\Driver\InfoProvider::getDriverInfo()
  105.      * @since 1.3.0
  106.      */
  107.     public static function getDriverInfo($required = true)
  108.     {
  109.         return DriverInfo::get($required);
  110.     }
  112.     /**
  113.      * Returns Gd resource.
  114.      *
  115.      * @return resource|\GdImage
  116.      */
  117.     public function getGdResource()
  118.     {
  119.         return $this->resource;
  120.     }
  122.     /**
  123.      * {@inheritdoc}
  124.      *
  125.      * @see \Imagine\Image\ManipulatorInterface::copy()
  126.      */
  127.     final public function copy()
  128.     {
  129.         return clone $this;
  130.     }
  132.     /**
  133.      * {@inheritdoc}
  134.      *
  135.      * @see \Imagine\Image\ManipulatorInterface::crop()
  136.      */
  137.     final public function crop(PointInterface $start, BoxInterface $size)
  138.     {
  139.         if (!$start->in($this->getSize())) {
  140.             throw new OutOfBoundsException('Crop coordinates must start at minimum 0, 0 position from top left corner, crop height and width must be positive integers and must not exceed the current image borders');
  141.         }
  143.         $width = $size->getWidth();
  144.         $height = $size->getHeight();
  146.         $dest = $this->createImage($size, 'crop');
  148.         if (imagecopy($dest, $this->resource, 0, 0, $start->getX(), $start->getY(), $width, $height) === false) {
  149.             imagedestroy($dest);
  150.             throw new RuntimeException('Image crop operation failed');
  151.         }
  153.         imagedestroy($this->resource);
  155.         $this->resource = $dest;
  157.         return $this;
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      *
  163.      * @see \Imagine\Image\ManipulatorInterface::paste()
  164.      */
  165.     final public function paste(ImageInterface $image, PointInterface $start, $alpha = 100)
  166.     {
  167.         if (!$image instanceof self) {
  168.             throw new InvalidArgumentException(sprintf('Gd\Image can only paste() Gd\Image instances, %s given', get_class($image)));
  169.         }
  171.         $alpha = (int) round($alpha);
  172.         if ($alpha < 0 || $alpha > 100) {
  173.             throw new InvalidArgumentException(sprintf('The %1$s argument can range from %2$d to %3$d, but you specified %4$d.', '$alpha', 0, 100, $alpha));
  174.         }
  176.         $size = $image->getSize();
  178.         if ($alpha === 100) {
  179.             imagealphablending($this->resource, true);
  180.             imagealphablending($image->resource, true);
  182.             $success = imagecopy($this->resource, $image->resource, $start->getX(), $start->getY(), 0, 0, $size->getWidth(), $size->getHeight());
  184.             imagealphablending($this->resource, false);
  185.             imagealphablending($image->resource, false);
  187.             if ($success === false) {
  188.                 throw new RuntimeException('Image paste operation failed');
  189.             }
  190.         } elseif ($alpha > 0) {
  191.             if (imagecopymerge(/*dst_im*/$this->resource, /*src_im*/$image->resource, /*dst_x*/$start->getX(), /*dst_y*/$start->getY(), /*src_x*/0, /*src_y*/0, /*src_w*/$size->getWidth(), /*src_h*/$size->getHeight(), /*pct*/$alpha) === false) {
  192.                 throw new RuntimeException('Image paste operation failed');
  193.             }
  194.         }
  196.         return $this;
  197.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      *
  202.      * Please remark that GD doesn't support different filters, so the $filter argument is ignored.
  203.      *
  204.      * @see \Imagine\Image\ManipulatorInterface::resize()
  205.      */
  206.     final public function resize(BoxInterface $size, $filter = ImageInterface::FILTER_UNDEFINED)
  207.     {
  208.         if (!in_array($filter, static::getAllFilterValues(), true)) {
  209.             throw new InvalidArgumentException('Unsupported filter type');
  210.         }
  212.         $width = $size->getWidth();
  213.         $height = $size->getHeight();
  215.         $dest = $this->createImage($size, 'resize');
  217.         imagealphablending($this->resource, true);
  218.         imagealphablending($dest, true);
  220.         $success = imagecopyresampled($dest, $this->resource, 0, 0, 0, 0, $width, $height, imagesx($this->resource), imagesy($this->resource));
  222.         imagealphablending($this->resource, false);
  223.         imagealphablending($dest, false);
  225.         if ($success === false) {
  226.             imagedestroy($dest);
  227.             throw new RuntimeException('Image resize operation failed');
  228.         }
  230.         imagedestroy($this->resource);
  232.         $this->resource = $dest;
  234.         return $this;
  235.     }
  237.     /**
  238.      * {@inheritdoc}
  239.      *
  240.      * @see \Imagine\Image\ManipulatorInterface::rotate()
  241.      */
  242.     final public function rotate($angle, ColorInterface $background = null)
  243.     {
  244.         if ($background === null) {
  245.             $background = $this->palette->color('fff');
  246.         }
  247.         $color = $this->getColor($background);
  248.         $resource = imagerotate($this->resource, -1 * $angle, $color);
  250.         if ($resource === false) {
  251.             throw new RuntimeException('Image rotate operation failed');
  252.         }
  254.         imagedestroy($this->resource);
  255.         $this->resource = $resource;
  257.         return $this;
  258.     }
  260.     /**
  261.      * {@inheritdoc}
  262.      *
  263.      * @see \Imagine\Image\ManipulatorInterface::save()
  264.      */
  265.     final public function save($path = null, array $options = array())
  266.     {
  267.         $path = $path === null ? (isset($this->metadata['filepath']) ? $this->metadata['filepath'] : $path) : $path;
  269.         if ($path === null) {
  270.             throw new RuntimeException('You can omit save path only if image has been open from a file');
  271.         }
  273.         if (isset($options['format'])) {
  274.             $format = $options['format'];
  275.         } elseif ('' !== $extension = pathinfo($path, \PATHINFO_EXTENSION)) {
  276.             $format = $extension;
  277.         } else {
  278.             $originalPath = isset($this->metadata['filepath']) ? $this->metadata['filepath'] : null;
  279.             $format = pathinfo($originalPath, \PATHINFO_EXTENSION);
  280.         }
  281.         $formatInfo = static::getDriverInfo()->getSupportedFormats()->find($format);
  282.         if ($formatInfo === null) {
  283.             throw new InvalidArgumentException(sprintf(
  284.                 'Saving image in "%s" format is not supported, please use one of the following extensions: "%s"',
  285.                 $format,
  286.                 implode('", "', static::getDriverInfo()->getSupportedFormats()->getAllIDs())
  287.             ));
  288.         }
  289.         $this->saveOrOutput($formatInfo, $options, $path);
  291.         return $this;
  292.     }
  294.     /**
  295.      * {@inheritdoc}
  296.      *
  297.      * @see \Imagine\Image\ManipulatorInterface::show()
  298.      */
  299.     public function show($format, array $options = array())
  300.     {
  301.         $formatInfo = static::getDriverInfo()->getSupportedFormats()->find($format);
  302.         if ($formatInfo === null) {
  303.             throw new InvalidArgumentException(sprintf(
  304.                 'Displaying an image in "%s" format is not supported, please use one of the following formats: "%s"',
  305.                 $format,
  306.                 implode('", "', static::getDriverInfo()->getSupportedFormats()->getAllIDs())
  307.             ));
  308.         }
  309.         header('Content-type: ' . $formatInfo->getMimeType());
  310.         $this->saveOrOutput($formatInfo, $options);
  312.         return $this;
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      *
  318.      * @see \Imagine\Image\ImageInterface::get()
  319.      */
  320.     public function get($format, array $options = array())
  321.     {
  322.         $formatInfo = static::getDriverInfo()->getSupportedFormats()->find($format);
  323.         if ($formatInfo === null) {
  324.             throw new InvalidArgumentException(sprintf(
  325.                 'Creating an image in "%s" format is not supported, please use one of the following formats: "%s"',
  326.                 $format,
  327.                 implode('", "', static::getDriverInfo()->getSupportedFormats()->getAllIDs())
  328.             ));
  329.         }
  330.         ob_start();
  331.         $this->saveOrOutput($formatInfo, $options);
  333.         return ob_get_clean();
  334.     }
  336.     /**
  337.      * {@inheritdoc}
  338.      *
  339.      * @see \Imagine\Image\ImageInterface::__toString()
  340.      */
  341.     public function __toString()
  342.     {
  343.         return $this->get(Format::ID_PNG);
  344.     }
  346.     /**
  347.      * {@inheritdoc}
  348.      *
  349.      * @see \Imagine\Image\ManipulatorInterface::flipHorizontally()
  350.      */
  351.     final public function flipHorizontally()
  352.     {
  353.         if (function_exists('imageflip')) {
  354.             imageflip($this->resource, IMG_FLIP_HORIZONTAL);
  355.         } else {
  356.             $size = $this->getSize();
  357.             $width = $size->getWidth();
  358.             $height = $size->getHeight();
  359.             $dest = $this->createImage($size, 'flip');
  361.             for ($i = 0; $i < $width; $i++) {
  362.                 if (imagecopy($dest, $this->resource, $i, 0, ($width - 1) - $i, 0, 1, $height) === false) {
  363.                     imagedestroy($dest);
  364.                     throw new RuntimeException('Horizontal flip operation failed');
  365.                 }
  366.             }
  368.             imagedestroy($this->resource);
  370.             $this->resource = $dest;
  371.         }
  373.         return $this;
  374.     }
  376.     /**
  377.      * {@inheritdoc}
  378.      *
  379.      * @see \Imagine\Image\ManipulatorInterface::flipVertically()
  380.      */
  381.     final public function flipVertically()
  382.     {
  383.         if (function_exists('imageflip')) {
  384.             imageflip($this->resource, IMG_FLIP_VERTICAL);
  385.         } else {
  386.             $size = $this->getSize();
  387.             $width = $size->getWidth();
  388.             $height = $size->getHeight();
  389.             $dest = $this->createImage($size, 'flip');
  391.             for ($i = 0; $i < $height; $i++) {
  392.                 if (imagecopy($dest, $this->resource, 0, $i, 0, ($height - 1) - $i, $width, 1) === false) {
  393.                     imagedestroy($dest);
  394.                     throw new RuntimeException('Vertical flip operation failed');
  395.                 }
  396.             }
  398.             imagedestroy($this->resource);
  400.             $this->resource = $dest;
  401.         }
  403.         return $this;
  404.     }
  406.     /**
  407.      * {@inheritdoc}
  408.      *
  409.      * @see \Imagine\Image\ManipulatorInterface::strip()
  410.      */
  411.     final public function strip()
  412.     {
  413.         // GD strips profiles and comment, so there's nothing to do here
  414.         return $this;
  415.     }
  417.     /**
  418.      * {@inheritdoc}
  419.      *
  420.      * @see \Imagine\Image\ImageInterface::draw()
  421.      */
  422.     public function draw()
  423.     {
  424.         return $this->getClassFactory()->createDrawer(ClassFactoryInterface::HANDLE_GD, $this->resource);
  425.     }
  427.     /**
  428.      * {@inheritdoc}
  429.      *
  430.      * @see \Imagine\Image\ImageInterface::effects()
  431.      */
  432.     public function effects()
  433.     {
  434.         return $this->getClassFactory()->createEffects(ClassFactoryInterface::HANDLE_GD, $this->resource);
  435.     }
  437.     /**
  438.      * {@inheritdoc}
  439.      *
  440.      * @see \Imagine\Image\ImageInterface::getSize()
  441.      */
  442.     public function getSize()
  443.     {
  444.         return $this->getClassFactory()->createBox(imagesx($this->resource), imagesy($this->resource));
  445.     }
  447.     /**
  448.      * {@inheritdoc}
  449.      *
  450.      * @see \Imagine\Image\ManipulatorInterface::applyMask()
  451.      */
  452.     public function applyMask(ImageInterface $mask)
  453.     {
  454.         if (!$mask instanceof self) {
  455.             throw new InvalidArgumentException('Cannot mask non-gd images');
  456.         }
  458.         $size = $this->getSize();
  459.         $maskSize = $mask->getSize();
  461.         if ($size != $maskSize) {
  462.             throw new InvalidArgumentException(sprintf('The given mask doesn\'t match current image\'s size, Current mask\'s dimensions are %s, while image\'s dimensions are %s', $maskSize, $size));
  463.         }
  465.         for ($x = 0, $width = $size->getWidth(); $x < $width; $x++) {
  466.             for ($y = 0, $height = $size->getHeight(); $y < $height; $y++) {
  467.                 $position = new Point($x, $y);
  468.                 $color = $this->getColorAt($position);
  469.                 $maskColor = $mask->getColorAt($position);
  470.                 $delta = (int) round($color->getAlpha() * $maskColor->getRed() / 255) * -1;
  472.                 if (imagesetpixel($this->resource, $x, $y, $this->getColor($color->dissolve($delta))) === false) {
  473.                     throw new RuntimeException('Apply mask operation failed');
  474.                 }
  475.             }
  476.         }
  478.         return $this;
  479.     }
  481.     /**
  482.      * {@inheritdoc}
  483.      *
  484.      * @see \Imagine\Image\ManipulatorInterface::fill()
  485.      */
  486.     public function fill(FillInterface $fill)
  487.     {
  488.         $size = $this->getSize();
  490.         for ($x = 0, $width = $size->getWidth(); $x < $width; $x++) {
  491.             for ($y = 0, $height = $size->getHeight(); $y < $height; $y++) {
  492.                 if (imagesetpixel($this->resource, $x, $y, $this->getColor($fill->getColor(new Point($x, $y)))) === false) {
  493.                     throw new RuntimeException('Fill operation failed');
  494.                 }
  495.             }
  496.         }
  498.         return $this;
  499.     }
  501.     /**
  502.      * {@inheritdoc}
  503.      *
  504.      * @see \Imagine\Image\ImageInterface::mask()
  505.      */
  506.     public function mask()
  507.     {
  508.         $mask = $this->copy();
  510.         if (imagefilter($mask->resource, IMG_FILTER_GRAYSCALE) === false) {
  511.             throw new RuntimeException('Mask operation failed');
  512.         }
  514.         return $mask;
  515.     }
  517.     /**
  518.      * {@inheritdoc}
  519.      *
  520.      * @see \Imagine\Image\ImageInterface::histogram()
  521.      */
  522.     public function histogram()
  523.     {
  524.         $size = $this->getSize();
  525.         $colors = array();
  527.         for ($x = 0, $width = $size->getWidth(); $x < $width; $x++) {
  528.             for ($y = 0, $height = $size->getHeight(); $y < $height; $y++) {
  529.                 $colors[] = $this->getColorAt(new Point($x, $y));
  530.             }
  531.         }
  533.         return array_values(array_unique($colors));
  534.     }
  536.     /**
  537.      * {@inheritdoc}
  538.      *
  539.      * @see \Imagine\Image\ImageInterface::getColorAt()
  540.      */
  541.     public function getColorAt(PointInterface $point)
  542.     {
  543.         if (!$point->in($this->getSize())) {
  544.             throw new RuntimeException(sprintf('Error getting color at point [%s,%s]. The point must be inside the image of size [%s,%s]', $point->getX(), $point->getY(), $this->getSize()->getWidth(), $this->getSize()->getHeight()));
  545.         }
  547.         $index = imagecolorat($this->resource, $point->getX(), $point->getY());
  548.         $info = imagecolorsforindex($this->resource, $index);
  550.         return $this->palette->color(array($info['red'], $info['green'], $info['blue']), max(min(100 - (int) round($info['alpha'] / 127 * 100), 100), 0));
  551.     }
  553.     /**
  554.      * {@inheritdoc}
  555.      *
  556.      * @see \Imagine\Image\ImageInterface::layers()
  557.      */
  558.     public function layers()
  559.     {
  560.         if ($this->layers === null) {
  561.             $this->layers = $this->getClassFactory()->createLayers(ClassFactoryInterface::HANDLE_GD, $this);
  562.         }
  564.         return $this->layers;
  565.     }
  567.     /**
  568.      * {@inheritdoc}
  569.      *
  570.      * @see \Imagine\Image\ImageInterface::interlace()
  571.      */
  572.     public function interlace($scheme)
  573.     {
  574.         static $supportedInterlaceSchemes = array(
  575.             ImageInterface::INTERLACE_NONE => 0,
  576.             ImageInterface::INTERLACE_LINE => 1,
  577.             ImageInterface::INTERLACE_PLANE => 1,
  578.             ImageInterface::INTERLACE_PARTITION => 1,
  579.         );
  581.         if (!array_key_exists($scheme, $supportedInterlaceSchemes)) {
  582.             throw new InvalidArgumentException('Unsupported interlace type');
  583.         }
  585.         imageinterlace($this->resource, $supportedInterlaceSchemes[$scheme]);
  587.         return $this;
  588.     }
  590.     /**
  591.      * {@inheritdoc}
  592.      *
  593.      * @see \Imagine\Image\ImageInterface::palette()
  594.      */
  595.     public function palette()
  596.     {
  597.         return $this->palette;
  598.     }
  600.     /**
  601.      * {@inheritdoc}
  602.      *
  603.      * @see \Imagine\Image\ImageInterface::profile()
  604.      */
  605.     public function profile(ProfileInterface $profile)
  606.     {
  607.         static::getDriverInfo()->requireFeature(DriverInfo::FEATURE_COLORPROFILES);
  608.     }
  610.     /**
  611.      * {@inheritdoc}
  612.      *
  613.      * @see \Imagine\Image\ImageInterface::usePalette()
  614.      */
  615.     public function usePalette(PaletteInterface $palette)
  616.     {
  617.         if ($this->palette->name() === $palette->name()) {
  618.             return $this;
  619.         }
  621.         static::getDriverInfo()->requirePaletteSupport($palette);
  623.         $this->palette = $palette;
  625.         return $this;
  626.     }
  628.     /**
  629.      * Performs save or show operation using one of GD's image... functions.
  630.      *
  631.      * @param \Imagine\Image\Format $format
  632.      * @param array $options
  633.      * @param string $filename
  634.      *
  635.      * @throws \Imagine\Exception\InvalidArgumentException
  636.      * @throws \Imagine\Exception\RuntimeException
  637.      */
  638.     private function saveOrOutput(Format $format, array $options, $filename = null)
  639.     {
  640.         switch ($format->getID()) {
  641.             default:
  642.                 $saveFunction = 'image' . $format->getID();
  643.                 break;
  644.         }
  645.         $args = array_merge(array(&$this->resource, $filename), $this->finalizeOptions($format, $options));
  647.         ErrorHandling::throwingRuntimeException(E_WARNING | E_NOTICE, function () use ($saveFunction, $args) {
  648.             if (call_user_func_array($saveFunction, $args) === false) {
  649.                 throw new RuntimeException('Save operation failed');
  650.             }
  651.         });
  652.     }
  654.     /**
  655.      * @param \Imagine\Image\Format $format
  656.      * @param array $options
  657.      *
  658.      * @throws \Imagine\Exception\InvalidArgumentException
  659.      *
  660.      * @return array
  661.      */
  662.     private function finalizeOptions(Format $format, array $options)
  663.     {
  664.         $result = array();
  665.         switch ($format->getID()) {
  666.             case Format::ID_AVIF:
  667.                 // ranges from 0 (worst quality, smaller file) to 100 (best quality, larger file). If -1 is provided, the default value is used
  668.                 $quality = -1;
  669.                 // ranges from 0 (slow, smaller file) to 10 (fast, larger file). If -1 is provided, the default value is used
  670.                 $speed = -1;
  671.                 if (!empty($options['avif_lossless'])) {
  672.                     $quality = 100;
  673.                 } else {
  674.                     if (!isset($options['avif_quality'])) {
  675.                         if (isset($options['quality'])) {
  676.                             $options['avif_quality'] = $options['quality'];
  677.                         }
  678.                     }
  679.                     if (isset($options['avif_quality'])) {
  680.                         $quality = max(0, min(100, $options['avif_quality']));
  681.                     }
  682.                 }
  683.                 $result[] = $quality;
  684.                 $result[] = $speed;
  685.                 break;
  686.             case Format::ID_BMP:
  687.                 if (isset($options['compressed'])) {
  688.                     $result[] = (bool) $options['compressed'];
  689.                 }
  690.                 break;
  691.             case Format::ID_JPEG:
  692.                 if (!isset($options['jpeg_quality'])) {
  693.                     if (isset($options['quality'])) {
  694.                         $options['jpeg_quality'] = $options['quality'];
  695.                     }
  696.                 }
  697.                 if (isset($options['jpeg_quality'])) {
  698.                     $result[] = $options['jpeg_quality'];
  699.                 }
  700.                 break;
  701.             case Format::ID_PNG:
  702.                 if (!isset($options['png_compression_level'])) {
  703.                     if (isset($options['quality'])) {
  704.                         $options['png_compression_level'] = round((100 - $options['quality']) * 9 / 100);
  705.                     }
  706.                 }
  707.                 if (isset($options['png_compression_level'])) {
  708.                     if ($options['png_compression_level'] < 0 || $options['png_compression_level'] > 9) {
  709.                         throw new InvalidArgumentException('png_compression_level option should be an integer from 0 to 9');
  710.                     }
  711.                     $result[] = $options['png_compression_level'];
  712.                 } else {
  713.                     $result[] = -1; // use default level
  714.                 }
  715.                 if (!isset($options['png_compression_filter'])) {
  716.                     if (isset($options['filters'])) {
  717.                         $options['png_compression_filter'] = $options['filters'];
  718.                     }
  719.                 }
  720.                 if (isset($options['png_compression_filter'])) {
  721.                     if (~PNG_ALL_FILTERS & $options['png_compression_filter']) {
  722.                         throw new InvalidArgumentException('png_compression_filter option should be a combination of the PNG_FILTER_XXX constants');
  723.                     }
  724.                     $result[] = $options['png_compression_filter'];
  725.                 }
  726.                 break;
  727.             case Format::ID_WEBP:
  728.                 if (!isset($options['webp_quality'])) {
  729.                     if (isset($options['quality'])) {
  730.                         $options['webp_quality'] = $options['quality'];
  731.                     }
  732.                 }
  733.                 if (isset($options['webp_quality'])) {
  734.                     if ($options['webp_quality'] < 0 || $options['webp_quality'] > 100) {
  735.                         throw new InvalidArgumentException('webp_quality option should be an integer from 0 to 100');
  736.                     }
  737.                     $result[] = $options['webp_quality'];
  738.                 }
  739.                 break;
  740.             case Format::ID_XBM:
  741.             case Format::ID_WBMP:
  742.                 if (isset($options['foreground'])) {
  743.                     $result[] = $options['foreground'];
  744.                 }
  745.                 break;
  746.         }
  748.         return $result;
  749.     }
  751.     /**
  752.      * Generates a GD image.
  753.      *
  754.      * @param \Imagine\Image\BoxInterface $size
  755.      * @param string $operation the operation initiating the creation
  756.      *
  757.      * @throws \Imagine\Exception\RuntimeException
  758.      *
  759.      * @return resource|\GdImage
  760.      */
  761.     private function createImage(BoxInterface $size, $operation)
  762.     {
  763.         $resource = imagecreatetruecolor($size->getWidth(), $size->getHeight());
  765.         if ($resource === false) {
  766.             throw new RuntimeException('Image ' . $operation . ' failed');
  767.         }
  769.         if (imagealphablending($resource, false) === false || imagesavealpha($resource, true) === false) {
  770.             throw new RuntimeException('Image ' . $operation . ' failed');
  771.         }
  773.         if (function_exists('imageantialias')) {
  774.             imageantialias($resource, true);
  775.         }
  777.         $transparent = imagecolorallocatealpha($resource, 255, 255, 255, 127);
  778.         imagefill($resource, 0, 0, $transparent);
  779.         imagecolortransparent($resource, $transparent);
  781.         return $resource;
  782.     }
  784.     /**
  785.      * Generates a GD color from Color instance.
  786.      *
  787.      * @param \Imagine\Image\Palette\Color\ColorInterface $color
  788.      *
  789.      * @throws \Imagine\Exception\RuntimeException
  790.      * @throws \Imagine\Exception\InvalidArgumentException
  791.      *
  792.      * @return int A color identifier
  793.      */
  794.     private function getColor(ColorInterface $color)
  795.     {
  796.         if (!$color instanceof RGBColor) {
  797.             throw new InvalidArgumentException('GD driver only supports RGB colors');
  798.         }
  800.         $index = imagecolorallocatealpha($this->resource, $color->getRed(), $color->getGreen(), $color->getBlue(), round(127 * (100 - $color->getAlpha()) / 100));
  802.         if ($index === false) {
  803.             throw new RuntimeException(sprintf('Unable to allocate color "RGB(%s, %s, %s)" with transparency of %d percent', $color->getRed(), $color->getGreen(), $color->getBlue(), $color->getAlpha()));
  804.         }
  806.         return $index;
  807.     }
  808. }