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. }