vendor/sulu/sulu/src/Sulu/Bundle/MediaBundle/Media/ImageConverter/ImagineImageConverter.php line 271

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Bundle\MediaBundle\Media\ImageConverter;
  14. use Imagine\Exception\RuntimeException;
  15. use Imagine\Filter\Basic\Autorotate;
  16. use Imagine\Image\ImageInterface;
  17. use Imagine\Image\ImagineInterface;
  18. use Imagine\Image\Palette\RGB;
  19. use Sulu\Bundle\MediaBundle\Entity\FileVersion;
  20. use Sulu\Bundle\MediaBundle\Entity\FormatOptions;
  21. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyInvalidFormatOptionsException;
  22. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyInvalidImageFormat;
  23. use Sulu\Bundle\MediaBundle\Media\Exception\InvalidFileTypeException;
  24. use Sulu\Bundle\MediaBundle\Media\ImageConverter\Cropper\CropperInterface;
  25. use Sulu\Bundle\MediaBundle\Media\ImageConverter\Focus\FocusInterface;
  26. use Sulu\Bundle\MediaBundle\Media\ImageConverter\Scaler\ScalerInterface;
  27. use Sulu\Bundle\MediaBundle\Media\Storage\StorageInterface;
  29. /**
  30.  * Sulu imagine converter for media.
  31.  */
  32. class ImagineImageConverter implements ImageConverterInterface
  33. {
  34.     /**
  35.      * @var ImagineInterface
  36.      */
  37.     private $imagine;
  39.     /**
  40.      * @var ImagineInterface
  41.      */
  42.     private $svgImagine;
  44.     /**
  45.      * @var StorageInterface
  46.      */
  47.     private $storage;
  49.     /**
  50.      * @var MediaImageExtractorInterface
  51.      */
  52.     private $mediaImageExtractor;
  54.     /**
  55.      * @var TransformationPoolInterface
  56.      */
  57.     private $transformationPool;
  59.     /**
  60.      * @var FocusInterface
  61.      */
  62.     private $focus;
  64.     /**
  65.      * @var ScalerInterface
  66.      */
  67.     private $scaler;
  69.     /**
  70.      * @var CropperInterface
  71.      */
  72.     private $cropper;
  74.     /**
  75.      * @var array
  76.      */
  77.     private $formats;
  79.     /**
  80.      * @var array
  81.      */
  82.     private $supportedMimeTypes;
  84.     public function __construct(
  85.         ImagineInterface $imagine,
  86.         StorageInterface $storage,
  87.         MediaImageExtractorInterface $mediaImageExtractor,
  88.         TransformationPoolInterface $transformationPool,
  89.         FocusInterface $focus,
  90.         ScalerInterface $scaler,
  91.         CropperInterface $cropper,
  92.         array $formats,
  93.         array $supportedMimeTypes,
  94.         ?ImagineInterface $svgImagine = null
  95.     ) {
  96.         $this->imagine = $imagine;
  97.         $this->storage = $storage;
  98.         $this->mediaImageExtractor = $mediaImageExtractor;
  99.         $this->transformationPool = $transformationPool;
  100.         $this->focus = $focus;
  101.         $this->scaler = $scaler;
  102.         $this->cropper = $cropper;
  103.         $this->formats = $formats;
  104.         $this->supportedMimeTypes = $supportedMimeTypes;
  105.         $this->svgImagine = $svgImagine;
  106.     }
  108.     public function getSupportedOutputImageFormats(?string $mimeType): array
  109.     {
  110.         if (!$mimeType) {
  111.             return [];
  112.         }
  114.         foreach ($this->supportedMimeTypes as $supportedMimeType) {
  115.             if (\fnmatch($supportedMimeType, $mimeType)) {
  116.                 $preferredExtension = 'jpg';
  118.                 switch ($mimeType) {
  119.                     case 'image/png':
  120.                         $preferredExtension = 'png';
  121.                         break;
  122.                     case 'image/svg+xml':
  123.                     case 'image/svg':
  124.                         $preferredExtension = 'png';
  125.                         if ($this->svgImagine) {
  126.                             $preferredExtension = 'svg';
  127.                         }
  128.                         break;
  129.                     case 'image/webp':
  130.                         $preferredExtension = 'webp';
  131.                         break;
  132.                     case 'image/gif':
  133.                         $preferredExtension = 'gif';
  134.                         break;
  135.                 }
  137.                 return \array_unique([
  138.                     $preferredExtension,
  139.                     'jpg',
  140.                     'gif',
  141.                     'png',
  142.                     'webp',
  143.                 ]);
  144.             }
  145.         }
  147.         return [];
  148.     }
  150.     public function convert(FileVersion $fileVersion, $formatKey, $imageFormat)
  151.     {
  152.         $imageResource = $this->mediaImageExtractor->extract(
  153.             $this->storage->load($fileVersion->getStorageOptions()),
  154.             $fileVersion->getMimeType()
  155.         );
  157.         $imagine = $this->imagine;
  158.         if ('svg' === $imageFormat && $this->svgImagine) {
  159.             $imagine = $this->svgImagine;
  160.         }
  162.         try {
  163.             $image = $imagine->read($imageResource);
  164.         } catch (RuntimeException $e) {
  165.             throw new InvalidFileTypeException($e->getMessage(), $e);
  166.         }
  168.         $image = $this->toRGB($image);
  170.         $image = $this->autorotate($image);
  172.         $format = $this->getFormat($formatKey);
  174.         $cropParameters = $this->getCropParameters(
  175.             $image,
  176.             $fileVersion->getFormatOptions()->get($formatKey),
  177.             $this->formats[$formatKey]
  178.         );
  180.         if (isset($cropParameters)) {
  181.             $image = $this->applyFormatCrop($image, $cropParameters);
  182.         } elseif (isset($format['scale']) && ImageInterface::THUMBNAIL_INSET !== $format['scale']['mode']) {
  183.             $image = $this->applyFocus($image, $fileVersion, $format['scale']);
  184.         }
  186.         if (isset($format['scale'])) {
  187.             $image = $this->applyScale($image, $format['scale']);
  188.         }
  190.         if (isset($format['transformations'])) {
  191.             $image = $this->applyTransformations($image, $format['transformations']);
  192.         }
  194.         $image->strip();
  196.         try {
  197.             // Set Interlacing to plane for smaller image size.
  198.             if (1 == \count($image->layers())) {
  199.                 $image->interlace(ImageInterface::INTERLACE_PLANE);
  200.             }
  201.         } catch (RuntimeException $exception) {
  202.             // ignore exceptions here (some imagine adapter does not implement this)
  203.         }
  205.         $imagineOptions = $format['options'];
  207.         return $image->get(
  208.             $imageFormat,
  209.             $this->getOptionsFromImage($image, $imageFormat, $imagineOptions)
  210.         );
  211.     }
  213.     /**
  214.      * Applies an array of transformations on a passed image.
  215.      *
  216.      * @param array $tansformations
  217.      *
  218.      * @return ImageInterface The modified image
  219.      *
  220.      * @throws ImageProxyInvalidFormatOptionsException
  221.      */
  222.     private function applyTransformations(ImageInterface $image, $tansformations)
  223.     {
  224.         foreach ($tansformations as $transformation) {
  225.             if (!isset($transformation['effect'])) {
  226.                 throw new ImageProxyInvalidFormatOptionsException('Effect not found');
  227.             }
  228.             $image = $this->modifyAllLayers(
  229.                 $image,
  230.                 function(ImageInterface $layer) use ($transformation) {
  231.                     return $this->transformationPool->get($transformation['effect'])->execute(
  232.                         $layer,
  233.                         $transformation['parameters']
  234.                     );
  235.                 }
  236.             );
  237.         }
  239.         return $image;
  240.     }
  242.     /**
  243.      * Crops a given image according to given parameters.
  244.      *
  245.      * @param ImageInterface $image The image to crop
  246.      * @param array $cropParameters The parameters which define the area to crop
  247.      *
  248.      * @return ImageInterface The cropped image
  249.      */
  250.     private function applyFormatCrop(ImageInterface $image, array $cropParameters)
  251.     {
  252.         return $this->modifyAllLayers(
  253.             $image,
  254.             function(ImageInterface $layer) use ($cropParameters) {
  255.                 return $this->cropper->crop(
  256.                     $layer,
  257.                     $cropParameters['x'],
  258.                     $cropParameters['y'],
  259.                     $cropParameters['width'],
  260.                     $cropParameters['height']
  261.                 );
  262.             }
  263.         );
  264.     }
  266.     /**
  267.      * Crops the given image according to the focus point defined in the file version.
  268.      *
  269.      * @return ImageInterface
  270.      */
  271.     private function applyFocus(ImageInterface $image, FileVersion $fileVersion, array $scale)
  272.     {
  273.         return $this->modifyAllLayers(
  274.             $image,
  275.             function(ImageInterface $layer) use ($fileVersion, $scale) {
  276.                 return $this->focus->focus(
  277.                     $layer,
  278.                     $fileVersion->getFocusPointX(),
  279.                     $fileVersion->getFocusPointY(),
  280.                     $scale['x'],
  281.                     $scale['y']
  282.                 );
  283.             }
  284.         );
  285.     }
  287.     /**
  288.      * Scales a given image according to the information passed as the second argument.
  289.      *
  290.      * @param array $scale
  291.      *
  292.      * @return ImageInterface
  293.      */
  294.     private function applyScale(ImageInterface $image, $scale)
  295.     {
  296.         return $this->modifyAllLayers(
  297.             $image,
  298.             function(ImageInterface $layer) use ($scale) {
  299.                 return $this->scaler->scale(
  300.                     $layer,
  301.                     $scale['x'],
  302.                     $scale['y'],
  303.                     $scale['mode'],
  304.                     $scale['forceRatio'],
  305.                     $scale['retina']
  306.                 );
  307.             }
  308.         );
  309.     }
  311.     /**
  312.      * Ensures that the color mode of the passed image is RGB.
  313.      *
  314.      * @return ImageInterface $image The modified image
  315.      */
  316.     private function toRGB(ImageInterface $image)
  317.     {
  318.         if ('cmyk' == $image->palette()->name()) {
  319.             $image->usePalette(new RGB());
  320.         }
  322.         return $image;
  323.     }
  325.     /**
  326.      * Autorotate based on metadata of an image.
  327.      *
  328.      * @return ImageInterface
  329.      */
  330.     private function autorotate(ImageInterface $image)
  331.     {
  332.         $autorotateFilter = new Autorotate();
  334.         return $autorotateFilter->apply($image);
  335.     }
  337.     /**
  338.      * Constructs the parameters for the cropper. Returns null when
  339.      * the image should not be cropped.
  340.      *
  341.      * @param FormatOptions|null $formatOptions
  342.      *
  343.      * @return ?array
  344.      */
  345.     private function getCropParameters(ImageInterface $image, $formatOptions, array $format)
  346.     {
  347.         if (isset($formatOptions)) {
  348.             $parameters = [
  349.                 'x' => $formatOptions->getCropX(),
  350.                 'y' => $formatOptions->getCropY(),
  351.                 'width' => $formatOptions->getCropWidth(),
  352.                 'height' => $formatOptions->getCropHeight(),
  353.             ];
  355.             if ($this->cropper->isValid(
  356.                 $image,
  357.                 $parameters['x'],
  358.                 $parameters['y'],
  359.                 $parameters['width'],
  360.                 $parameters['height'],
  361.                 $format
  362.             )) {
  363.                 return $parameters;
  364.             }
  365.         }
  367.         return null;
  368.     }
  370.     /**
  371.      * Applies a callback to every layer of an image and returns the resulting image.
  372.      *
  373.      * @param callable $modifier The callable to apply to all layers
  374.      *
  375.      * @return ImageInterface
  376.      */
  377.     private function modifyAllLayers(ImageInterface $image, callable $modifier)
  378.     {
  379.         try {
  380.             $layers = $image->layers();
  381.         } catch (RuntimeException $exception) {
  382.             $layers = [];
  383.         }
  385.         if (\count($layers) > 1) {
  386.             $countLayer = 0;
  387.             $image->layers()->coalesce();
  389.             /** @var ImageInterface $temporaryImage */
  390.             $temporaryImage = null;
  391.             foreach ($image->layers() as $layer) {
  392.                 ++$countLayer;
  393.                 $layer = \call_user_func($modifier, $layer);
  394.                 if (1 === $countLayer) {
  395.                     $temporaryImage = clone $layer; // use first layer as main image
  396.                 } else {
  397.                     $temporaryImage->layers()->add($layer);
  398.                 }
  399.             }
  400.             $image = $temporaryImage;
  401.         } else {
  402.             $image = \call_user_func($modifier, $image);
  403.         }
  405.         return $image;
  406.     }
  408.     /**
  409.      * Return the options for the given format.
  410.      *
  411.      * @param string $formatKey
  412.      *
  413.      * @return array
  414.      *
  415.      * @throws ImageProxyInvalidImageFormat
  416.      */
  417.     private function getFormat($formatKey)
  418.     {
  419.         if (!isset($this->formats[$formatKey])) {
  420.             throw new ImageProxyInvalidImageFormat('Format was not found');
  421.         }
  423.         return $this->formats[$formatKey];
  424.     }
  426.     /**
  427.      * @param string $imageExtension
  428.      * @param array $imagineOptions
  429.      *
  430.      * @return array
  431.      */
  432.     private function getOptionsFromImage(ImageInterface $image, $imageExtension, $imagineOptions)
  433.     {
  434.         $options = [];
  435.         if ('gif' == $imageExtension && \count($image->layers()) > 1) {
  436.             $options['animated'] = true;
  437.             $options['optimize'] = true;
  438.         }
  440.         return \array_merge($options, $imagineOptions);
  441.     }
  442. }