core/lib/Thelia/Action/Image.php line 91

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\Action;
  15. use Imagine\Gd\Imagine;
  16. use Imagine\Gmagick\Imagine as GmagickImagine;
  17. use Imagine\Image\Box;
  18. use Imagine\Image\ImageInterface;
  19. use Imagine\Image\ImagineInterface;
  20. use Imagine\Image\Palette\RGB;
  21. use Imagine\Image\Point;
  22. use Imagine\Imagick\Imagine as ImagickImagine;
  23. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  24. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  25. use Thelia\Core\Event\Image\ImageEvent;
  26. use Thelia\Core\Event\TheliaEvents;
  27. use Thelia\Exception\ImageException;
  28. use Thelia\Model\ConfigQuery;
  29. use Thelia\Tools\URL;
  31. /**
  32.  * Image management actions. This class handles image processing and caching.
  33.  *
  34.  * Basically, images are stored outside of the web space (by default in local/media/images),
  35.  * and cached inside the web space (by default in web/local/images).
  36.  *
  37.  * In the images caches directory, a subdirectory for images categories (eg. product, category, folder, etc.) is
  38.  * automatically created, and the cached image is created here. Plugin may use their own subdirectory as required.
  39.  *
  40.  * The cached image name contains a hash of the processing options, and the original (normalized) name of the image.
  41.  *
  42.  * A copy (or symbolic link, by default) of the original image is always created in the cache, so that the full
  43.  * resolution image is always available.
  44.  *
  45.  * Various image processing options are available :
  46.  *
  47.  * - resizing, with border, crop, or by keeping image aspect ratio
  48.  * - rotation, in degrees, positive or negative
  49.  * - background color, applyed to empty background when creating borders or rotating
  50.  * - effects. The effects are applied in the specified order. The following effects are available:
  51.  *    - gamma:value : change the image Gamma to the specified value. Example: gamma:0.7
  52.  *    - grayscale or greyscale: switch image to grayscale
  53.  *    - colorize:color : apply a color mask to the image. Exemple: colorize:#ff2244
  54.  *    - negative : transform the image in its negative equivalent
  55.  *    - vflip or vertical_flip : vertical flip
  56.  *    - hflip or horizontal_flip : horizontal flip
  57.  *
  58.  * If a problem occurs, an ImageException may be thrown.
  59.  *
  60.  * @author Franck Allimant <franck@cqfdev.fr>
  61.  */
  62. class Image extends BaseCachedFile implements EventSubscriberInterface
  63. {
  64.     // Resize mode constants
  65.     public const EXACT_RATIO_WITH_BORDERS = 1;
  66.     public const EXACT_RATIO_WITH_CROP = 2;
  67.     public const KEEP_IMAGE_RATIO = 3;
  69.     /**
  70.      * @return string root of the image cache directory in web space
  71.      */
  72.     protected function getCacheDirFromWebRoot()
  73.     {
  74.         return ConfigQuery::read('image_cache_dir_from_web_root', 'cache'.DS.'images');
  75.     }
  77.     /**
  78.      * Process image and write the result in the image cache.
  79.      *
  80.      * If the image already exists in cache, the cache file is immediately returned, without any processing
  81.      * If the original (full resolution) image is required, create either a symbolic link with the
  82.      * original image in the cache dir, or copy it in the cache dir.
  83.      *
  84.      * This method updates the cache_file_path and file_url attributes of the event
  85.      *
  86.      * @param string $eventName
  87.      *
  88.      * @throws \Thelia\Exception\ImageException
  89.      * @throws \InvalidArgumentException
  90.      */
  91.     public function processImage(ImageEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  92.     {
  93.         $subdir = $event->getCacheSubdirectory();
  94.         $sourceFile = $event->getSourceFilepath();
  96.         $imageExt = pathinfo($sourceFile, \PATHINFO_EXTENSION);
  98.         if (null == $subdir || null == $sourceFile) {
  99.             throw new \InvalidArgumentException('Cache sub-directory and source file path cannot be null');
  100.         }
  102.         // Find cached file path
  103.         $cacheFilePath = $this->getCacheFilePath($subdir, $sourceFile, $event->isOriginalImage(), $event->getOptionsHash());
  105.         // Alternative image path is for browser that don't support webp
  106.         $alternativeImagePath = null;
  108.         if ($event->getFormat()) {
  109.             $sourceExtension = pathinfo($cacheFilePath, \PATHINFO_EXTENSION);
  110.             if ($event->getFormat() === 'webp') {
  111.                 $alternativeImagePath = $cacheFilePath;
  112.             }
  113.             $cacheFilePath = str_replace($sourceExtension, $event->getFormat(), $cacheFilePath);
  114.         }
  116.         $originalImagePathInCache = $this->getCacheFilePath($subdir, $sourceFile, true);
  118.         if (!file_exists($cacheFilePath)) {
  119.             if (!file_exists($sourceFile)) {
  120.                 throw new ImageException(sprintf('Source image file %s does not exists.', $sourceFile));
  121.             }
  123.             // Create a cached version of the original image in the web space, if not exists
  125.             if (!file_exists($originalImagePathInCache)) {
  126.                 $mode = ConfigQuery::read('original_image_delivery_mode', 'symlink');
  128.                 if ($mode == 'symlink') {
  129.                     if (false === symlink($sourceFile, $originalImagePathInCache)) {
  130.                         throw new ImageException(sprintf('Failed to create symbolic link for %s in %s image cache directory', basename($sourceFile), $subdir));
  131.                     }
  132.                 } else {
  133.                     // mode = 'copy'
  134.                     if (false === @copy($sourceFile, $originalImagePathInCache)) {
  135.                         throw new ImageException(sprintf('Failed to copy %s in %s image cache directory', basename($sourceFile), $subdir));
  136.                     }
  137.                 }
  138.             }
  140.             // Process image only if we have some transformations to do.
  141.             if (!$event->isOriginalImage()) {
  142.                 if ('svg' === $imageExt) {
  143.                     $dom = new \DOMDocument('1.0', 'utf-8');
  144.                     $dom->load($originalImagePathInCache);
  145.                     $svg = $dom->documentElement;
  147.                     if (!$svg->hasAttribute('viewBox')) {
  148.                         $pattern = '/^(\d*\.\d+|\d+)(px)?$/';
  150.                         $interpretable = preg_match($pattern, $svg->getAttribute('width'), $width) &&
  151.                             preg_match($pattern, $svg->getAttribute('height'), $height);
  153.                         if (!$interpretable || !isset($width) || !isset($height)) {
  154.                             throw new \Exception("can't create viewBox if height and width is not defined in the svg file");
  155.                         }
  157.                         $viewBox = implode(' ', [0, 0, $width[0], $height[0]]);
  158.                         $svg->setAttribute('viewBox', $viewBox);
  159.                     }
  160.                     $svg->setAttribute('width', $event->getWidth());
  161.                     $svg->setAttribute('height', $event->getWidth());
  162.                     $dom->save($cacheFilePath);
  163.                 } else {
  164.                     $this->applyTransformation($sourceFile, $event, $dispatcher, $cacheFilePath);
  165.                     if ($alternativeImagePath) {
  166.                         $this->applyTransformation($sourceFile, $event, $dispatcher, $alternativeImagePath);
  167.                     }
  168.                 }
  169.             }
  170.         }
  172.         // Compute the image URL
  173.         $processedImageUrl = $this->getCacheFileURL($subdir, basename($cacheFilePath));
  175.         // compute the full resolution image path in cache
  176.         $originalImageUrl = $this->getCacheFileURL($subdir, basename($originalImagePathInCache));
  178.         // Update the event with file path and file URL
  179.         $event->setCacheFilepath($cacheFilePath);
  180.         $event->setCacheOriginalFilepath($originalImagePathInCache);
  182.         $event->setFileUrl(URL::getInstance()->absoluteUrl($processedImageUrl, null, URL::PATH_TO_FILE, $this->cdnBaseUrl));
  183.         $event->setOriginalFileUrl(URL::getInstance()->absoluteUrl($originalImageUrl, null, URL::PATH_TO_FILE, $this->cdnBaseUrl));
  185.         $imagine = $this->createImagineInstance();
  186.         $image = $imagine->open($cacheFilePath);
  187.         $event->setImageObject($image);
  188.     }
  190.     private function applyTransformation(
  191.         $sourceFile,
  192.         $event,
  193.         $dispatcher,
  194.         $cacheFilePath
  195.     ): void {
  196.         $imagine = $this->createImagineInstance();
  197.         $image = $imagine->open($sourceFile);
  199.         if (!$image) {
  200.             throw new ImageException(sprintf('Source file %s cannot be opened.', basename($sourceFile)));
  201.         }
  203.         if (\function_exists('exif_read_data')) {
  204.             $exifdata = @exif_read_data($sourceFile);
  205.             if (isset($exifdata['Orientation'])) {
  206.                 $orientation = $exifdata['Orientation'];
  207.                 $color = new RGB();
  208.                 switch ($orientation) {
  209.                     case 3:
  210.                         $image->rotate(180, $color->color('#F00'));
  211.                         break;
  213.                     case 6:
  214.                         $image->rotate(90, $color->color('#F00'));
  215.                         break;
  217.                     case 8:
  218.                         $image->rotate(-90, $color->color('#F00'));
  219.                         break;
  220.                 }
  221.             }
  222.         }
  224.         // Allow image pre-processing (watermarging, or other stuff...)
  225.         $event->setImageObject($image);
  226.         $dispatcher->dispatch($event, TheliaEvents::IMAGE_PREPROCESSING);
  227.         $image = $event->getImageObject();
  229.         $background_color = $event->getBackgroundColor();
  231.         $palette = new RGB();
  233.         if ($background_color != null) {
  234.             $bg_color = $palette->color($background_color);
  235.         } else {
  236.             // Define a fully transparent white background color
  237.             $bg_color = $palette->color('fff', 0);
  238.         }
  240.         // Apply resize
  241.         $image = $this->applyResize(
  242.             $imagine,
  243.             $image,
  244.             $event->getWidth(),
  245.             $event->getHeight(),
  246.             $event->getResizeMode(),
  247.             $bg_color,
  248.             $event->getAllowZoom()
  249.         );
  251.         // Rotate if required
  252.         $rotation = (int) $event->getRotation();
  254.         if ($rotation != 0) {
  255.             $image->rotate($rotation, $bg_color);
  256.         }
  258.         // Flip
  259.         // Process each effects
  260.         foreach ($event->getEffects() as $effect) {
  261.             $effect = trim(strtolower($effect));
  263.             $params = explode(':', $effect);
  265.             switch ($params[0]) {
  266.                 case 'greyscale':
  267.                 case 'grayscale':
  268.                     $image->effects()->grayscale();
  269.                     break;
  270.                 case 'negative':
  271.                     $image->effects()->negative();
  272.                     break;
  273.                 case 'horizontal_flip':
  274.                 case 'hflip':
  275.                     $image->flipHorizontally();
  276.                     break;
  277.                 case 'vertical_flip':
  278.                 case 'vflip':
  279.                     $image->flipVertically();
  280.                     break;
  281.                 case 'gamma':
  282.                     // Syntax: gamma:value. Exemple: gamma:0.7
  283.                     if (isset($params[1])) {
  284.                         $gamma = (float) $params[1];
  286.                         $image->effects()->gamma($gamma);
  287.                     }
  288.                     break;
  289.                 case 'colorize':
  290.                     // Syntax: colorize:couleur. Exemple: colorize:#ff00cc
  291.                     if (isset($params[1])) {
  292.                         $the_color = $palette->color($params[1]);
  294.                         $image->effects()->colorize($the_color);
  295.                     }
  296.                     break;
  297.                 case 'blur':
  298.                     if (isset($params[1])) {
  299.                         $blur_level = (int) $params[1];
  301.                         $image->effects()->blur($blur_level);
  302.                     }
  303.                     break;
  304.             }
  305.         }
  307.         $quality = $event->getQuality();
  309.         if (null === $quality) {
  310.             $quality = ConfigQuery::read('default_images_quality_percent', 75);
  311.         }
  313.         // Allow image post-processing (watermarging, or other stuff...)
  314.         $event->setImageObject($image);
  315.         $dispatcher->dispatch($event, TheliaEvents::IMAGE_POSTPROCESSING);
  316.         $image = $event->getImageObject();
  318.         $image->save(
  319.             $cacheFilePath,
  320.             ['quality' => $quality, 'animated' => true]
  321.         );
  322.     }
  324.     /**
  325.      * Process image resizing, with borders or cropping. If $dest_width and $dest_height
  326.      * are both null, no resize is performed.
  327.      *
  328.      * @param ImagineInterface $imagine     the Imagine instance
  329.      * @param ImageInterface   $image       the image to process
  330.      * @param int              $dest_width  the required width
  331.      * @param int              $dest_height the required height
  332.      * @param int              $resize_mode the resize mode (crop / bands / keep image ratio)p
  333.      * @param string           $bg_color    the bg_color used for bands
  334.      * @param bool             $allow_zoom  if true, image may be zoomed to matchrequired size. If false, image is not zoomed.
  335.      *
  336.      * @return ImageInterface the resized image
  337.      */
  338.     protected function applyResize(
  339.         ImagineInterface $imagine,
  340.         ImageInterface $image,
  341.         $dest_width,
  342.         $dest_height,
  343.         $resize_mode,
  344.         $bg_color,
  345.         $allow_zoom = false
  346.     ) {
  347.         if (!(null === $dest_width && null === $dest_height)) {
  348.             $width_orig = $image->getSize()->getWidth();
  349.             $height_orig = $image->getSize()->getHeight();
  351.             $ratio = $width_orig / $height_orig;
  353.             if (null === $dest_width) {
  354.                 $dest_width = $dest_height * $ratio;
  355.             }
  357.             if (null === $dest_height) {
  358.                 $dest_height = $dest_width / $ratio;
  359.             }
  361.             if (null === $resize_mode) {
  362.                 $resize_mode = self::KEEP_IMAGE_RATIO;
  363.             }
  365.             $width_diff = $dest_width / $width_orig;
  366.             $height_diff = $dest_height / $height_orig;
  368.             $delta_x = $delta_y = $border_width = $border_height = 0;
  370.             if ($width_diff > 1 && $height_diff > 1) {
  371.                 // Set the default final size. If zoom is allowed, we will get the required
  372.                 // image dimension. Otherwise, the final image may be smaller than required.
  373.                 if ($allow_zoom) {
  374.                     $resize_width = $dest_width;
  375.                     $resize_height = $dest_height;
  376.                 } else {
  377.                     $resize_width = $width_orig;
  378.                     $resize_height = $height_orig;
  379.                 }
  381.                 // When cropping, be sure to always generate an image which is
  382.                 // not smaller than the required size, zooming it if required.
  383.                 if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
  384.                     if ($allow_zoom) {
  385.                         if ($width_diff > $height_diff) {
  386.                             $resize_width = $dest_width;
  387.                             $resize_height = (int) ($height_orig * $dest_width / $width_orig);
  388.                             $delta_y = ($resize_height - $dest_height) / 2;
  389.                         } else {
  390.                             $resize_height = $dest_height;
  391.                             $resize_width = (int) (($width_orig * $resize_height) / $height_orig);
  392.                             $delta_x = ($resize_width - $dest_width) / 2;
  393.                         }
  394.                     } else {
  395.                         // No zoom : final image may be smaller than the required size.
  396.                         $dest_width = $resize_width;
  397.                         $dest_height = $resize_height;
  398.                     }
  399.                 }
  400.             } elseif ($width_diff > $height_diff) {
  401.                 // Image height > image width
  402.                 $resize_height = $dest_height;
  403.                 $resize_width = (int) (($width_orig * $resize_height) / $height_orig);
  405.                 if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
  406.                     $resize_width = $dest_width;
  407.                     $resize_height = (int) ($height_orig * $dest_width / $width_orig);
  408.                     $delta_y = ($resize_height - $dest_height) / 2;
  409.                 } elseif ($resize_mode != self::EXACT_RATIO_WITH_BORDERS) {
  410.                     $dest_width = $resize_width;
  411.                 }
  412.             } else {
  413.                 // Image width > image height
  414.                 $resize_width = $dest_width;
  415.                 $resize_height = (int) ($height_orig * $dest_width / $width_orig);
  417.                 if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
  418.                     $resize_height = $dest_height;
  419.                     $resize_width = (int) (($width_orig * $resize_height) / $height_orig);
  420.                     $delta_x = ($resize_width - $dest_width) / 2;
  421.                 } elseif ($resize_mode != self::EXACT_RATIO_WITH_BORDERS) {
  422.                     $dest_height = $resize_height;
  423.                 }
  424.             }
  426.             $image->resize(new Box($resize_width, $resize_height));
  428.             $resizeFilter = 'imagick' === ConfigQuery::read('imagine_graphic_driver', 'gd')
  429.                 ? ImageInterface::FILTER_LANCZOS
  430.                 : ImageInterface::FILTER_UNDEFINED;
  432.             $image->resize(new Box($resize_width, $resize_height), $resizeFilter);
  434.             if ($resize_mode == self::EXACT_RATIO_WITH_BORDERS) {
  435.                 $border_width = (int) (($dest_width - $resize_width) / 2);
  436.                 $border_height = (int) (($dest_height - $resize_height) / 2);
  438.                 $canvas = new Box($dest_width, $dest_height);
  439.                 $layersCount = \count($image->layers());
  441.                 if ('imagick' === ConfigQuery::read('imagine_graphic_driver', 'gd') && $layersCount > 1) {
  442.                     // If image has layers we apply transformation to all layers since paste method would flatten the image
  443.                     $newImage = $imagine->create($canvas, $bg_color);
  444.                     $resizedLayers = $newImage->layers();
  445.                     $resizedLayers->remove(0);
  446.                     for ($i = 0; $i < $layersCount; ++$i) {
  447.                         $newImage2 = $imagine->create($canvas, $bg_color);
  448.                         $resizedLayers[] = $newImage2->paste($image->layers()->get($i)->resize(new Box($resize_width, $resize_height), $resizeFilter), new Point($border_width, $border_height));
  449.                     }
  451.                     return $newImage;
  452.                 }
  454.                 return $imagine->create($canvas, $bg_color)
  455.                         ->paste($image, new Point($border_width, $border_height));
  456.             }
  457.             if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
  458.                 $image->crop(
  459.                     new Point($delta_x, $delta_y),
  460.                     new Box($dest_width, $dest_height)
  461.                 );
  462.             }
  463.         }
  465.         return $image;
  466.     }
  468.     /**
  469.      * Create a new Imagine object using current driver configuration.
  470.      *
  471.      * @return ImagineInterface
  472.      */
  473.     protected function createImagineInstance()
  474.     {
  475.         $driver = ConfigQuery::read('imagine_graphic_driver', 'gd');
  477.         switch ($driver) {
  478.             case 'imagick':
  479.                 $image = new ImagickImagine();
  480.                 break;
  481.             case 'gmagick':
  482.                 $image = new GmagickImagine();
  483.                 break;
  484.             case 'gd':
  485.             default:
  486.                 $image = new Imagine();
  487.         }
  489.         return $image;
  490.     }
  492.     /**
  493.      * {@inheritdoc}
  494.      */
  495.     public static function getSubscribedEvents()
  496.     {
  497.         return [
  498.             TheliaEvents::IMAGE_PROCESS => ['processImage', 128],
  500.             // Implemented in parent class BaseCachedFile
  501.             TheliaEvents::IMAGE_CLEAR_CACHE => ['clearCache', 128],
  502.             TheliaEvents::IMAGE_DELETE => ['deleteFile', 128],
  503.             TheliaEvents::IMAGE_SAVE => ['saveFile', 128],
  504.             TheliaEvents::IMAGE_UPDATE => ['updateFile', 128],
  505.             TheliaEvents::IMAGE_UPDATE_POSITION => ['updatePosition', 128],
  506.             TheliaEvents::IMAGE_TOGGLE_VISIBILITY => ['toggleVisibility', 128],
  507.         ];
  508.     }
  509. }