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

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 DOMDocument;
  20. use Imagine\Image\Box;
  21. use Imagine\Image\BoxInterface;
  22. use Imagine\Image\ImagineInterface;
  23. use Imagine\Image\Metadata\MetadataBag;
  24. use Symfony\Component\Filesystem\Filesystem;
  25. use Webmozart\PathUtil\Path;
  26. use XMLReader;
  28. class Image implements ImageInterface
  29. {
  30.     /**
  31.      * @var string
  32.      *
  33.      * @internal
  34.      */
  35.     protected $path;
  37.     /**
  38.      * @var ImageDimensions
  39.      *
  40.      * @internal
  41.      */
  42.     protected $dimensions;
  44.     /**
  45.      * @var ImagineInterface
  46.      *
  47.      * @internal
  48.      */
  49.     protected $imagine;
  51.     /**
  52.      * @var ImportantPart
  53.      */
  54.     private $importantPart;
  56.     public function __construct(string $path, ImagineInterface $imagine, Filesystem $filesystem = null)
  57.     {
  58.         if (null === $filesystem) {
  59.             $filesystem = new Filesystem();
  60.         }
  62.         if (!$filesystem->exists($path)) {
  63.             throw new FileNotExistsException($path.' does not exist');
  64.         }
  66.         if (is_dir($path)) {
  67.             throw new FileNotExistsException($path.' is a directory');
  68.         }
  70.         $this->path = $path;
  71.         $this->imagine = $imagine;
  72.     }
  74.     /**
  75.      * {@inheritdoc}
  76.      */
  77.     public function getImagine(): ImagineInterface
  78.     {
  79.         return $this->imagine;
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function getPath(): string
  86.     {
  87.         return $this->path;
  88.     }
  90.     /**
  91.      * {@inheritdoc}
  92.      */
  93.     public function getUrl(string $rootDir, string $prefix = ''): string
  94.     {
  95.         if (!Path::isBasePath($rootDir, $this->path)) {
  96.             throw new InvalidArgumentException(sprintf('Path "%s" is not inside root directory "%s"', $this->path, $rootDir));
  97.         }
  99.         $url = Path::makeRelative($this->path, $rootDir);
  100.         $url = str_replace('%2F', '/', rawurlencode($url));
  102.         return $prefix.$url;
  103.     }
  105.     /**
  106.      * {@inheritdoc}
  107.      */
  108.     public function getDimensions(): ImageDimensions
  109.     {
  110.         if (null === $this->dimensions) {
  111.             // Try getSvgSize() or native exif_read_data()/getimagesize() for better performance
  112.             if ($this->imagine instanceof SvgImagine) {
  113.                 $size = $this->getSvgSize();
  115.                 if (null !== $size) {
  116.                     $this->dimensions = new ImageDimensions($size);
  117.                 }
  118.             } elseif (
  119.                 \function_exists('exif_read_data')
  120.                 && ($exif = @exif_read_data($this->path, 'COMPUTED,IFD0'))
  121.                 && !empty($exif['COMPUTED']['Width'])
  122.                 && !empty($exif['COMPUTED']['Height'])
  123.             ) {
  124.                 $orientation = $this->fixOrientation($exif['Orientation'] ?? null);
  125.                 $size = $this->fixSizeOrientation(new Box($exif['COMPUTED']['Width'], $exif['COMPUTED']['Height']), $orientation);
  126.                 $this->dimensions = new ImageDimensions($size, null, null, $orientation);
  127.             } elseif (
  128.                 ($size = @getimagesize($this->path))
  129.                 && !empty($size[0]) && !empty($size[1])
  130.             ) {
  131.                 $this->dimensions = new ImageDimensions(new Box($size[0], $size[1]));
  132.             }
  134.             // Fall back to Imagine
  135.             if (null === $this->dimensions) {
  136.                 $imagineImage = $this->imagine->open($this->path);
  137.                 $orientation = $this->fixOrientation($imagineImage->metadata()->get('ifd0.Orientation'));
  138.                 $size = $this->fixSizeOrientation($imagineImage->getSize(), $orientation);
  139.                 $this->dimensions = new ImageDimensions($size, null, null, $orientation);
  140.             }
  141.         }
  143.         return $this->dimensions;
  144.     }
  146.     /**
  147.      * {@inheritdoc}
  148.      */
  149.     public function getImportantPart(): ImportantPart
  150.     {
  151.         return $this->importantPart ?? new ImportantPart();
  152.     }
  154.     /**
  155.      * {@inheritdoc}
  156.      */
  157.     public function setImportantPart(ImportantPart $importantPart = null): ImageInterface
  158.     {
  159.         $this->importantPart = $importantPart;
  161.         return $this;
  162.     }
  164.     /**
  165.      * Corrects invalid EXIF orientation values.
  166.      */
  167.     private function fixOrientation($orientation): int
  168.     {
  169.         $orientation = (int) $orientation;
  171.         if ($orientation < 1 || $orientation > 8) {
  172.             return ImageDimensions::ORIENTATION_NORMAL;
  173.         }
  175.         return $orientation;
  176.     }
  178.     /**
  179.      * Swaps width and height for (-/+)90 degree rotated orientations.
  180.      */
  181.     private function fixSizeOrientation(BoxInterface $size, int $orientation): BoxInterface
  182.     {
  183.         if (
  184.             \in_array(
  185.                 $orientation,
  186.                 [
  187.                     ImageDimensions::ORIENTATION_90,
  188.                     ImageDimensions::ORIENTATION_270,
  189.                     ImageDimensions::ORIENTATION_MIRROR_90,
  190.                     ImageDimensions::ORIENTATION_MIRROR_270,
  191.                 ],
  192.                 true
  193.             )
  194.         ) {
  195.             return new Box($size->getHeight(), $size->getWidth());
  196.         }
  198.         return $size;
  199.     }
  201.     /**
  202.      * Reads the SVG image file partially and returns the size of it.
  203.      *
  204.      * This is faster than reading and parsing the whole SVG file just to get
  205.      * the size of it, especially for large files.
  206.      */
  207.     private function getSvgSize(): ?BoxInterface
  208.     {
  209.         if (!class_exists(SvgImage::class) || !class_exists(XMLReader::class) || !class_exists(DOMDocument::class)) {
  210.             return null;
  211.         }
  213.         static $zlibSupport;
  215.         if (null === $zlibSupport) {
  216.             $reader = new XMLReader();
  217.             $zlibSupport = \in_array('compress.zlib', stream_get_wrappers(), true)
  218.                 && true === @$reader->open('compress.zlib://data:text/xml,<x/>')
  219.                 && true === @$reader->read()
  220.                 && true === @$reader->close();
  221.         }
  223.         $size = null;
  224.         $reader = new XMLReader();
  225.         $path = $this->path;
  227.         if ($zlibSupport) {
  228.             $path = 'compress.zlib://'.$path;
  229.         }
  231.         $disableEntities = null;
  233.         if (LIBXML_VERSION < 20900) {
  234.             // Enable the entity loader at first to make XMLReader::open() work
  235.             // see https://bugs.php.net/bug.php?id=73328
  236.             $disableEntities = libxml_disable_entity_loader(false);
  237.         }
  239.         $internalErrors = libxml_use_internal_errors(true);
  241.         if ($reader->open($path, null, LIBXML_NONET)) {
  242.             if (LIBXML_VERSION < 20900) {
  243.                 // After opening the file disable the entity loader for security reasons
  244.                 libxml_disable_entity_loader();
  245.             }
  247.             $size = $this->getSvgSizeFromReader($reader);
  249.             $reader->close();
  250.         }
  252.         if (LIBXML_VERSION < 20900) {
  253.             libxml_disable_entity_loader($disableEntities);
  254.         }
  256.         libxml_use_internal_errors($internalErrors);
  257.         libxml_clear_errors();
  259.         return $size;
  260.     }
  262.     /**
  263.      * Extracts the SVG image size from the given XMLReader object.
  264.      */
  265.     private function getSvgSizeFromReader(XMLReader $reader): ?BoxInterface
  266.     {
  267.         // Move the pointer to the first element in the document
  268.         while ($reader->read() && XMLReader::ELEMENT !== $reader->nodeType);
  270.         if (XMLReader::ELEMENT !== $reader->nodeType || 'svg' !== $reader->name) {
  271.             return null;
  272.         }
  274.         $document = new DOMDocument();
  275.         $svg = $document->createElement('svg');
  276.         $document->appendChild($svg);
  278.         foreach (['width', 'height', 'viewBox'] as $key) {
  279.             if ($value = $reader->getAttribute($key)) {
  280.                 $svg->setAttribute($key, $value);
  281.             }
  282.         }
  284.         $image = new SvgImage($document, new MetadataBag());
  286.         return $image->getSize();
  287.     }
  288. }