vendor/contao/image/src/Image.php line 106

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of Contao.
  7.  *
  8.  * (c) Leo Feyer
  9.  *
  10.  * @license LGPL-3.0-or-later
  11.  */
  13. namespace Contao\Image;
  15. use Contao\Image\Exception\FileNotExistsException;
  16. use Contao\Image\Exception\InvalidArgumentException;
  17. use Contao\ImagineSvg\Image as SvgImage;
  18. use Contao\ImagineSvg\Imagine as SvgImagine;
  19. use Imagine\Image\Box;
  20. use Imagine\Image\BoxInterface;
  21. use Imagine\Image\ImagineInterface;
  22. use Imagine\Image\Metadata\MetadataBag;
  23. use Symfony\Component\Filesystem\Filesystem;
  24. use Symfony\Component\Filesystem\Path;
  26. class Image implements ImageInterface
  27. {
  28.     /**
  29.      * @var string
  30.      *
  31.      * @internal
  32.      */
  33.     protected $path;
  35.     /**
  36.      * @var ImageDimensions
  37.      *
  38.      * @internal
  39.      */
  40.     protected $dimensions;
  42.     /**
  43.      * @var ImagineInterface
  44.      *
  45.      * @internal
  46.      */
  47.     protected $imagine;
  49.     /**
  50.      * @var ImportantPart|null
  51.      */
  52.     private $importantPart;
  54.     public function __construct(string $path, ImagineInterface $imagine, Filesystem $filesystem = null)
  55.     {
  56.         if (null === $filesystem) {
  57.             $filesystem = new Filesystem();
  58.         }
  60.         if (!$filesystem->exists($path)) {
  61.             throw new FileNotExistsException($path.' does not exist');
  62.         }
  64.         if (is_dir($path)) {
  65.             throw new FileNotExistsException($path.' is a directory');
  66.         }
  68.         $this->path = $path;
  69.         $this->imagine = $imagine;
  70.     }
  72.     /**
  73.      * {@inheritdoc}
  74.      */
  75.     public function getImagine(): ImagineInterface
  76.     {
  77.         return $this->imagine;
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function getPath(): string
  84.     {
  85.         return $this->path;
  86.     }
  88.     /**
  89.      * {@inheritdoc}
  90.      */
  91.     public function getUrl(string $rootDir, string $prefix = ''): string
  92.     {
  93.         if (!Path::isBasePath($rootDir, $this->path)) {
  94.             throw new InvalidArgumentException(sprintf('Path "%s" is not inside root directory "%s"', $this->path, $rootDir));
  95.         }
  97.         $url = Path::makeRelative($this->path, $rootDir);
  98.         $url = str_replace('%2F', '/', rawurlencode($url));
  100.         return $prefix.$url;
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      */
  106.     public function getDimensions(): ImageDimensions
  107.     {
  108.         if (null === $this->dimensions) {
  109.             // Try getSvgSize() or native exif_read_data()/getimagesize() for better performance
  110.             if ($this->imagine instanceof SvgImagine) {
  111.                 $size = $this->getSvgSize();
  113.                 if (null !== $size) {
  114.                     $this->dimensions = new ImageDimensions($size);
  115.                 }
  116.             } elseif (
  117.                 \function_exists('exif_read_data')
  118.                 && ($exif = @exif_read_data($this->path, 'COMPUTED,IFD0'))
  119.                 && !empty($exif['COMPUTED']['Width'])
  120.                 && !empty($exif['COMPUTED']['Height'])
  121.             ) {
  122.                 $orientation = $this->fixOrientation($exif['Orientation'] ?? null);
  123.                 $size = $this->fixSizeOrientation(new Box($exif['COMPUTED']['Width'], $exif['COMPUTED']['Height']), $orientation);
  124.                 $this->dimensions = new ImageDimensions($size, null, null, $orientation);
  125.             } elseif (
  126.                 ($size = @getimagesize($this->path))
  127.                 && !empty($size[0]) && !empty($size[1])
  128.             ) {
  129.                 $this->dimensions = new ImageDimensions(new Box($size[0], $size[1]));
  130.             }
  132.             // Fall back to Imagine
  133.             if (null === $this->dimensions) {
  134.                 $imagineImage = $this->imagine->open($this->path);
  135.                 $orientation = $this->fixOrientation($imagineImage->metadata()->get('ifd0.Orientation'));
  136.                 $size = $this->fixSizeOrientation($imagineImage->getSize(), $orientation);
  137.                 $this->dimensions = new ImageDimensions($size, null, null, $orientation);
  138.             }
  139.         }
  141.         return $this->dimensions;
  142.     }
  144.     /**
  145.      * {@inheritdoc}
  146.      */
  147.     public function getImportantPart(): ImportantPart
  148.     {
  149.         return $this->importantPart ?? new ImportantPart();
  150.     }
  152.     /**
  153.      * {@inheritdoc}
  154.      */
  155.     public function setImportantPart(ImportantPart $importantPart = null): ImageInterface
  156.     {
  157.         $this->importantPart = $importantPart;
  159.         return $this;
  160.     }
  162.     /**
  163.      * Corrects invalid EXIF orientation values.
  164.      */
  165.     private function fixOrientation($orientation): int
  166.     {
  167.         $orientation = (int) $orientation;
  169.         if ($orientation < 1 || $orientation > 8) {
  170.             return ImageDimensions::ORIENTATION_NORMAL;
  171.         }
  173.         return $orientation;
  174.     }
  176.     /**
  177.      * Swaps width and height for (-/+)90 degree rotated orientations.
  178.      */
  179.     private function fixSizeOrientation(BoxInterface $size, int $orientation): BoxInterface
  180.     {
  181.         if (
  182.             \in_array(
  183.                 $orientation,
  184.                 [
  185.                     ImageDimensions::ORIENTATION_90,
  186.                     ImageDimensions::ORIENTATION_270,
  187.                     ImageDimensions::ORIENTATION_MIRROR_90,
  188.                     ImageDimensions::ORIENTATION_MIRROR_270,
  189.                 ],
  190.                 true
  191.             )
  192.         ) {
  193.             return new Box($size->getHeight(), $size->getWidth());
  194.         }
  196.         return $size;
  197.     }
  199.     /**
  200.      * Reads the SVG image file partially and returns the size of it.
  201.      *
  202.      * This is faster than reading and parsing the whole SVG file just to get
  203.      * the size of it, especially for large files.
  204.      */
  205.     private function getSvgSize(): ?BoxInterface
  206.     {
  207.         if (!class_exists(SvgImage::class) || !class_exists(\XMLReader::class) || !class_exists(\DOMDocument::class)) {
  208.             return null;
  209.         }
  211.         static $zlibSupport;
  213.         if (null === $zlibSupport) {
  214.             $reader = new \XMLReader();
  215.             $zlibSupport = \in_array('compress.zlib', stream_get_wrappers(), true)
  216.                 && true === @$reader->open('compress.zlib://data:text/xml,<x/>')
  217.                 && true === @$reader->read()
  218.                 && true === @$reader->close();
  219.         }
  221.         $size = null;
  222.         $reader = new \XMLReader();
  223.         $path = $this->path;
  225.         if ($zlibSupport) {
  226.             $path = 'compress.zlib://'.$path;
  227.         }
  229.         $disableEntities = null;
  231.         if (LIBXML_VERSION < 20900) {
  232.             // Enable the entity loader at first to make XMLReader::open() work
  233.             // see https://bugs.php.net/bug.php?id=73328
  234.             $disableEntities = libxml_disable_entity_loader(false);
  235.         }
  237.         $internalErrors = libxml_use_internal_errors(true);
  239.         if ($reader->open($path, null, LIBXML_NONET)) {
  240.             if (LIBXML_VERSION < 20900) {
  241.                 // After opening the file disable the entity loader for security reasons
  242.                 libxml_disable_entity_loader();
  243.             }
  245.             $size = $this->getSvgSizeFromReader($reader);
  247.             $reader->close();
  248.         }
  250.         if (LIBXML_VERSION < 20900) {
  251.             libxml_disable_entity_loader($disableEntities);
  252.         }
  254.         libxml_use_internal_errors($internalErrors);
  255.         libxml_clear_errors();
  257.         return $size;
  258.     }
  260.     /**
  261.      * Extracts the SVG image size from the given XMLReader object.
  262.      */
  263.     private function getSvgSizeFromReader(\XMLReader $reader): ?BoxInterface
  264.     {
  265.         // Move the pointer to the first element in the document
  266.         while ($reader->read() && \XMLReader::ELEMENT !== $reader->nodeType);
  268.         if (\XMLReader::ELEMENT !== $reader->nodeType || 'svg' !== $reader->name) {
  269.             return null;
  270.         }
  272.         $document = new \DOMDocument();
  273.         $svg = $document->createElement('svg');
  274.         $document->appendChild($svg);
  276.         foreach (['width', 'height', 'viewBox'] as $key) {
  277.             if ($value = $reader->getAttribute($key)) {
  278.                 $svg->setAttribute($key, $value);
  279.             }
  280.         }
  282.         $image = new SvgImage($document, new MetadataBag());
  284.         return $image->getSize();
  285.     }
  286. }