vendor/contao/core-bundle/src/Resources/contao/library/Contao/Image.php line 754

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Contao\Image\DeferredImageInterface;
  14. use Contao\Image\Image as NewImage;
  15. use Contao\Image\ImageDimensions;
  16. use Contao\Image\ImportantPart;
  17. use Contao\Image\ResizeConfiguration;
  18. use Contao\Image\ResizeOptions;
  19. use Imagine\Image\Box;
  21. /**
  22.  * Resizes images
  23.  *
  24.  * The class resizes images and stores them in the image target folder.
  25.  *
  26.  * Usage:
  27.  *
  28.  *     $imageObj = new Image(new File('example.jpg'));
  29.  *
  30.  *     $src = $imageObj->setTargetWidth(640)
  31.  *                     ->setTargetHeight(480)
  32.  *                     ->setResizeMode('center_center')
  33.  *                     ->executeResize()
  34.  *                     ->getResizedPath();
  35.  */
  36. class Image
  37. {
  38.     /**
  39.      * The File instance of the original image
  40.      *
  41.      * @var File
  42.      */
  43.     protected $fileObj;
  45.     /**
  46.      * The resized image path
  47.      *
  48.      * @var string
  49.      */
  50.     protected $resizedPath = '';
  52.     /**
  53.      * The target width
  54.      *
  55.      * @var integer
  56.      */
  57.     protected $targetWidth = 0;
  59.     /**
  60.      * The target height
  61.      *
  62.      * @var integer
  63.      */
  64.     protected $targetHeight = 0;
  66.     /**
  67.      * The resize mode (defaults to crop for backwards compatibility)
  68.      *
  69.      * @var string
  70.      */
  71.     protected $resizeMode = 'crop';
  73.     /**
  74.      * The target path
  75.      *
  76.      * @var string
  77.      */
  78.     protected $targetPath = '';
  80.     /**
  81.      * Override an existing target
  82.      *
  83.      * @var boolean
  84.      */
  85.     protected $forceOverride = false;
  87.     /**
  88.      * Zoom level (between 0 and 100)
  89.      *
  90.      * @var integer
  91.      */
  92.     protected $zoomLevel = 0;
  94.     /**
  95.      * Root dir
  96.      * @var string
  97.      */
  98.     protected $strRootDir;
  100.     /**
  101.      * Important part settings
  102.      *
  103.      * @var array
  104.      */
  105.     protected $importantPart = array();
  107.     /**
  108.      * Create a new object to handle an image
  109.      *
  110.      * @param File $file A file instance of the original image
  111.      *
  112.      * @throws \InvalidArgumentException If the file does not exist or cannot be processed
  113.      *
  114.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  115.      *             Use the contao.image.factory service instead.
  116.      */
  117.     public function __construct(File $file)
  118.     {
  119.         trigger_deprecation('contao/core-bundle', '4.3', 'Using the "Contao\Image" class has been deprecated and will no longer work in Contao 5.0. Use the "contao.image.factory" service instead.');
  121.         // Create deferred images (see #5873)
  122.         $file->createIfDeferred();
  124.         // Check whether the file exists
  125.         if (!$file->exists())
  126.         {
  127.             $webDir = System::getContainer()->getParameter('contao.web_dir');
  129.             // Handle public bundle resources
  130.             if (file_exists($webDir . '/' . $file->path))
  131.             {
  132.                 $file = new File(StringUtil::stripRootDir($webDir) . '/' . $file->path);
  133.             }
  134.             else
  135.             {
  136.                 throw new \InvalidArgumentException('Image "' . $file->path . '" could not be found');
  137.             }
  138.         }
  140.         $this->fileObj = $file;
  141.         $arrAllowedTypes = System::getContainer()->getParameter('contao.image.valid_extensions');
  143.         // Check the file type
  144.         if (!\in_array($this->fileObj->extension, $arrAllowedTypes))
  145.         {
  146.             throw new \InvalidArgumentException('Image type "' . $this->fileObj->extension . '" was not allowed to be processed');
  147.         }
  149.         $this->strRootDir = System::getContainer()->getParameter('kernel.project_dir');
  150.     }
  152.     /**
  153.      * Override the target image
  154.      *
  155.      * @param boolean $forceOverride True to override the target image
  156.      *
  157.      * @return $this The image object
  158.      */
  159.     public function setForceOverride($forceOverride)
  160.     {
  161.         $this->forceOverride = (bool) $forceOverride;
  163.         return $this;
  164.     }
  166.     /**
  167.      * Get force override setting
  168.      *
  169.      * @return boolean True if the target image will be overridden
  170.      */
  171.     public function getForceOverride()
  172.     {
  173.         return $this->forceOverride;
  174.     }
  176.     /**
  177.      * Set the important part settings
  178.      *
  179.      * @param array $importantPart The settings array
  180.      *
  181.      * @return $this The image object
  182.      *
  183.      * @throws \InvalidArgumentException If the settings array is malformed
  184.      */
  185.     public function setImportantPart(array $importantPart = null)
  186.     {
  187.         if ($importantPart !== null)
  188.         {
  189.             if (!isset($importantPart['x'], $importantPart['y'], $importantPart['width'], $importantPart['height']))
  190.             {
  191.                 throw new \InvalidArgumentException('Malformed array for setting the important part!');
  192.             }
  194.             $this->importantPart = array
  195.             (
  196.                 'x' => max(0, min($this->fileObj->viewWidth - 1, (int) $importantPart['x'])),
  197.                 'y' => max(0, min($this->fileObj->viewHeight - 1, (int) $importantPart['y'])),
  198.             );
  200.             $this->importantPart['width'] = max(1, min($this->fileObj->viewWidth - $this->importantPart['x'], (int) $importantPart['width']));
  201.             $this->importantPart['height'] = max(1, min($this->fileObj->viewHeight - $this->importantPart['y'], (int) $importantPart['height']));
  202.         }
  203.         else
  204.         {
  205.             $this->importantPart = null;
  206.         }
  208.         return $this;
  209.     }
  211.     /**
  212.      * Get the important part settings
  213.      *
  214.      * @return array The settings array
  215.      */
  216.     public function getImportantPart()
  217.     {
  218.         if ($this->importantPart)
  219.         {
  220.             return $this->importantPart;
  221.         }
  223.         return array('x'=>0, 'y'=>0, 'width'=>$this->fileObj->viewWidth, 'height'=>$this->fileObj->viewHeight);
  224.     }
  226.     /**
  227.      * Set the target height
  228.      *
  229.      * @param integer $targetHeight The target height
  230.      *
  231.      * @return $this The image object
  232.      */
  233.     public function setTargetHeight($targetHeight)
  234.     {
  235.         $this->targetHeight = (int) $targetHeight;
  237.         return $this;
  238.     }
  240.     /**
  241.      * Get the target height
  242.      *
  243.      * @return integer The target height
  244.      */
  245.     public function getTargetHeight()
  246.     {
  247.         return $this->targetHeight;
  248.     }
  250.     /**
  251.      * Set the target width
  252.      *
  253.      * @param integer $targetWidth The target width
  254.      *
  255.      * @return $this The image object
  256.      */
  257.     public function setTargetWidth($targetWidth)
  258.     {
  259.         $this->targetWidth = (int) $targetWidth;
  261.         return $this;
  262.     }
  264.     /**
  265.      * Get the target width
  266.      *
  267.      * @return integer The target width
  268.      */
  269.     public function getTargetWidth()
  270.     {
  271.         return $this->targetWidth;
  272.     }
  274.     /**
  275.      * Set the target path
  276.      *
  277.      * @param string $targetPath The target path
  278.      *
  279.      * @return $this The image object
  280.      */
  281.     public function setTargetPath($targetPath)
  282.     {
  283.         $this->targetPath = (string) $targetPath;
  285.         return $this;
  286.     }
  288.     /**
  289.      * Get the target path
  290.      *
  291.      * @return string The target path
  292.      */
  293.     public function getTargetPath()
  294.     {
  295.         return $this->targetPath;
  296.     }
  298.     /**
  299.      * Set the zoom level
  300.      *
  301.      * @param integer $zoomLevel The zoom level
  302.      *
  303.      * @return $this The object instance
  304.      *
  305.      * @throws \InvalidArgumentException If the zoom level is out of bounds
  306.      */
  307.     public function setZoomLevel($zoomLevel)
  308.     {
  309.         $zoomLevel = (int) $zoomLevel;
  311.         if ($zoomLevel < 0 || $zoomLevel > 100)
  312.         {
  313.             throw new \InvalidArgumentException('Zoom level must be between 0 and 100!');
  314.         }
  316.         $this->zoomLevel = $zoomLevel;
  318.         return $this;
  319.     }
  321.     /**
  322.      * Get the zoom level
  323.      *
  324.      * @return integer The zoom level
  325.      */
  326.     public function getZoomLevel()
  327.     {
  328.         return $this->zoomLevel;
  329.     }
  331.     /**
  332.      * Set the resize mode
  333.      *
  334.      * @param string $resizeMode The resize mode
  335.      *
  336.      * @return $this The image object
  337.      */
  338.     public function setResizeMode($resizeMode)
  339.     {
  340.         $this->resizeMode = $resizeMode;
  342.         return $this;
  343.     }
  345.     /**
  346.      * Get the resize mode
  347.      *
  348.      * @return string The resize mode
  349.      */
  350.     public function getResizeMode()
  351.     {
  352.         return $this->resizeMode;
  353.     }
  355.     /**
  356.      * Get the path of the original image
  357.      *
  358.      * @return string The path of the original image
  359.      */
  360.     public function getOriginalPath()
  361.     {
  362.         return $this->fileObj->path;
  363.     }
  365.     /**
  366.      * Get the path of the resized image
  367.      *
  368.      * @return string The path of the resized image
  369.      */
  370.     public function getResizedPath()
  371.     {
  372.         $path = $this->resizedPath;
  373.         $webDir = StringUtil::stripRootDir(System::getContainer()->getParameter('contao.web_dir'));
  375.         // Strip the contao.web_dir directory prefix (see #337)
  376.         if (strncmp($path, $webDir . '/', \strlen($webDir) + 1) === 0)
  377.         {
  378.             $path = substr($path, \strlen($webDir) + 1);
  379.         }
  381.         return $path;
  382.     }
  384.     /**
  385.      * Get the cache name
  386.      *
  387.      * @return string The cache name
  388.      */
  389.     public function getCacheName()
  390.     {
  391.         $importantPart = $this->getImportantPart();
  393.         $strCacheKey = substr(md5
  394.         (
  395.             '-w' . $this->getTargetWidth()
  396.             . '-h' . $this->getTargetHeight()
  397.             . '-o' . $this->getOriginalPath()
  398.             . '-m' . $this->getResizeMode()
  399.             . '-z' . $this->getZoomLevel()
  400.             . '-x' . $importantPart['x']
  401.             . '-y' . $importantPart['y']
  402.             . '-i' . $importantPart['width']
  403.             . '-e' . $importantPart['height']
  404.             . '-t' . $this->fileObj->mtime
  405.         ), 0, 8);
  407.         return StringUtil::stripRootDir(System::getContainer()->getParameter('contao.image.target_dir')) . '/' . substr($strCacheKey, -1) . '/' . $this->fileObj->filename . '-' . $strCacheKey . '.' . $this->fileObj->extension;
  408.     }
  410.     /**
  411.      * Resize the image
  412.      *
  413.      * @return $this The image object
  414.      */
  415.     public function executeResize()
  416.     {
  417.         $image = $this->prepareImage();
  418.         $resizeConfig = $this->prepareResizeConfig();
  420.         if (
  421.             $this->getTargetPath()
  422.             && !$this->getForceOverride()
  423.             && !System::getContainer()->getParameter('contao.image.bypass_cache')
  424.             && file_exists($this->strRootDir . '/' . $this->getTargetPath())
  425.             && $this->fileObj->mtime <= filemtime($this->strRootDir . '/' . $this->getTargetPath())
  426.         ) {
  427.             // HOOK: add custom logic
  428.             if (isset($GLOBALS['TL_HOOKS']['executeResize']) && \is_array($GLOBALS['TL_HOOKS']['executeResize']))
  429.             {
  430.                 foreach ($GLOBALS['TL_HOOKS']['executeResize'] as $callback)
  431.                 {
  432.                     $return = System::importStatic($callback[0])->{$callback[1]}($this);
  434.                     if (\is_string($return))
  435.                     {
  436.                         $this->resizedPath = System::urlEncode($return);
  438.                         return $this;
  439.                     }
  440.                 }
  441.             }
  443.             $this->resizedPath = System::urlEncode($this->getTargetPath());
  445.             return $this;
  446.         }
  448.         $image = System::getContainer()
  449.             ->get('contao.image.legacy_resizer')
  450.             ->resize(
  451.                 $image,
  452.                 $resizeConfig,
  453.                 (new ResizeOptions())
  454.                     ->setImagineOptions(System::getContainer()->getParameter('contao.image.imagine_options'))
  455.                     ->setTargetPath($this->targetPath ? $this->strRootDir . '/' . $this->targetPath : null)
  456.                     ->setBypassCache(System::getContainer()->getParameter('contao.image.bypass_cache'))
  457.                     ->setSkipIfDimensionsMatch(true)
  458.             )
  459.         ;
  461.         $this->resizedPath = $image->getUrl($this->strRootDir);
  463.         return $this;
  464.     }
  466.     /**
  467.      * Prepare image object.
  468.      *
  469.      * @return NewImage
  470.      */
  471.     protected function prepareImage()
  472.     {
  473.         if ($this->fileObj->isSvgImage)
  474.         {
  475.             $imagine = System::getContainer()->get('contao.image.imagine_svg');
  476.         }
  477.         else
  478.         {
  479.             $imagine = System::getContainer()->get('contao.image.imagine');
  480.         }
  482.         $image = new NewImage($this->strRootDir . '/' . $this->fileObj->path, $imagine, System::getContainer()->get('filesystem'));
  483.         $image->setImportantPart($this->prepareImportantPart());
  485.         return $image;
  486.     }
  488.     /**
  489.      * Prepare important part object.
  490.      *
  491.      * @return ImportantPart
  492.      */
  493.     protected function prepareImportantPart()
  494.     {
  495.         $importantPart = $this->getImportantPart();
  497.         if (substr_count($this->resizeMode, '_') === 1)
  498.         {
  499.             $importantPart = array
  500.             (
  501.                 'x' => 0,
  502.                 'y' => 0,
  503.                 'width' => $this->fileObj->viewWidth,
  504.                 'height' => $this->fileObj->viewHeight,
  505.             );
  507.             $mode = explode('_', $this->resizeMode);
  509.             if ($mode[0] === 'left')
  510.             {
  511.                 $importantPart['width'] = 1;
  512.             }
  513.             elseif ($mode[0] === 'right')
  514.             {
  515.                 $importantPart['x'] = $importantPart['width'] - 1;
  516.                 $importantPart['width'] = 1;
  517.             }
  519.             if ($mode[1] === 'top')
  520.             {
  521.                 $importantPart['height'] = 1;
  522.             }
  523.             elseif ($mode[1] === 'bottom')
  524.             {
  525.                 $importantPart['y'] = $importantPart['height'] - 1;
  526.                 $importantPart['height'] = 1;
  527.             }
  528.         }
  530.         if (!$importantPart['width'] || !$importantPart['height'])
  531.         {
  532.             return null;
  533.         }
  535.         return new ImportantPart(
  536.             $importantPart['x'] / $this->fileObj->viewWidth,
  537.             $importantPart['y'] / $this->fileObj->viewHeight,
  538.             $importantPart['width'] / $this->fileObj->viewWidth,
  539.             $importantPart['height'] / $this->fileObj->viewHeight
  540.         );
  541.     }
  543.     /**
  544.      * Prepare resize configuration object.
  545.      *
  546.      * @return ResizeConfiguration
  547.      */
  548.     protected function prepareResizeConfig()
  549.     {
  550.         $resizeConfig = new ResizeConfiguration();
  551.         $resizeConfig->setWidth($this->targetWidth);
  552.         $resizeConfig->setHeight($this->targetHeight);
  553.         $resizeConfig->setZoomLevel($this->zoomLevel);
  555.         if (substr_count($this->resizeMode, '_') === 1)
  556.         {
  557.             $resizeConfig->setMode(ResizeConfiguration::MODE_CROP);
  558.             $resizeConfig->setZoomLevel(0);
  559.         }
  560.         else
  561.         {
  562.             try
  563.             {
  564.                 $resizeConfig->setMode($this->resizeMode);
  565.             }
  566.             catch (\Throwable $exception)
  567.             {
  568.                 $resizeConfig->setMode(ResizeConfiguration::MODE_CROP);
  569.             }
  570.         }
  572.         return $resizeConfig;
  573.     }
  575.     /**
  576.      * Calculate the resize coordinates
  577.      *
  578.      * @return array The resize coordinates (width, height, target_x, target_y, target_width, target_height)
  579.      */
  580.     public function computeResize()
  581.     {
  582.         $resizeCoordinates = System::getContainer()
  583.             ->get('contao.image.resize_calculator')
  584.             ->calculate(
  585.                 $this->prepareResizeConfig(),
  586.                 new ImageDimensions(
  587.                     new Box($this->fileObj->viewWidth, $this->fileObj->viewHeight),
  588.                     $this->fileObj->viewWidth !== $this->fileObj->width
  589.                 ),
  590.                 $this->prepareImportantPart()
  591.             )
  592.         ;
  594.         return array
  595.         (
  596.             'width' => $resizeCoordinates->getCropSize()->getWidth(),
  597.             'height' => $resizeCoordinates->getCropSize()->getHeight(),
  598.             'target_x' => -$resizeCoordinates->getCropStart()->getX(),
  599.             'target_y' => -$resizeCoordinates->getCropStart()->getY(),
  600.             'target_width' => $resizeCoordinates->getSize()->getWidth(),
  601.             'target_height' => $resizeCoordinates->getSize()->getHeight(),
  602.         );
  603.     }
  605.     /**
  606.      * Get the relative path to an image
  607.      *
  608.      * @param string $src The image name or path
  609.      *
  610.      * @return string The relative path
  611.      */
  612.     public static function getPath($src)
  613.     {
  614.         if (!$src)
  615.         {
  616.             return '';
  617.         }
  619.         $src = rawurldecode($src);
  621.         if (strpos($src, '/') !== false)
  622.         {
  623.             return $src;
  624.         }
  626.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  628.         if (strncmp($src, 'icon', 4) === 0)
  629.         {
  630.             if (pathinfo($src, PATHINFO_EXTENSION) == 'svg')
  631.             {
  632.                 return 'assets/contao/images/' . $src;
  633.             }
  635.             $filename = pathinfo($src, PATHINFO_FILENAME);
  637.             // Prefer SVG icons
  638.             if (file_exists($projectDir . '/assets/contao/images/' . $filename . '.svg'))
  639.             {
  640.                 return 'assets/contao/images/' . $filename . '.svg';
  641.             }
  643.             return 'assets/contao/images/' . $src;
  644.         }
  646.         $theme = Backend::getTheme();
  648.         if (pathinfo($src, PATHINFO_EXTENSION) == 'svg')
  649.         {
  650.             return 'system/themes/' . $theme . '/icons/' . $src;
  651.         }
  653.         $filename = pathinfo($src, PATHINFO_FILENAME);
  655.         // Prefer SVG icons
  656.         if (file_exists($projectDir . '/system/themes/' . $theme . '/icons/' . $filename . '.svg'))
  657.         {
  658.             return 'system/themes/' . $theme . '/icons/' . $filename . '.svg';
  659.         }
  661.         return 'system/themes/' . $theme . '/images/' . $src;
  662.     }
  664.     /**
  665.      * Generate an image tag and return it as string
  666.      *
  667.      * @param string $src        The image path
  668.      * @param string $alt        An optional alt attribute
  669.      * @param string $attributes A string of other attributes
  670.      *
  671.      * @return string The image HTML tag
  672.      */
  673.     public static function getHtml($src, $alt='', $attributes='')
  674.     {
  675.         $src = static::getPath($src);
  677.         if (!$src)
  678.         {
  679.             return '';
  680.         }
  682.         $container = System::getContainer();
  683.         $projectDir = $container->getParameter('kernel.project_dir');
  684.         $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  686.         if (!is_file($projectDir . '/' . $src))
  687.         {
  688.             try
  689.             {
  690.                 $deferredImage = $container->get('contao.image.factory')->create($projectDir . '/' . $src);
  691.             }
  692.             catch (\Exception $e)
  693.             {
  694.                 $deferredImage = null;
  695.             }
  697.             // Handle public bundle resources
  698.             if (file_exists($projectDir . '/' . $webDir . '/' . $src))
  699.             {
  700.                 $src = $webDir . '/' . $src;
  701.             }
  702.             elseif (!$deferredImage instanceof DeferredImageInterface)
  703.             {
  704.                 return '';
  705.             }
  706.         }
  708.         $objFile = new File($src);
  710.         // Strip the contao.web_dir directory prefix (see #337)
  711.         if (strncmp($src, $webDir . '/', \strlen($webDir) + 1) === 0)
  712.         {
  713.             $src = substr($src, \strlen($webDir) + 1);
  714.         }
  716.         $context = (strncmp($src, 'assets/', 7) === 0) ? 'assets_context' : 'files_context';
  718.         return '<img src="' . Controller::addStaticUrlTo(System::urlEncode($src), $container->get('contao.assets.' . $context)) . '" width="' . $objFile->width . '" height="' . $objFile->height . '" alt="' . StringUtil::specialchars($alt) . '"' . ($attributes ? ' ' . $attributes : '') . '>';
  719.     }
  721.     /**
  722.      * Resize or crop an image and replace the original with the resized version
  723.      *
  724.      * @param string  $image  The image path
  725.      * @param integer $width  The target width
  726.      * @param integer $height The target height
  727.      * @param string  $mode   The resize mode
  728.      *
  729.      * @return boolean True if the image could be resized successfully
  730.      *
  731.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  732.      *             Use the contao.image.factory service instead.
  733.      */
  734.     public static function resize($image, $width, $height, $mode='')
  735.     {
  736.         trigger_deprecation('contao/core-bundle', '4.3', 'Using "Contao\Image::resize()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.image.factory" service instead.');
  738.         return static::get($image, $width, $height, $mode, $image, true) ? true : false;
  739.     }
  741.     /**
  742.      * Create an image instance from the given image path and size
  743.      *
  744.      * @param string|File          $image The image path or File instance
  745.      * @param array|integer|string $size  The image size as array (width, height, resize mode) or a tl_image_size ID or a predefined image size key
  746.      *
  747.      * @return static The created image instance
  748.      *
  749.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  750.      *             Use the contao.image.factory service instead.
  751.      */
  752.     public static function create($image, $size=null)
  753.     {
  754.         trigger_deprecation('contao/core-bundle', '4.3', 'Using "Contao\Image::create()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.image.factory" service instead.');
  756.         if (\is_string($image))
  757.         {
  758.             $image = new File(rawurldecode($image));
  759.         }
  761.         $imageObj = new static($image);
  763.         if (\is_array($size) && !empty($size[2]))
  764.         {
  765.             // tl_image_size ID as resize mode
  766.             if (is_numeric($size[2]))
  767.             {
  768.                 $size = (int) $size[2];
  769.             }
  771.             // Predefined image size as resize mode
  772.             elseif (\is_string($size[2]) && $size[2][0] === '_')
  773.             {
  774.                 $size = $size[2];
  775.             }
  776.         }
  778.         if (\is_array($size))
  779.         {
  780.             $size += array(0, 0, 'crop');
  782.             $imageObj
  783.                 ->setTargetWidth($size[0])
  784.                 ->setTargetHeight($size[1])
  785.                 ->setResizeMode($size[2])
  786.             ;
  787.         }
  789.         // Load the image size from the database if $size is an ID or a predefined size
  790.         elseif (($imageSize = self::getImageSizeConfig($size)) !== null)
  791.         {
  792.             $imageObj
  793.                 ->setTargetWidth($imageSize->width)
  794.                 ->setTargetHeight($imageSize->height)
  795.                 ->setResizeMode($imageSize->resizeMode)
  796.                 ->setZoomLevel($imageSize->zoom)
  797.             ;
  798.         }
  800.         $fileRecord = FilesModel::findByPath($image->path);
  801.         $currentSize = $image->imageViewSize;
  803.         // Set the important part
  804.         if ($fileRecord !== null && $fileRecord->importantPartWidth && $fileRecord->importantPartHeight)
  805.         {
  806.             $imageObj->setImportantPart(array
  807.             (
  808.                 'x' => (int) ($fileRecord->importantPartX * $currentSize[0]),
  809.                 'y' => (int) ($fileRecord->importantPartY * $currentSize[1]),
  810.                 'width' => (int) ($fileRecord->importantPartWidth * $currentSize[0]),
  811.                 'height' => (int) ($fileRecord->importantPartHeight * $currentSize[1]),
  812.             ));
  813.         }
  815.         return $imageObj;
  816.     }
  818.     private static function getImageSizeConfig($size)
  819.     {
  820.         if (is_numeric($size))
  821.         {
  822.             return ImageSizeModel::findByPk($size);
  823.         }
  825.         if (!\is_string($size) || $size[0] !== '_')
  826.         {
  827.             return null;
  828.         }
  830.         static $predefinedSizes = null;
  832.         if ($predefinedSizes === null)
  833.         {
  834.             $factory = System::getContainer()->get('contao.image.factory');
  835.             $predefinedSizes = (new \ReflectionObject($factory))->getProperty('predefinedSizes');
  836.             $predefinedSizes->setAccessible(true);
  837.             $predefinedSizes = $predefinedSizes->getValue($factory) ?? array();
  838.         }
  840.         if (!isset($predefinedSizes[$size]))
  841.         {
  842.             return null;
  843.         }
  845.         $imageSize = new \stdClass();
  846.         $imageSize->width = $predefinedSizes[$size]['width'];
  847.         $imageSize->height = $predefinedSizes[$size]['height'];
  848.         $imageSize->resizeMode = $predefinedSizes[$size]['resizeMode'];
  849.         $imageSize->zoom = $predefinedSizes[$size]['zoom'];
  851.         return $imageSize;
  852.     }
  854.     /**
  855.      * Resize an image and store the resized version in the image target folder
  856.      *
  857.      * @param string  $image  The image path
  858.      * @param integer $width  The target width
  859.      * @param integer $height The target height
  860.      * @param string  $mode   The resize mode
  861.      * @param string  $target An optional target path
  862.      * @param boolean $force  Override existing target images
  863.      *
  864.      * @return string|null The path of the resized image or null
  865.      *
  866.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  867.      *             Use the contao.image.factory service instead.
  868.      */
  869.     public static function get($image, $width, $height, $mode='', $target=null, $force=false)
  870.     {
  871.         trigger_deprecation('contao/core-bundle', '4.3', 'Using "Contao\Image::get()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.image.factory" service instead.');
  873.         if (!$image)
  874.         {
  875.             return null;
  876.         }
  878.         try
  879.         {
  880.             $imageObj = static::create($image, array($width, $height, $mode));
  881.             $imageObj->setTargetPath($target);
  882.             $imageObj->setForceOverride($force);
  884.             if ($path = $imageObj->executeResize()->getResizedPath())
  885.             {
  886.                 return $path;
  887.             }
  888.         }
  889.         catch (\Exception $e)
  890.         {
  891.             System::getContainer()->get('monolog.logger.contao.error')->error('Image "' . $image . '" could not be processed: ' . $e->getMessage());
  892.         }
  894.         return null;
  895.     }
  897.     /**
  898.      * Convert sizes like 2em, 10cm or 12pt to pixels
  899.      *
  900.      * @param string $size The size string
  901.      *
  902.      * @return integer The pixel value
  903.      *
  904.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  905.      *             Use the contao.image.factory service instead.
  906.      */
  907.     public static function getPixelValue($size)
  908.     {
  909.         trigger_deprecation('contao/core-bundle', '4.3', 'Using "Contao\Image::getPixelValue()" has been deprecated and will no longer work in Contao 5.0. Use the "contao.image.factory" service instead.');
  911.         $value = preg_replace('/[^0-9.-]+/', '', $size);
  912.         $unit = preg_replace('/[^acehimnprtvwx%]/', '', $size);
  914.         // Convert 16px = 1em = 2ex = 12pt = 1pc = 1/6in = 2.54/6cm = 25.4/6mm = 100%
  915.         switch ($unit)
  916.         {
  917.             case '':
  918.             case 'px':
  919.                 return (int) round($value);
  921.             case 'pc':
  922.             case 'em':
  923.                 return (int) round($value * 16);
  925.             case 'ex':
  926.                 return (int) round($value * 16 / 2);
  928.             case 'pt':
  929.                 return (int) round($value * 16 / 12);
  931.             case 'in':
  932.                 return (int) round($value * 16 * 6);
  934.             case 'cm':
  935.                 return (int) round($value * 16 / (2.54 / 6));
  937.             case 'mm':
  938.                 return (int) round($value * 16 / (25.4 / 6));
  940.             case '%':
  941.                 return (int) round($value * 16 / 100);
  942.         }
  944.         return 0;
  945.     }
  946. }
  948. class_alias(Image::class, 'Image');