vendor/imagine/imagine/src/Imagick/Image.php line 287

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\Imagick;
  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\Fill\Gradient\Horizontal;
  23. use Imagine\Image\Fill\Gradient\Linear;
  24. use Imagine\Image\Format;
  25. use Imagine\Image\ImageInterface;
  26. use Imagine\Image\Metadata\MetadataBag;
  27. use Imagine\Image\Palette\Color\ColorInterface;
  28. use Imagine\Image\Palette\PaletteInterface;
  29. use Imagine\Image\Point;
  30. use Imagine\Image\PointInterface;
  31. use Imagine\Image\ProfileInterface;
  32. use Imagine\Utils\ErrorHandling;
  34. /**
  35.  * Image implementation using the Imagick PHP extension.
  36.  */
  37. final class Image extends AbstractImage implements InfoProvider
  38. {
  39.     /**
  40.      * @var \Imagick
  41.      */
  42.     private $imagick;
  44.     /**
  45.      * @var \Imagine\Imagick\Layers|null
  46.      */
  47.     private $layers;
  49.     /**
  50.      * @var \Imagine\Image\Palette\PaletteInterface
  51.      */
  52.     private $palette;
  54.     /**
  55.      * @var array
  56.      */
  57.     private static $colorspaceMapping = array(
  58.         PaletteInterface::PALETTE_CMYK => \Imagick::COLORSPACE_CMYK,
  59.         PaletteInterface::PALETTE_RGB => \Imagick::COLORSPACE_RGB,
  60.         PaletteInterface::PALETTE_GRAYSCALE => \Imagick::COLORSPACE_GRAY,
  61.     );
  63.     /**
  64.      * Constructs a new Image instance.
  65.      *
  66.      * @param \Imagick $imagick
  67.      * @param \Imagine\Image\Palette\PaletteInterface $palette
  68.      * @param \Imagine\Image\Metadata\MetadataBag $metadata
  69.      */
  70.     public function __construct(\Imagick $imagick, PaletteInterface $palette, MetadataBag $metadata)
  71.     {
  72.         $this->metadata = $metadata;
  73.         $this->imagick = $imagick;
  74.         if (static::getDriverInfo()->hasFeature(DriverInfo::FEATURE_COLORSPACECONVERSION)) {
  75.             $this->setColorspace($palette);
  76.         }
  77.         $this->palette = $palette;
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      *
  83.      * @see \Imagine\Image\AbstractImage::__clone()
  84.      */
  85.     public function __clone()
  86.     {
  87.         parent::__clone();
  88.         if ($this->imagick instanceof \Imagick) {
  89.             $this->imagick = $this->cloneImagick();
  90.         }
  91.         $this->palette = clone $this->palette;
  92.         if ($this->layers !== null) {
  93.             $this->layers = $this->getClassFactory()->createLayers(ClassFactoryInterface::HANDLE_IMAGICK, $this, $this->layers->key());
  94.         }
  95.     }
  97.     /**
  98.      * Destroys allocated imagick resources.
  99.      */
  100.     public function __destruct()
  101.     {
  102.         if ($this->imagick instanceof \Imagick) {
  103.             $this->imagick->clear();
  104.             $this->imagick->destroy();
  105.         }
  106.     }
  108.     /**
  109.      * {@inheritdoc}
  110.      *
  111.      * @see \Imagine\Driver\InfoProvider::getDriverInfo()
  112.      * @since 1.3.0
  113.      */
  114.     public static function getDriverInfo($required = true)
  115.     {
  116.         return DriverInfo::get($required);
  117.     }
  119.     /**
  120.      * Returns the underlying \Imagick instance.
  121.      *
  122.      * @return \Imagick
  123.      */
  124.     public function getImagick()
  125.     {
  126.         return $this->imagick;
  127.     }
  129.     /**
  130.      * {@inheritdoc}
  131.      *
  132.      * @see \Imagine\Image\ManipulatorInterface::copy()
  133.      */
  134.     public function copy()
  135.     {
  136.         try {
  137.             return clone $this;
  138.         } catch (\ImagickException $e) {
  139.             throw new RuntimeException('Copy operation failed', $e->getCode(), $e);
  140.         }
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      *
  146.      * @see \Imagine\Image\ManipulatorInterface::crop()
  147.      */
  148.     public function crop(PointInterface $start, BoxInterface $size)
  149.     {
  150.         if (!$start->in($this->getSize())) {
  151.             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');
  152.         }
  153.         try {
  154.             if ($this->layers()->count() > 1) {
  155.                 // Crop each layer separately
  156.                 $this->imagick = $this->imagick->coalesceImages();
  157.                 foreach ($this->imagick as $frame) {
  158.                     $frame->cropImage($size->getWidth(), $size->getHeight(), $start->getX(), $start->getY());
  159.                     // Reset canvas for gif format
  160.                     $frame->setImagePage(0, 0, 0, 0);
  161.                 }
  162.                 $this->imagick = $this->imagick->deconstructImages();
  163.             } else {
  164.                 $this->imagick->cropImage($size->getWidth(), $size->getHeight(), $start->getX(), $start->getY());
  165.                 // Reset canvas for gif format
  166.                 $this->imagick->setImagePage(0, 0, 0, 0);
  167.             }
  168.         } catch (\ImagickException $e) {
  169.             throw new RuntimeException('Crop operation failed', $e->getCode(), $e);
  170.         }
  172.         return $this;
  173.     }
  175.     /**
  176.      * {@inheritdoc}
  177.      *
  178.      * @see \Imagine\Image\ManipulatorInterface::flipHorizontally()
  179.      */
  180.     public function flipHorizontally()
  181.     {
  182.         try {
  183.             $this->imagick->flopImage();
  184.         } catch (\ImagickException $e) {
  185.             throw new RuntimeException('Horizontal Flip operation failed', $e->getCode(), $e);
  186.         }
  188.         return $this;
  189.     }
  191.     /**
  192.      * {@inheritdoc}
  193.      *
  194.      * @see \Imagine\Image\ManipulatorInterface::flipVertically()
  195.      */
  196.     public function flipVertically()
  197.     {
  198.         try {
  199.             $this->imagick->flipImage();
  200.         } catch (\ImagickException $e) {
  201.             throw new RuntimeException('Vertical flip operation failed', $e->getCode(), $e);
  202.         }
  204.         return $this;
  205.     }
  207.     /**
  208.      * {@inheritdoc}
  209.      *
  210.      * @see \Imagine\Image\ManipulatorInterface::strip()
  211.      */
  212.     public function strip()
  213.     {
  214.         try {
  215.             try {
  216.                 $this->profile($this->palette->profile());
  217.             } catch (\Exception $e) {
  218.                 // here we discard setting the profile as the previous incorporated profile
  219.                 // is corrupted, let's now strip the image
  220.             }
  221.             $this->imagick->stripImage();
  222.         } catch (\ImagickException $e) {
  223.             throw new RuntimeException('Strip operation failed', $e->getCode(), $e);
  224.         }
  226.         return $this;
  227.     }
  229.     /**
  230.      * {@inheritdoc}
  231.      *
  232.      * @see \Imagine\Image\ManipulatorInterface::paste()
  233.      */
  234.     public function paste(ImageInterface $image, PointInterface $start, $alpha = 100)
  235.     {
  236.         if (!$image instanceof self) {
  237.             throw new InvalidArgumentException(sprintf('Imagick\Image can only paste() Imagick\Image instances, %s given', get_class($image)));
  238.         }
  240.         $alpha = (int) round($alpha);
  241.         if ($alpha < 0 || $alpha > 100) {
  242.             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));
  243.         }
  245.         if ($alpha === 100) {
  246.             $pasteMe = $image->imagick;
  247.         } elseif ($alpha > 0) {
  248.             $pasteMe = $image->cloneImagick();
  249.             // setImageOpacity was replaced with setImageAlpha in php-imagick v3.4.3
  250.             if (method_exists($pasteMe, 'setImageAlpha')) {
  251.                 $pasteMe->setImageAlpha($alpha / 100);
  252.             } else {
  253.                 ErrorHandling::ignoring(E_DEPRECATED, function () use ($pasteMe, $alpha) {
  254.                     $pasteMe->setImageOpacity($alpha / 100);
  255.                 });
  256.             }
  257.         } else {
  258.             $pasteMe = null;
  259.         }
  260.         if ($pasteMe !== null) {
  261.             try {
  262.                 $this->imagick->compositeImage($pasteMe, \Imagick::COMPOSITE_DEFAULT, $start->getX(), $start->getY());
  263.                 $error = null;
  264.             } catch (\ImagickException $e) {
  265.                 $error = $e;
  266.             }
  267.             if ($pasteMe !== $image->imagick) {
  268.                 $pasteMe->clear();
  269.                 $pasteMe->destroy();
  270.             }
  271.             if ($error !== null) {
  272.                 throw new RuntimeException('Paste operation failed', $error->getCode(), $error);
  273.             }
  274.         }
  276.         return $this;
  277.     }
  279.     /**
  280.      * {@inheritdoc}
  281.      *
  282.      * @see \Imagine\Image\ManipulatorInterface::resize()
  283.      */
  284.     public function resize(BoxInterface $size, $filter = ImageInterface::FILTER_UNDEFINED)
  285.     {
  286.         try {
  287.             if ($this->layers()->count() > 1) {
  288.                 $this->imagick = $this->imagick->coalesceImages();
  289.                 foreach ($this->imagick as $frame) {
  290.                     $frame->resizeImage($size->getWidth(), $size->getHeight(), $this->getFilter($filter), 1);
  291.                 }
  292.                 $this->imagick = $this->imagick->deconstructImages();
  293.             } else {
  294.                 $this->imagick->resizeImage($size->getWidth(), $size->getHeight(), $this->getFilter($filter), 1);
  295.             }
  296.         } catch (\ImagickException $e) {
  297.             throw new RuntimeException('Resize operation failed', $e->getCode(), $e);
  298.         }
  300.         return $this;
  301.     }
  303.     /**
  304.      * {@inheritdoc}
  305.      *
  306.      * @see \Imagine\Image\ManipulatorInterface::rotate()
  307.      */
  308.     public function rotate($angle, ColorInterface $background = null)
  309.     {
  310.         if ($background === null) {
  311.             $background = $this->palette->color('fff');
  312.         }
  314.         try {
  315.             $pixel = $this->getColor($background);
  317.             $this->imagick->rotateimage($pixel, $angle);
  318.             $this->imagick->setImagePage(0, 0, 0, 0);
  320.             $pixel->clear();
  321.             $pixel->destroy();
  322.         } catch (\ImagickException $e) {
  323.             throw new RuntimeException('Rotate operation failed', $e->getCode(), $e);
  324.         }
  326.         return $this;
  327.     }
  329.     /**
  330.      * {@inheritdoc}
  331.      *
  332.      * @see \Imagine\Image\ManipulatorInterface::save()
  333.      */
  334.     public function save($path = null, array $options = array())
  335.     {
  336.         $path = $path === null ? $this->imagick->getImageFilename() : $path;
  337.         if ($path === null) {
  338.             throw new RuntimeException('You can omit save path only if image has been open from a file');
  339.         }
  341.         try {
  342.             $this->prepareOutput($options, $path);
  343.             $this->imagick->writeImages($path, true);
  344.         } catch (\ImagickException $e) {
  345.             throw new RuntimeException('Save operation failed', $e->getCode(), $e);
  346.         }
  348.         return $this;
  349.     }
  351.     /**
  352.      * {@inheritdoc}
  353.      *
  354.      * @see \Imagine\Image\ManipulatorInterface::show()
  355.      */
  356.     public function show($format, array $options = array())
  357.     {
  358.         $formatInfo = static::getDriverInfo()->getSupportedFormats()->find($format);
  359.         if ($formatInfo === null) {
  360.             throw new InvalidArgumentException(sprintf(
  361.                 'Displaying an image in "%s" format is not supported, please use one of the following formats: "%s"',
  362.                 $format,
  363.                 implode('", "', static::getDriverInfo()->getSupportedFormats()->getAllIDs())
  364.             ));
  365.         }
  366.         header('Content-type: ' . $formatInfo->getMimeType());
  367.         echo $this->get($format, $options);
  369.         return $this;
  370.     }
  372.     /**
  373.      * {@inheritdoc}
  374.      *
  375.      * @see \Imagine\Image\ImageInterface::get()
  376.      */
  377.     public function get($format, array $options = array())
  378.     {
  379.         try {
  380.             $options['format'] = $format;
  381.             $this->prepareOutput($options);
  382.         } catch (\ImagickException $e) {
  383.             throw new RuntimeException('Get operation failed', $e->getCode(), $e);
  384.         }
  386.         return $this->imagick->getImagesBlob();
  387.     }
  389.     /**
  390.      * {@inheritdoc}
  391.      *
  392.      * @see \Imagine\Image\ImageInterface::interlace()
  393.      */
  394.     public function interlace($scheme)
  395.     {
  396.         static $supportedInterlaceSchemes = array(
  397.             ImageInterface::INTERLACE_NONE => \Imagick::INTERLACE_NO,
  398.             ImageInterface::INTERLACE_LINE => \Imagick::INTERLACE_LINE,
  399.             ImageInterface::INTERLACE_PLANE => \Imagick::INTERLACE_PLANE,
  400.             ImageInterface::INTERLACE_PARTITION => \Imagick::INTERLACE_PARTITION,
  401.         );
  403.         if (!array_key_exists($scheme, $supportedInterlaceSchemes)) {
  404.             throw new InvalidArgumentException('Unsupported interlace type');
  405.         }
  407.         $this->imagick->setInterlaceScheme($supportedInterlaceSchemes[$scheme]);
  409.         return $this;
  410.     }
  412.     /**
  413.      * @param array $options
  414.      * @param string $path
  415.      */
  416.     private function prepareOutput(array $options, $path = null)
  417.     {
  418.         if (isset($options['animated']) && $options['animated'] === true) {
  419.             $format = isset($options['format']) ? $options['format'] : Format::ID_GIF;
  420.             $delay = isset($options['animated.delay']) ? $options['animated.delay'] : null;
  421.             $loops = isset($options['animated.loops']) ? $options['animated.loops'] : 0;
  423.             $options['flatten'] = false;
  425.             $this->layers()->animate($format, $delay, $loops);
  426.         } else {
  427.             $this->layers()->merge();
  428.         }
  429.         $this->imagick = $this->applyImageOptions($this->imagick, $options, $path);
  431.         // flatten only if image has multiple layers
  432.         if ((!isset($options['flatten']) || $options['flatten'] === true) && $this->layers()->count() > 1) {
  433.             $this->flatten();
  434.         }
  436.         if (isset($options['format'])) {
  437.             $this->imagick->setImageFormat($options['format']);
  438.         }
  439.     }
  441.     /**
  442.      * {@inheritdoc}
  443.      *
  444.      * @see \Imagine\Image\ImageInterface::__toString()
  445.      */
  446.     public function __toString()
  447.     {
  448.         return $this->get(Format::ID_PNG);
  449.     }
  451.     /**
  452.      * {@inheritdoc}
  453.      *
  454.      * @see \Imagine\Image\ImageInterface::draw()
  455.      */
  456.     public function draw()
  457.     {
  458.         return $this->getClassFactory()->createDrawer(ClassFactoryInterface::HANDLE_IMAGICK, $this->imagick);
  459.     }
  461.     /**
  462.      * {@inheritdoc}
  463.      *
  464.      * @see \Imagine\Image\ImageInterface::effects()
  465.      */
  466.     public function effects()
  467.     {
  468.         return $this->getClassFactory()->createEffects(ClassFactoryInterface::HANDLE_IMAGICK, $this->imagick);
  469.     }
  471.     /**
  472.      * {@inheritdoc}
  473.      *
  474.      * @see \Imagine\Image\ImageInterface::getSize()
  475.      */
  476.     public function getSize()
  477.     {
  478.         try {
  479.             $i = $this->imagick->getIteratorIndex();
  480.             $this->imagick->rewind();
  481.             $width = $this->imagick->getImageWidth();
  482.             $height = $this->imagick->getImageHeight();
  483.             $this->imagick->setIteratorIndex($i);
  484.         } catch (\ImagickException $e) {
  485.             throw new RuntimeException('Could not get size', $e->getCode(), $e);
  486.         }
  488.         return $this->getClassFactory()->createBox($width, $height);
  489.     }
  491.     /**
  492.      * {@inheritdoc}
  493.      *
  494.      * @see \Imagine\Image\ManipulatorInterface::applyMask()
  495.      */
  496.     public function applyMask(ImageInterface $mask)
  497.     {
  498.         if (!$mask instanceof self) {
  499.             throw new InvalidArgumentException('Can only apply instances of Imagine\Imagick\Image as masks');
  500.         }
  502.         $size = $this->getSize();
  503.         $maskSize = $mask->getSize();
  505.         if ($size != $maskSize) {
  506.             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));
  507.         }
  509.         $mask = $mask->mask();
  510.         $mask->imagick->negateImage(true);
  512.         try {
  513.             // remove transparent areas of the original from the mask
  514.             $mask->imagick->compositeImage($this->imagick, \Imagick::COMPOSITE_DSTIN, 0, 0);
  515.             $this->imagick->compositeImage($mask->imagick, \Imagick::COMPOSITE_COPYOPACITY, 0, 0);
  517.             $mask->imagick->clear();
  518.             $mask->imagick->destroy();
  519.         } catch (\ImagickException $e) {
  520.             throw new RuntimeException('Apply mask operation failed', $e->getCode(), $e);
  521.         }
  523.         return $this;
  524.     }
  526.     /**
  527.      * {@inheritdoc}
  528.      *
  529.      * @see \Imagine\Image\ImageInterface::mask()
  530.      */
  531.     public function mask()
  532.     {
  533.         $mask = $this->copy();
  535.         try {
  536.             $mask->imagick->modulateImage(100, 0, 100);
  537.             $mask->imagick->setImageMatte(false);
  538.         } catch (\ImagickException $e) {
  539.             throw new RuntimeException('Mask operation failed', $e->getCode(), $e);
  540.         }
  542.         return $mask;
  543.     }
  545.     /**
  546.      * {@inheritdoc}
  547.      *
  548.      * @see \Imagine\Image\ManipulatorInterface::fill()
  549.      */
  550.     public function fill(FillInterface $fill)
  551.     {
  552.         try {
  553.             if ($this->isLinearOpaque($fill)) {
  554.                 $this->applyFastLinear($fill);
  555.             } else {
  556.                 $iterator = $this->imagick->getPixelIterator();
  558.                 foreach ($iterator as $y => $pixels) {
  559.                     foreach ($pixels as $x => $pixel) {
  560.                         $color = $fill->getColor(new Point($x, $y));
  562.                         $pixel->setColor((string) $color);
  563.                         $pixel->setColorValue(\Imagick::COLOR_ALPHA, $color->getAlpha() / 100);
  564.                     }
  566.                     $iterator->syncIterator();
  567.                 }
  568.             }
  569.         } catch (\ImagickException $e) {
  570.             throw new RuntimeException('Fill operation failed', $e->getCode(), $e);
  571.         }
  573.         return $this;
  574.     }
  576.     /**
  577.      * {@inheritdoc}
  578.      *
  579.      * @see \Imagine\Image\ImageInterface::histogram()
  580.      */
  581.     public function histogram()
  582.     {
  583.         try {
  584.             $pixels = $this->imagick->getImageHistogram();
  585.         } catch (\ImagickException $e) {
  586.             throw new RuntimeException('Error while fetching histogram', $e->getCode(), $e);
  587.         }
  589.         $image = $this;
  591.         return array_values(array_unique(array_map(function (\ImagickPixel $pixel) use ($image) {
  592.             return $image->pixelToColor($pixel);
  593.         }, $pixels)));
  594.     }
  596.     /**
  597.      * {@inheritdoc}
  598.      *
  599.      * @see \Imagine\Image\ImageInterface::getColorAt()
  600.      */
  601.     public function getColorAt(PointInterface $point)
  602.     {
  603.         if (!$point->in($this->getSize())) {
  604.             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()));
  605.         }
  607.         try {
  608.             $pixel = $this->imagick->getImagePixelColor($point->getX(), $point->getY());
  609.         } catch (\ImagickException $e) {
  610.             throw new RuntimeException('Error while getting image pixel color', $e->getCode(), $e);
  611.         }
  613.         return $this->pixelToColor($pixel);
  614.     }
  616.     /**
  617.      * Returns a color given a pixel, depending the Palette context.
  618.      *
  619.      * Note : this method is public for PHP 5.3 compatibility
  620.      *
  621.      * @param \ImagickPixel $pixel
  622.      *
  623.      * @throws \Imagine\Exception\InvalidArgumentException In case a unknown color is requested
  624.      *
  625.      * @return \Imagine\Image\Palette\Color\ColorInterface
  626.      */
  627.     public function pixelToColor(\ImagickPixel $pixel)
  628.     {
  629.         static $colorMapping = array(
  630.             ColorInterface::COLOR_RED => \Imagick::COLOR_RED,
  631.             ColorInterface::COLOR_GREEN => \Imagick::COLOR_GREEN,
  632.             ColorInterface::COLOR_BLUE => \Imagick::COLOR_BLUE,
  633.             ColorInterface::COLOR_CYAN => \Imagick::COLOR_CYAN,
  634.             ColorInterface::COLOR_MAGENTA => \Imagick::COLOR_MAGENTA,
  635.             ColorInterface::COLOR_YELLOW => \Imagick::COLOR_YELLOW,
  636.             ColorInterface::COLOR_KEYLINE => \Imagick::COLOR_BLACK,
  637.             // There is no gray component in \Imagick, let's use one of the RGB comp
  638.             ColorInterface::COLOR_GRAY => \Imagick::COLOR_RED,
  639.         );
  641.         $alpha = $this->palette->supportsAlpha() ? (int) round($pixel->getColorValue(\Imagick::COLOR_ALPHA) * 100) : null;
  642.         if ($alpha) {
  643.             $alpha = min(max($alpha, 0), 100);
  644.         }
  646.         $multiplier = $this->palette()->getChannelsMaxValue();
  648.         return $this->palette->color(array_map(function ($color) use ($multiplier, $pixel, $colorMapping) {
  649.             if (!isset($colorMapping[$color])) {
  650.                 throw new InvalidArgumentException(sprintf('Color %s is not mapped in Imagick', $color));
  651.             }
  653.             return $pixel->getColorValue($colorMapping[$color]) * $multiplier;
  654.         }, $this->palette->pixelDefinition()), $alpha);
  655.     }
  657.     /**
  658.      * {@inheritdoc}
  659.      *
  660.      * @see \Imagine\Image\ImageInterface::layers()
  661.      */
  662.     public function layers()
  663.     {
  664.         if ($this->layers === null) {
  665.             $this->layers = $this->getClassFactory()->createLayers(ClassFactoryInterface::HANDLE_IMAGICK, $this);
  666.         }
  668.         return $this->layers;
  669.     }
  671.     /**
  672.      * {@inheritdoc}
  673.      *
  674.      * @see \Imagine\Image\ImageInterface::usePalette()
  675.      */
  676.     public function usePalette(PaletteInterface $palette)
  677.     {
  678.         if ($this->palette->name() === $palette->name()) {
  679.             return $this;
  680.         }
  682.         if (!isset(static::$colorspaceMapping[$palette->name()])) {
  683.             throw new InvalidArgumentException(sprintf('The palette %s is not supported by Imagick driver', $palette->name()));
  684.         }
  686.         static::getDriverInfo()->requireFeature(DriverInfo::FEATURE_COLORSPACECONVERSION);
  688.         try {
  689.             try {
  690.                 $hasICCProfile = (bool) $this->imagick->getImageProfile('icc');
  691.             } catch (\ImagickException $e) {
  692.                 $hasICCProfile = false;
  693.             }
  695.             if (!$hasICCProfile) {
  696.                 $this->profile($this->palette->profile());
  697.             }
  699.             $this->profile($palette->profile());
  700.             $this->setColorspace($palette);
  701.         } catch (\ImagickException $e) {
  702.             throw new RuntimeException('Failed to set colorspace', $e->getCode(), $e);
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * {@inheritdoc}
  710.      *
  711.      * @see \Imagine\Image\ImageInterface::palette()
  712.      */
  713.     public function palette()
  714.     {
  715.         return $this->palette;
  716.     }
  718.     /**
  719.      * {@inheritdoc}
  720.      *
  721.      * @see \Imagine\Image\ImageInterface::profile()
  722.      */
  723.     public function profile(ProfileInterface $profile)
  724.     {
  725.         static::getDriverInfo()->requireFeature(DriverInfo::FEATURE_COLORPROFILES);
  726.         try {
  727.             $this->imagick->profileImage('icc', $profile->data());
  728.         } catch (\ImagickException $e) {
  729.             throw new RuntimeException(sprintf('Unable to add profile %s to image', $profile->name()), $e->getCode(), $e);
  730.         }
  732.         return $this;
  733.     }
  735.     /**
  736.      * Flatten the image.
  737.      */
  738.     private function flatten()
  739.     {
  740.         // @see https://github.com/mkoppanen/imagick/issues/45
  741.         try {
  742.             if (method_exists($this->imagick, 'mergeImageLayers') && defined('Imagick::LAYERMETHOD_UNDEFINED')) {
  743.                 $this->imagick = $this->imagick->mergeImageLayers(\Imagick::LAYERMETHOD_UNDEFINED);
  744.             } elseif (method_exists($this->imagick, 'flattenImages')) {
  745.                 $this->imagick = $this->imagick->flattenImages();
  746.             }
  747.         } catch (\ImagickException $e) {
  748.             throw new RuntimeException('Flatten operation failed', $e->getCode(), $e);
  749.         }
  750.     }
  752.     /**
  753.      * Applies options before save or output.
  754.      *
  755.      * @param \Imagick $image
  756.      * @param array $options
  757.      * @param string $path
  758.      *
  759.      * @throws \Imagine\Exception\InvalidArgumentException
  760.      * @throws \Imagine\Exception\RuntimeException
  761.      *
  762.      * @return \Imagick
  763.      */
  764.     private function applyImageOptions(\Imagick $image, array $options, $path)
  765.     {
  766.         if (isset($options['format'])) {
  767.             $format = $options['format'];
  768.         } elseif ('' !== $extension = pathinfo($path, \PATHINFO_EXTENSION)) {
  769.             $format = $extension;
  770.         } else {
  771.             $format = pathinfo($image->getImageFilename(), \PATHINFO_EXTENSION);
  772.         }
  774.         $formatInfo = Format::get($format);
  775.         switch ($formatInfo === null ? '' : $formatInfo->getID()) {
  776.             case Format::ID_JPEG:
  777.                 if (!isset($options['jpeg_quality'])) {
  778.                     if (isset($options['quality'])) {
  779.                         $options['jpeg_quality'] = $options['quality'];
  780.                     }
  781.                 }
  782.                 if (isset($options['jpeg_quality'])) {
  783.                     $image->setimagecompressionquality($options['jpeg_quality']);
  784.                     $image->setcompressionquality($options['jpeg_quality']);
  785.                 }
  786.                 if (isset($options['jpeg_sampling_factors'])) {
  787.                     if (!is_array($options['jpeg_sampling_factors']) || \count($options['jpeg_sampling_factors']) < 1) {
  788.                         throw new InvalidArgumentException('jpeg_sampling_factors option should be an array of integers');
  789.                     }
  790.                     $image->setSamplingFactors(array_map(function ($factor) {
  791.                         return (int) $factor;
  792.                     }, $options['jpeg_sampling_factors']));
  793.                 }
  794.                 break;
  795.             case Format::ID_PNG:
  796.                 if (!isset($options['png_compression_level'])) {
  797.                     if (isset($options['quality'])) {
  798.                         $options['png_compression_level'] = round((100 - $options['quality']) * 9 / 100);
  799.                     }
  800.                 }
  801.                 if (isset($options['png_compression_level'])) {
  802.                     if ($options['png_compression_level'] < 0 || $options['png_compression_level'] > 9) {
  803.                         throw new InvalidArgumentException('png_compression_level option should be an integer from 0 to 9');
  804.                     }
  805.                 }
  806.                 if (isset($options['png_compression_filter'])) {
  807.                     if ($options['png_compression_filter'] < 0 || $options['png_compression_filter'] > 9) {
  808.                         throw new InvalidArgumentException('png_compression_filter option should be an integer from 0 to 9');
  809.                     }
  810.                 }
  811.                 if (isset($options['png_compression_level']) || isset($options['png_compression_filter'])) {
  812.                     // first digit: compression level (default: 7)
  813.                     $compression = isset($options['png_compression_level']) ? $options['png_compression_level'] * 10 : 70;
  814.                     // second digit: compression filter (default: 5)
  815.                     $compression += isset($options['png_compression_filter']) ? $options['png_compression_filter'] : 5;
  816.                     $image->setimagecompressionquality($compression);
  817.                     $image->setcompressionquality($compression);
  818.                 }
  819.                 break;
  820.             case Format::ID_WEBP:
  821.                 if (!isset($options['webp_quality'])) {
  822.                     if (isset($options['quality'])) {
  823.                         $options['webp_quality'] = $options['quality'];
  824.                     }
  825.                 }
  826.                 if (isset($options['webp_quality'])) {
  827.                     $image->setImageCompressionQuality($options['webp_quality']);
  828.                 }
  829.                 if (isset($options['webp_lossless'])) {
  830.                     $image->setOption('webp:lossless', $options['webp_lossless']);
  831.                 }
  832.                 break;
  833.             case Format::ID_AVIF:
  834.             case Format::ID_HEIC:
  835.                 if (!empty($options[$formatInfo->getID() . '_lossless'])) {
  836.                     $image->setimagecompressionquality(100);
  837.                     $image->setcompressionquality(100);
  838.                 } else {
  839.                     if (!isset($options[$formatInfo->getID() . '_quality'])) {
  840.                         if (isset($options['quality'])) {
  841.                             $options[$formatInfo->getID() . '_quality'] = $options['quality'];
  842.                         }
  843.                     }
  844.                     if (isset($options[$formatInfo->getID() . '_quality'])) {
  845.                         $options[$formatInfo->getID() . '_quality'] = max(1, min(99, $options[$formatInfo->getID() . '_quality']));
  846.                         $image->setimagecompressionquality($options[$formatInfo->getID() . '_quality']);
  847.                         $image->setcompressionquality($options[$formatInfo->getID() . '_quality']);
  848.                     }
  849.                 }
  850.                 break;
  851.             case Format::ID_JXL:
  852.                 if (!empty($options['jxl_lossless'])) {
  853.                     $image->setimagecompressionquality(100);
  854.                     $image->setcompressionquality(100);
  855.                 } else {
  856.                     if (!isset($options['jxl_quality'])) {
  857.                         if (isset($options['quality'])) {
  858.                             $options['jxl_quality'] = $options['quality'];
  859.                         }
  860.                     }
  861.                     if (isset($options['jxl_quality'])) {
  862.                         $options['jxl_quality'] = max(9, min(99, $options['jxl_quality']));
  863.                         $image->setimagecompressionquality($options['jxl_quality']);
  864.                         $image->setcompressionquality($options['jxl_quality']);
  865.                     }
  866.                 }
  867.                 break;
  868.         }
  869.         if (isset($options['resolution-units']) && isset($options['resolution-x']) && isset($options['resolution-y'])) {
  870.             if (empty($options['resampling-filter'])) {
  871.                 $filterName = ImageInterface::FILTER_UNDEFINED;
  872.             } else {
  873.                 $filterName = $options['resampling-filter'];
  874.             }
  875.             $filter = $this->getFilter($filterName);
  876.             switch ($options['resolution-units']) {
  877.                 case ImageInterface::RESOLUTION_PIXELSPERCENTIMETER:
  878.                     $image->setImageUnits(\Imagick::RESOLUTION_PIXELSPERCENTIMETER);
  879.                     break;
  880.                 case ImageInterface::RESOLUTION_PIXELSPERINCH:
  881.                     $image->setImageUnits(\Imagick::RESOLUTION_PIXELSPERINCH);
  882.                     break;
  883.                 default:
  884.                     throw new RuntimeException('Unsupported image unit format');
  885.             }
  886.             $image->setImageResolution($options['resolution-x'], $options['resolution-y']);
  887.             $image->resampleImage($options['resolution-x'], $options['resolution-y'], $filter, 0);
  888.         }
  889.         if (!empty($options['optimize'])) {
  890.             try {
  891.                 $image = $image->coalesceImages();
  892.                 $optimized = $image->optimizeimagelayers();
  893.             } catch (\ImagickException $e) {
  894.                 throw new RuntimeException('Image optimization failed', $e->getCode(), $e);
  895.             }
  896.             if ($optimized === false) {
  897.                 throw new RuntimeException('Image optimization failed');
  898.             }
  899.             if ($optimized instanceof \Imagick) {
  900.                 $image = $optimized;
  901.             }
  902.         }
  904.         return $image;
  905.     }
  907.     /**
  908.      * Gets specifically formatted color string from Color instance.
  909.      *
  910.      * @param \Imagine\Image\Palette\Color\ColorInterface $color
  911.      *
  912.      * @return \ImagickPixel
  913.      */
  914.     private function getColor(ColorInterface $color)
  915.     {
  916.         $pixel = new \ImagickPixel((string) $color);
  917.         $pixel->setColorValue(\Imagick::COLOR_ALPHA, $color->getAlpha() / 100);
  919.         return $pixel;
  920.     }
  922.     /**
  923.      * Checks whether given $fill is linear and opaque.
  924.      *
  925.      * @param \Imagine\Image\Fill\FillInterface $fill
  926.      *
  927.      * @return bool
  928.      */
  929.     private function isLinearOpaque(FillInterface $fill)
  930.     {
  931.         return $fill instanceof Linear && $fill->getStart()->isOpaque() && $fill->getEnd()->isOpaque();
  932.     }
  934.     /**
  935.      * Performs optimized gradient fill for non-opaque linear gradients.
  936.      *
  937.      * @param \Imagine\Image\Fill\Gradient\Linear $fill
  938.      */
  939.     private function applyFastLinear(Linear $fill)
  940.     {
  941.         $gradient = new \Imagick();
  942.         $size = $this->getSize();
  943.         $color = sprintf('gradient:%s-%s', (string) $fill->getStart(), (string) $fill->getEnd());
  945.         if ($fill instanceof Horizontal) {
  946.             $gradient->newPseudoImage($size->getHeight(), $size->getWidth(), $color);
  947.             $gradient->rotateImage(new \ImagickPixel(), 90);
  948.         } else {
  949.             $gradient->newPseudoImage($size->getWidth(), $size->getHeight(), $color);
  950.         }
  952.         $this->imagick->compositeImage($gradient, \Imagick::COMPOSITE_OVER, 0, 0);
  953.         $gradient->clear();
  954.         $gradient->destroy();
  955.     }
  957.     /**
  958.      * Sets colorspace and image type, assigns the palette.
  959.      *
  960.      * @param \Imagine\Image\Palette\PaletteInterface $palette
  961.      *
  962.      * @throws \Imagine\Exception\InvalidArgumentException
  963.      */
  964.     private function setColorspace(PaletteInterface $palette)
  965.     {
  966.         $typeMapping = array(
  967.             // We use Matte variants to preserve alpha
  968.             //
  969.             // (the IMGTYPE_...ALPHA constants are only available since ImageMagick 7 and Imagick 3.4.3, previously they were named
  970.             // IMGTYPE_...MATTE but in some combinations of different Imagick and ImageMagick versions none of them are avaiable at all,
  971.             // so we found no other way to fix it as to hard code the values here)
  972.             PaletteInterface::PALETTE_CMYK => defined('\Imagick::IMGTYPE_TRUECOLORALPHA') ? \Imagick::IMGTYPE_TRUECOLORALPHA : (defined('\Imagick::IMGTYPE_TRUECOLORMATTE') ? \Imagick::IMGTYPE_TRUECOLORMATTE : 7),
  973.             PaletteInterface::PALETTE_RGB => defined('\Imagick::IMGTYPE_TRUECOLORALPHA') ? \Imagick::IMGTYPE_TRUECOLORALPHA : (defined('\Imagick::IMGTYPE_TRUECOLORMATTE') ? \Imagick::IMGTYPE_TRUECOLORMATTE : 7),
  974.             PaletteInterface::PALETTE_GRAYSCALE => defined('\Imagick::IMGTYPE_GRAYSCALEALPHA') ? \Imagick::IMGTYPE_GRAYSCALEALPHA : (defined('\Imagick::IMGTYPE_GRAYSCALEMATTE') ? \Imagick::IMGTYPE_GRAYSCALEMATTE : 3),
  975.         );
  977.         if (!isset(static::$colorspaceMapping[$palette->name()])) {
  978.             throw new InvalidArgumentException(sprintf('The palette %s is not supported by Imagick driver', $palette->name()));
  979.         }
  981.         $this->imagick->setType($typeMapping[$palette->name()]);
  982.         $this->imagick->setColorspace(static::$colorspaceMapping[$palette->name()]);
  983.         if ($this->imagick->getnumberimages() > 0 && defined('Imagick::ALPHACHANNEL_REMOVE') && defined('Imagick::ALPHACHANNEL_SET')) {
  984.             $originalImageIndex = $this->imagick->getiteratorindex();
  985.             foreach ($this->imagick as $frame) {
  986.                 if ($palette->supportsAlpha()) {
  987.                     $frame->setimagealphachannel(\Imagick::ALPHACHANNEL_SET);
  988.                 } else {
  989.                     $frame->setimagealphachannel(\Imagick::ALPHACHANNEL_REMOVE);
  990.                 }
  991.             }
  992.             $this->imagick->setiteratorindex($originalImageIndex);
  993.         }
  994.         $this->palette = $palette;
  995.     }
  997.     /**
  998.      * Returns the filter if it's supported.
  999.      *
  1000.      * @param string $filter
  1001.      *
  1002.      * @throws \Imagine\Exception\InvalidArgumentException if the filter is unsupported
  1003.      *
  1004.      * @return string
  1005.      */
  1006.     private function getFilter($filter = ImageInterface::FILTER_UNDEFINED)
  1007.     {
  1008.         static $supportedFilters = null;
  1009.         if ($supportedFilters === null) {
  1010.             $supportedFilters = array(
  1011.                 ImageInterface::FILTER_UNDEFINED => \Imagick::FILTER_UNDEFINED,
  1012.                 ImageInterface::FILTER_BESSEL => \Imagick::FILTER_BESSEL,
  1013.                 ImageInterface::FILTER_BLACKMAN => \Imagick::FILTER_BLACKMAN,
  1014.                 ImageInterface::FILTER_BOX => \Imagick::FILTER_BOX,
  1015.                 ImageInterface::FILTER_CATROM => \Imagick::FILTER_CATROM,
  1016.                 ImageInterface::FILTER_CUBIC => \Imagick::FILTER_CUBIC,
  1017.                 ImageInterface::FILTER_GAUSSIAN => \Imagick::FILTER_GAUSSIAN,
  1018.                 ImageInterface::FILTER_HANNING => \Imagick::FILTER_HANNING,
  1019.                 ImageInterface::FILTER_HAMMING => \Imagick::FILTER_HAMMING,
  1020.                 ImageInterface::FILTER_HERMITE => \Imagick::FILTER_HERMITE,
  1021.                 ImageInterface::FILTER_LANCZOS => \Imagick::FILTER_LANCZOS,
  1022.                 ImageInterface::FILTER_MITCHELL => \Imagick::FILTER_MITCHELL,
  1023.                 ImageInterface::FILTER_POINT => \Imagick::FILTER_POINT,
  1024.                 ImageInterface::FILTER_QUADRATIC => \Imagick::FILTER_QUADRATIC,
  1025.                 ImageInterface::FILTER_SINC => \Imagick::FILTER_SINC,
  1026.                 ImageInterface::FILTER_TRIANGLE => \Imagick::FILTER_TRIANGLE,
  1027.             );
  1028.             if (defined('Imagick::FILTER_SINCFAST')) {
  1029.                 $supportedFilters[ImageInterface::FILTER_SINCFAST] = \Imagick::FILTER_SINCFAST;
  1030.             }
  1031.         }
  1032.         if (!in_array($filter, static::getAllFilterValues(), true)) {
  1033.             throw new InvalidArgumentException('Unsupported filter type');
  1034.         }
  1035.         if (!array_key_exists($filter, $supportedFilters)) {
  1036.             $filter = ImageInterface::FILTER_UNDEFINED;
  1037.         }
  1039.         return $supportedFilters[$filter];
  1040.     }
  1042.     /**
  1043.      * Clone the Imagick resource of this instance.
  1044.      *
  1045.      * @throws \ImagickException
  1046.      *
  1047.      * @return \Imagick
  1048.      */
  1049.     protected function cloneImagick()
  1050.     {
  1051.         // the clone method has been deprecated in imagick 3.1.0b1.
  1052.         // we can't use phpversion('imagick') because it may return `@PACKAGE_VERSION@`
  1053.         // so, let's check if ImagickDraw has the setResolution method, which has been introduced in the same version 3.1.0b1
  1054.         if (method_exists('ImagickDraw', 'setResolution')) {
  1055.             return clone $this->imagick;
  1056.         }
  1058.         return $this->imagick->clone();
  1059.     }
  1060. }