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

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.         // Check whether the file exists
  122.         if (!$file->exists())
  123.         {
  124.             $webDir = System::getContainer()->getParameter('contao.web_dir');
  126.             // Handle public bundle resources
  127.             if (file_exists($webDir . '/' . $file->path))
  128.             {
  129.                 $file = new File(StringUtil::stripRootDir($webDir) . '/' . $file->path);
  130.             }
  131.             else
  132.             {
  133.                 throw new \InvalidArgumentException('Image "' . $file->path . '" could not be found');
  134.             }
  135.         }
  137.         $this->fileObj = $file;
  138.         $arrAllowedTypes = System::getContainer()->getParameter('contao.image.valid_extensions');
  140.         // Check the file type
  141.         if (!\in_array($this->fileObj->extension, $arrAllowedTypes))
  142.         {
  143.             throw new \InvalidArgumentException('Image type "' . $this->fileObj->extension . '" was not allowed to be processed');
  144.         }
  146.         $this->strRootDir = System::getContainer()->getParameter('kernel.project_dir');
  147.     }
  149.     /**
  150.      * Override the target image
  151.      *
  152.      * @param boolean $forceOverride True to override the target image
  153.      *
  154.      * @return $this The image object
  155.      */
  156.     public function setForceOverride($forceOverride)
  157.     {
  158.         $this->forceOverride = (bool) $forceOverride;
  160.         return $this;
  161.     }
  163.     /**
  164.      * Get force override setting
  165.      *
  166.      * @return boolean True if the target image will be overridden
  167.      */
  168.     public function getForceOverride()
  169.     {
  170.         return $this->forceOverride;
  171.     }
  173.     /**
  174.      * Set the important part settings
  175.      *
  176.      * @param array $importantPart The settings array
  177.      *
  178.      * @return $this The image object
  179.      *
  180.      * @throws \InvalidArgumentException If the settings array is malformed
  181.      */
  182.     public function setImportantPart(array $importantPart = null)
  183.     {
  184.         if ($importantPart !== null)
  185.         {
  186.             if (!isset($importantPart['x'], $importantPart['y'], $importantPart['width'], $importantPart['height']))
  187.             {
  188.                 throw new \InvalidArgumentException('Malformed array for setting the important part!');
  189.             }
  191.             $this->importantPart = array
  192.             (
  193.                 'x' => max(0, min($this->fileObj->viewWidth - 1, (int) $importantPart['x'])),
  194.                 'y' => max(0, min($this->fileObj->viewHeight - 1, (int) $importantPart['y'])),
  195.             );
  197.             $this->importantPart['width'] = max(1, min($this->fileObj->viewWidth - $this->importantPart['x'], (int) $importantPart['width']));
  198.             $this->importantPart['height'] = max(1, min($this->fileObj->viewHeight - $this->importantPart['y'], (int) $importantPart['height']));
  199.         }
  200.         else
  201.         {
  202.             $this->importantPart = null;
  203.         }
  205.         return $this;
  206.     }
  208.     /**
  209.      * Get the important part settings
  210.      *
  211.      * @return array The settings array
  212.      */
  213.     public function getImportantPart()
  214.     {
  215.         if ($this->importantPart)
  216.         {
  217.             return $this->importantPart;
  218.         }
  220.         return array('x'=>0, 'y'=>0, 'width'=>$this->fileObj->viewWidth, 'height'=>$this->fileObj->viewHeight);
  221.     }
  223.     /**
  224.      * Set the target height
  225.      *
  226.      * @param integer $targetHeight The target height
  227.      *
  228.      * @return $this The image object
  229.      */
  230.     public function setTargetHeight($targetHeight)
  231.     {
  232.         $this->targetHeight = (int) $targetHeight;
  234.         return $this;
  235.     }
  237.     /**
  238.      * Get the target height
  239.      *
  240.      * @return integer The target height
  241.      */
  242.     public function getTargetHeight()
  243.     {
  244.         return $this->targetHeight;
  245.     }
  247.     /**
  248.      * Set the target width
  249.      *
  250.      * @param integer $targetWidth The target width
  251.      *
  252.      * @return $this The image object
  253.      */
  254.     public function setTargetWidth($targetWidth)
  255.     {
  256.         $this->targetWidth = (int) $targetWidth;
  258.         return $this;
  259.     }
  261.     /**
  262.      * Get the target width
  263.      *
  264.      * @return integer The target width
  265.      */
  266.     public function getTargetWidth()
  267.     {
  268.         return $this->targetWidth;
  269.     }
  271.     /**
  272.      * Set the target path
  273.      *
  274.      * @param string $targetPath The target path
  275.      *
  276.      * @return $this The image object
  277.      */
  278.     public function setTargetPath($targetPath)
  279.     {
  280.         $this->targetPath = (string) $targetPath;
  282.         return $this;
  283.     }
  285.     /**
  286.      * Get the target path
  287.      *
  288.      * @return string The target path
  289.      */
  290.     public function getTargetPath()
  291.     {
  292.         return $this->targetPath;
  293.     }
  295.     /**
  296.      * Set the zoom level
  297.      *
  298.      * @param integer $zoomLevel The zoom level
  299.      *
  300.      * @return $this The object instance
  301.      *
  302.      * @throws \InvalidArgumentException If the zoom level is out of bounds
  303.      */
  304.     public function setZoomLevel($zoomLevel)
  305.     {
  306.         $zoomLevel = (int) $zoomLevel;
  308.         if ($zoomLevel < 0 || $zoomLevel > 100)
  309.         {
  310.             throw new \InvalidArgumentException('Zoom level must be between 0 and 100!');
  311.         }
  313.         $this->zoomLevel = $zoomLevel;
  315.         return $this;
  316.     }
  318.     /**
  319.      * Get the zoom level
  320.      *
  321.      * @return integer The zoom level
  322.      */
  323.     public function getZoomLevel()
  324.     {
  325.         return $this->zoomLevel;
  326.     }
  328.     /**
  329.      * Set the resize mode
  330.      *
  331.      * @param string $resizeMode The resize mode
  332.      *
  333.      * @return $this The image object
  334.      */
  335.     public function setResizeMode($resizeMode)
  336.     {
  337.         $this->resizeMode = $resizeMode;
  339.         return $this;
  340.     }
  342.     /**
  343.      * Get the resize mode
  344.      *
  345.      * @return string The resize mode
  346.      */
  347.     public function getResizeMode()
  348.     {
  349.         return $this->resizeMode;
  350.     }
  352.     /**
  353.      * Get the path of the original image
  354.      *
  355.      * @return string The path of the original image
  356.      */
  357.     public function getOriginalPath()
  358.     {
  359.         return $this->fileObj->path;
  360.     }
  362.     /**
  363.      * Get the path of the resized image
  364.      *
  365.      * @return string The path of the resized image
  366.      */
  367.     public function getResizedPath()
  368.     {
  369.         $path = $this->resizedPath;
  370.         $webDir = StringUtil::stripRootDir(System::getContainer()->getParameter('contao.web_dir'));
  372.         // Strip the contao.web_dir directory prefix (see #337)
  373.         if (strncmp($path, $webDir . '/', \strlen($webDir) + 1) === 0)
  374.         {
  375.             $path = substr($path, \strlen($webDir) + 1);
  376.         }
  378.         return $path;
  379.     }
  381.     /**
  382.      * Get the cache name
  383.      *
  384.      * @return string The cache name
  385.      */
  386.     public function getCacheName()
  387.     {
  388.         $importantPart = $this->getImportantPart();
  390.         $strCacheKey = substr(md5
  391.         (
  392.             '-w' . $this->getTargetWidth()
  393.             . '-h' . $this->getTargetHeight()
  394.             . '-o' . $this->getOriginalPath()
  395.             . '-m' . $this->getResizeMode()
  396.             . '-z' . $this->getZoomLevel()
  397.             . '-x' . $importantPart['x']
  398.             . '-y' . $importantPart['y']
  399.             . '-i' . $importantPart['width']
  400.             . '-e' . $importantPart['height']
  401.             . '-t' . $this->fileObj->mtime
  402.         ), 0, 8);
  404.         return StringUtil::stripRootDir(System::getContainer()->getParameter('contao.image.target_dir')) . '/' . substr($strCacheKey, -1) . '/' . $this->fileObj->filename . '-' . $strCacheKey . '.' . $this->fileObj->extension;
  405.     }
  407.     /**
  408.      * Resize the image
  409.      *
  410.      * @return $this The image object
  411.      */
  412.     public function executeResize()
  413.     {
  414.         $image = $this->prepareImage();
  415.         $resizeConfig = $this->prepareResizeConfig();
  417.         if (
  418.             $this->getTargetPath()
  419.             && !$this->getForceOverride()
  420.             && !System::getContainer()->getParameter('contao.image.bypass_cache')
  421.             && file_exists($this->strRootDir . '/' . $this->getTargetPath())
  422.             && $this->fileObj->mtime <= filemtime($this->strRootDir . '/' . $this->getTargetPath())
  423.         ) {
  424.             // HOOK: add custom logic
  425.             if (isset($GLOBALS['TL_HOOKS']['executeResize']) && \is_array($GLOBALS['TL_HOOKS']['executeResize']))
  426.             {
  427.                 foreach ($GLOBALS['TL_HOOKS']['executeResize'] as $callback)
  428.                 {
  429.                     $return = System::importStatic($callback[0])->{$callback[1]}($this);
  431.                     if (\is_string($return))
  432.                     {
  433.                         $this->resizedPath = System::urlEncode($return);
  435.                         return $this;
  436.                     }
  437.                 }
  438.             }
  440.             $this->resizedPath = System::urlEncode($this->getTargetPath());
  442.             return $this;
  443.         }
  445.         $image = System::getContainer()
  446.             ->get('contao.image.legacy_resizer')
  447.             ->resize(
  448.                 $image,
  449.                 $resizeConfig,
  450.                 (new ResizeOptions())
  451.                     ->setImagineOptions(System::getContainer()->getParameter('contao.image.imagine_options'))
  452.                     ->setTargetPath($this->targetPath ? $this->strRootDir . '/' . $this->targetPath : null)
  453.                     ->setBypassCache(System::getContainer()->getParameter('contao.image.bypass_cache'))
  454.                     ->setSkipIfDimensionsMatch(true)
  455.             )
  456.         ;
  458.         $this->resizedPath = $image->getUrl($this->strRootDir);
  460.         return $this;
  461.     }
  463.     /**
  464.      * Prepare image object.
  465.      *
  466.      * @return NewImage
  467.      */
  468.     protected function prepareImage()
  469.     {
  470.         if ($this->fileObj->isSvgImage)
  471.         {
  472.             $imagine = System::getContainer()->get('contao.image.imagine_svg');
  473.         }
  474.         else
  475.         {
  476.             $imagine = System::getContainer()->get('contao.image.imagine');
  477.         }
  479.         $image = new NewImage($this->strRootDir . '/' . $this->fileObj->path, $imagine, System::getContainer()->get('filesystem'));
  480.         $image->setImportantPart($this->prepareImportantPart());
  482.         return $image;
  483.     }
  485.     /**
  486.      * Prepare important part object.
  487.      *
  488.      * @return ImportantPart
  489.      */
  490.     protected function prepareImportantPart()
  491.     {
  492.         $importantPart = $this->getImportantPart();
  494.         if (substr_count($this->resizeMode, '_') === 1)
  495.         {
  496.             $importantPart = array
  497.             (
  498.                 'x' => 0,
  499.                 'y' => 0,
  500.                 'width' => $this->fileObj->viewWidth,
  501.                 'height' => $this->fileObj->viewHeight,
  502.             );
  504.             $mode = explode('_', $this->resizeMode);
  506.             if ($mode[0] === 'left')
  507.             {
  508.                 $importantPart['width'] = 1;
  509.             }
  510.             elseif ($mode[0] === 'right')
  511.             {
  512.                 $importantPart['x'] = $importantPart['width'] - 1;
  513.                 $importantPart['width'] = 1;
  514.             }
  516.             if ($mode[1] === 'top')
  517.             {
  518.                 $importantPart['height'] = 1;
  519.             }
  520.             elseif ($mode[1] === 'bottom')
  521.             {
  522.                 $importantPart['y'] = $importantPart['height'] - 1;
  523.                 $importantPart['height'] = 1;
  524.             }
  525.         }
  527.         if (!$importantPart['width'] || !$importantPart['height'])
  528.         {
  529.             return null;
  530.         }
  532.         return new ImportantPart(
  533.             $importantPart['x'] / $this->fileObj->viewWidth,
  534.             $importantPart['y'] / $this->fileObj->viewHeight,
  535.             $importantPart['width'] / $this->fileObj->viewWidth,
  536.             $importantPart['height'] / $this->fileObj->viewHeight
  537.         );
  538.     }
  540.     /**
  541.      * Prepare resize configuration object.
  542.      *
  543.      * @return ResizeConfiguration
  544.      */
  545.     protected function prepareResizeConfig()
  546.     {
  547.         $resizeConfig = new ResizeConfiguration();
  548.         $resizeConfig->setWidth($this->targetWidth);
  549.         $resizeConfig->setHeight($this->targetHeight);
  550.         $resizeConfig->setZoomLevel($this->zoomLevel);
  552.         if (substr_count($this->resizeMode, '_') === 1)
  553.         {
  554.             $resizeConfig->setMode(ResizeConfiguration::MODE_CROP);
  555.             $resizeConfig->setZoomLevel(0);
  556.         }
  557.         else
  558.         {
  559.             try
  560.             {
  561.                 $resizeConfig->setMode($this->resizeMode);
  562.             }
  563.             catch (\Throwable $exception)
  564.             {
  565.                 $resizeConfig->setMode(ResizeConfiguration::MODE_CROP);
  566.             }
  567.         }
  569.         return $resizeConfig;
  570.     }
  572.     /**
  573.      * Calculate the resize coordinates
  574.      *
  575.      * @return array The resize coordinates (width, height, target_x, target_y, target_width, target_height)
  576.      */
  577.     public function computeResize()
  578.     {
  579.         $resizeCoordinates = System::getContainer()
  580.             ->get('contao.image.resize_calculator')
  581.             ->calculate(
  582.                 $this->prepareResizeConfig(),
  583.                 new ImageDimensions(
  584.                     new Box($this->fileObj->viewWidth, $this->fileObj->viewHeight),
  585.                     $this->fileObj->viewWidth !== $this->fileObj->width
  586.                 ),
  587.                 $this->prepareImportantPart()
  588.             )
  589.         ;
  591.         return array
  592.         (
  593.             'width' => $resizeCoordinates->getCropSize()->getWidth(),
  594.             'height' => $resizeCoordinates->getCropSize()->getHeight(),
  595.             'target_x' => -$resizeCoordinates->getCropStart()->getX(),
  596.             'target_y' => -$resizeCoordinates->getCropStart()->getY(),
  597.             'target_width' => $resizeCoordinates->getSize()->getWidth(),
  598.             'target_height' => $resizeCoordinates->getSize()->getHeight(),
  599.         );
  600.     }
  602.     /**
  603.      * Get the relative path to an image
  604.      *
  605.      * @param string $src The image name or path
  606.      *
  607.      * @return string The relative path
  608.      */
  609.     public static function getPath($src)
  610.     {
  611.         if (!$src)
  612.         {
  613.             return '';
  614.         }
  616.         $src = rawurldecode($src);
  618.         if (strpos($src, '/') !== false)
  619.         {
  620.             return $src;
  621.         }
  623.         $projectDir = System::getContainer()->getParameter('kernel.project_dir');
  625.         if (strncmp($src, 'icon', 4) === 0)
  626.         {
  627.             if (pathinfo($src, PATHINFO_EXTENSION) == 'svg')
  628.             {
  629.                 return 'assets/contao/images/' . $src;
  630.             }
  632.             $filename = pathinfo($src, PATHINFO_FILENAME);
  634.             // Prefer SVG icons
  635.             if (file_exists($projectDir . '/assets/contao/images/' . $filename . '.svg'))
  636.             {
  637.                 return 'assets/contao/images/' . $filename . '.svg';
  638.             }
  640.             return 'assets/contao/images/' . $src;
  641.         }
  643.         $theme = Backend::getTheme();
  645.         if (pathinfo($src, PATHINFO_EXTENSION) == 'svg')
  646.         {
  647.             return 'system/themes/' . $theme . '/icons/' . $src;
  648.         }
  650.         $filename = pathinfo($src, PATHINFO_FILENAME);
  652.         // Prefer SVG icons
  653.         if (file_exists($projectDir . '/system/themes/' . $theme . '/icons/' . $filename . '.svg'))
  654.         {
  655.             return 'system/themes/' . $theme . '/icons/' . $filename . '.svg';
  656.         }
  658.         return 'system/themes/' . $theme . '/images/' . $src;
  659.     }
  661.     /**
  662.      * Generate an image tag and return it as string
  663.      *
  664.      * @param string $src        The image path
  665.      * @param string $alt        An optional alt attribute
  666.      * @param string $attributes A string of other attributes
  667.      *
  668.      * @return string The image HTML tag
  669.      */
  670.     public static function getHtml($src, $alt='', $attributes='')
  671.     {
  672.         $src = static::getPath($src);
  674.         if (!$src)
  675.         {
  676.             return '';
  677.         }
  679.         $container = System::getContainer();
  680.         $projectDir = $container->getParameter('kernel.project_dir');
  681.         $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  683.         if (!is_file($projectDir . '/' . $src))
  684.         {
  685.             try
  686.             {
  687.                 $deferredImage = $container->get('contao.image.factory')->create($projectDir . '/' . $src);
  688.             }
  689.             catch (\Exception $e)
  690.             {
  691.                 $deferredImage = null;
  692.             }
  694.             // Handle public bundle resources
  695.             if (file_exists($projectDir . '/' . $webDir . '/' . $src))
  696.             {
  697.                 $src = $webDir . '/' . $src;
  698.             }
  699.             elseif (!$deferredImage instanceof DeferredImageInterface)
  700.             {
  701.                 return '';
  702.             }
  703.         }
  705.         $objFile = new File($src);
  707.         // Strip the contao.web_dir directory prefix (see #337)
  708.         if (strncmp($src, $webDir . '/', \strlen($webDir) + 1) === 0)
  709.         {
  710.             $src = substr($src, \strlen($webDir) + 1);
  711.         }
  713.         $context = (strncmp($src, 'assets/', 7) === 0) ? 'assets_context' : 'files_context';
  715.         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 : '') . '>';
  716.     }
  718.     /**
  719.      * Resize or crop an image and replace the original with the resized version
  720.      *
  721.      * @param string  $image  The image path
  722.      * @param integer $width  The target width
  723.      * @param integer $height The target height
  724.      * @param string  $mode   The resize mode
  725.      *
  726.      * @return boolean True if the image could be resized successfully
  727.      *
  728.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  729.      *             Use the contao.image.factory service instead.
  730.      */
  731.     public static function resize($image, $width, $height, $mode='')
  732.     {
  733.         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.');
  735.         return static::get($image, $width, $height, $mode, $image, true) ? true : false;
  736.     }
  738.     /**
  739.      * Create an image instance from the given image path and size
  740.      *
  741.      * @param string|File          $image The image path or File instance
  742.      * @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
  743.      *
  744.      * @return static The created image instance
  745.      *
  746.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  747.      *             Use the contao.image.factory service instead.
  748.      */
  749.     public static function create($image, $size=null)
  750.     {
  751.         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.');
  753.         if (\is_string($image))
  754.         {
  755.             $image = new File(rawurldecode($image));
  756.         }
  758.         $imageObj = new static($image);
  760.         if (\is_array($size) && !empty($size[2]))
  761.         {
  762.             // tl_image_size ID as resize mode
  763.             if (is_numeric($size[2]))
  764.             {
  765.                 $size = (int) $size[2];
  766.             }
  768.             // Predefined image size as resize mode
  769.             elseif (\is_string($size[2]) && $size[2][0] === '_')
  770.             {
  771.                 $size = $size[2];
  772.             }
  773.         }
  775.         if (\is_array($size))
  776.         {
  777.             $size += array(0, 0, 'crop');
  779.             $imageObj
  780.                 ->setTargetWidth($size[0])
  781.                 ->setTargetHeight($size[1])
  782.                 ->setResizeMode($size[2])
  783.             ;
  784.         }
  786.         // Load the image size from the database if $size is an ID or a predefined size
  787.         elseif (($imageSize = self::getImageSizeConfig($size)) !== null)
  788.         {
  789.             $imageObj
  790.                 ->setTargetWidth($imageSize->width)
  791.                 ->setTargetHeight($imageSize->height)
  792.                 ->setResizeMode($imageSize->resizeMode)
  793.                 ->setZoomLevel($imageSize->zoom)
  794.             ;
  795.         }
  797.         $fileRecord = FilesModel::findByPath($image->path);
  798.         $currentSize = $image->imageViewSize;
  800.         // Set the important part
  801.         if ($fileRecord !== null && $fileRecord->importantPartWidth && $fileRecord->importantPartHeight)
  802.         {
  803.             $imageObj->setImportantPart(array
  804.             (
  805.                 'x' => (int) ($fileRecord->importantPartX * $currentSize[0]),
  806.                 'y' => (int) ($fileRecord->importantPartY * $currentSize[1]),
  807.                 'width' => (int) ($fileRecord->importantPartWidth * $currentSize[0]),
  808.                 'height' => (int) ($fileRecord->importantPartHeight * $currentSize[1]),
  809.             ));
  810.         }
  812.         return $imageObj;
  813.     }
  815.     private static function getImageSizeConfig($size)
  816.     {
  817.         if (is_numeric($size))
  818.         {
  819.             return ImageSizeModel::findByPk($size);
  820.         }
  822.         if (!\is_string($size) || $size[0] !== '_')
  823.         {
  824.             return null;
  825.         }
  827.         static $predefinedSizes = null;
  829.         if ($predefinedSizes === null)
  830.         {
  831.             $factory = System::getContainer()->get('contao.image.factory');
  832.             $predefinedSizes = (new \ReflectionObject($factory))->getProperty('predefinedSizes');
  833.             $predefinedSizes->setAccessible(true);
  834.             $predefinedSizes = $predefinedSizes->getValue($factory) ?? array();
  835.         }
  837.         if (!isset($predefinedSizes[$size]))
  838.         {
  839.             return null;
  840.         }
  842.         $imageSize = new \stdClass();
  843.         $imageSize->width = $predefinedSizes[$size]['width'];
  844.         $imageSize->height = $predefinedSizes[$size]['height'];
  845.         $imageSize->resizeMode = $predefinedSizes[$size]['resizeMode'];
  846.         $imageSize->zoom = $predefinedSizes[$size]['zoom'];
  848.         return $imageSize;
  849.     }
  851.     /**
  852.      * Resize an image and store the resized version in the image target folder
  853.      *
  854.      * @param string  $image  The image path
  855.      * @param integer $width  The target width
  856.      * @param integer $height The target height
  857.      * @param string  $mode   The resize mode
  858.      * @param string  $target An optional target path
  859.      * @param boolean $force  Override existing target images
  860.      *
  861.      * @return string|null The path of the resized image or null
  862.      *
  863.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  864.      *             Use the contao.image.factory service instead.
  865.      */
  866.     public static function get($image, $width, $height, $mode='', $target=null, $force=false)
  867.     {
  868.         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.');
  870.         if (!$image)
  871.         {
  872.             return null;
  873.         }
  875.         try
  876.         {
  877.             $imageObj = static::create($image, array($width, $height, $mode));
  878.             $imageObj->setTargetPath($target);
  879.             $imageObj->setForceOverride($force);
  881.             if ($path = $imageObj->executeResize()->getResizedPath())
  882.             {
  883.                 return $path;
  884.             }
  885.         }
  886.         catch (\Exception $e)
  887.         {
  888.             System::getContainer()->get('monolog.logger.contao.error')->error('Image "' . $image . '" could not be processed: ' . $e->getMessage());
  889.         }
  891.         return null;
  892.     }
  894.     /**
  895.      * Convert sizes like 2em, 10cm or 12pt to pixels
  896.      *
  897.      * @param string $size The size string
  898.      *
  899.      * @return integer The pixel value
  900.      *
  901.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.0.
  902.      *             Use the contao.image.factory service instead.
  903.      */
  904.     public static function getPixelValue($size)
  905.     {
  906.         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.');
  908.         $value = preg_replace('/[^0-9.-]+/', '', $size);
  909.         $unit = preg_replace('/[^acehimnprtvwx%]/', '', $size);
  911.         // Convert 16px = 1em = 2ex = 12pt = 1pc = 1/6in = 2.54/6cm = 25.4/6mm = 100%
  912.         switch ($unit)
  913.         {
  914.             case '':
  915.             case 'px':
  916.                 return (int) round($value);
  918.             case 'pc':
  919.             case 'em':
  920.                 return (int) round($value * 16);
  922.             case 'ex':
  923.                 return (int) round($value * 16 / 2);
  925.             case 'pt':
  926.                 return (int) round($value * 16 / 12);
  928.             case 'in':
  929.                 return (int) round($value * 16 * 6);
  931.             case 'cm':
  932.                 return (int) round($value * 16 / (2.54 / 6));
  934.             case 'mm':
  935.                 return (int) round($value * 16 / (25.4 / 6));
  937.             case '%':
  938.                 return (int) round($value * 16 / 100);
  939.         }
  941.         return 0;
  942.     }
  943. }
  945. class_alias(Image::class, 'Image');