vendor/pimcore/pimcore/models/Asset/Image.php line 30

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Model\Asset;
  18. use Pimcore\Event\FrontendEvents;
  19. use Pimcore\File;
  20. use Pimcore\Model;
  21. use Pimcore\Tool;
  22. use Pimcore\Tool\Console;
  23. use Pimcore\Tool\Storage;
  24. use Symfony\Component\EventDispatcher\GenericEvent;
  25. use Symfony\Component\Process\Process;
  27. /**
  28.  * @method \Pimcore\Model\Asset\Dao getDao()
  29.  */
  30. class Image extends Model\Asset
  31. {
  32.     use Model\Asset\MetaData\EmbeddedMetaDataTrait;
  34.     /**
  35.      * {@inheritdoc}
  36.      */
  37.     protected $type = 'image';
  39.     private bool $clearThumbnailsOnSave = false;
  41.     /**
  42.      * {@inheritdoc}
  43.      */
  44.     protected function update($params = [])
  45.     {
  46.         if ($this->getDataChanged()) {
  47.             foreach (['imageWidth', 'imageHeight', 'imageDimensionsCalculated'] as $key) {
  48.                 $this->removeCustomSetting($key);
  49.             }
  50.         }
  52.         if ($params['isUpdate']) {
  53.             $this->clearThumbnails($this->clearThumbnailsOnSave);
  54.             $this->clearThumbnailsOnSave = false; // reset to default
  55.         }
  57.         parent::update($params);
  58.     }
  60.     /**
  61.      * @internal
  62.      */
  63.     public function detectFocalPoint(): bool
  64.     {
  65.         if ($this->getCustomSetting('focalPointX') && $this->getCustomSetting('focalPointY')) {
  66.             return false;
  67.         }
  69.         if ($faceCordintates = $this->getCustomSetting('faceCoordinates')) {
  70.             $xPoints = [];
  71.             $yPoints = [];
  73.             foreach ($faceCordintates as $fc) {
  74.                 // focal point calculation
  75.                 $xPoints[] = ($fc['x'] + $fc['x'] + $fc['width']) / 2;
  76.                 $yPoints[] = ($fc['y'] + $fc['y'] + $fc['height']) / 2;
  77.             }
  79.             $focalPointX = array_sum($xPoints) / count($xPoints);
  80.             $focalPointY = array_sum($yPoints) / count($yPoints);
  82.             $this->setCustomSetting('focalPointX', $focalPointX);
  83.             $this->setCustomSetting('focalPointY', $focalPointY);
  85.             return true;
  86.         }
  88.         return false;
  89.     }
  91.     /**
  92.      * @internal
  93.      */
  94.     public function detectFaces(): bool
  95.     {
  96.         if ($this->getCustomSetting('faceCoordinates')) {
  97.             return false;
  98.         }
  100.         $config = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['focal_point_detection'];
  102.         if (!$config['enabled']) {
  103.             return false;
  104.         }
  106.         $facedetectBin = \Pimcore\Tool\Console::getExecutable('facedetect');
  107.         if ($facedetectBin) {
  108.             $faceCoordinates = [];
  109.             $thumbnail = $this->getThumbnail(Image\Thumbnail\Config::getPreviewConfig());
  110.             $reference = $thumbnail->getPathReference();
  111.             if (in_array($reference['type'], ['asset', 'thumbnail'])) {
  112.                 $image = $thumbnail->getLocalFile();
  113.                 $imageWidth = $thumbnail->getWidth();
  114.                 $imageHeight = $thumbnail->getHeight();
  116.                 $command = [$facedetectBin, $image];
  117.                 Console::addLowProcessPriority($command);
  118.                 $process = new Process($command);
  119.                 $process->run();
  120.                 $result = $process->getOutput();
  121.                 if (strpos($result, "\n")) {
  122.                     $faces = explode("\n", trim($result));
  124.                     foreach ($faces as $coordinates) {
  125.                         list($x, $y, $width, $height) = explode(' ', $coordinates);
  127.                         // percentages
  128.                         $Px = $x / $imageWidth * 100;
  129.                         $Py = $y / $imageHeight * 100;
  130.                         $Pw = $width / $imageWidth * 100;
  131.                         $Ph = $height / $imageHeight * 100;
  133.                         $faceCoordinates[] = [
  134.                             'x' => $Px,
  135.                             'y' => $Py,
  136.                             'width' => $Pw,
  137.                             'height' => $Ph,
  138.                         ];
  139.                     }
  141.                     $this->setCustomSetting('faceCoordinates', $faceCoordinates);
  143.                     return true;
  144.                 }
  145.             }
  146.         }
  148.         return false;
  149.     }
  151.     /**
  152.      * @internal
  153.      *
  154.      * @param null|string $generator
  155.      *
  156.      * @return bool|string
  157.      *
  158.      * @throws \Exception
  159.      */
  160.     public function generateLowQualityPreview($generator = null)
  161.     {
  162.         $config = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['low_quality_image_preview'];
  164.         if (!$config['enabled']) {
  165.             return false;
  166.         }
  168.         // fallback
  169.         if (class_exists('Imagick')) {
  170.             // Imagick fallback
  171.             $path = $this->getThumbnail(Image\Thumbnail\Config::getPreviewConfig())->getLocalFile();
  173.             $imagick = new \Imagick($path);
  174.             $imagick->setImageFormat('jpg');
  175.             $imagick->setOption('jpeg:extent', '1kb');
  176.             $width = $imagick->getImageWidth();
  177.             $height = $imagick->getImageHeight();
  179.             // we can't use getImageBlob() here, because of a bug in combination with jpeg:extent
  180.             // http://www.imagemagick.org/discourse-server/viewtopic.php?f=3&t=24366
  181.             $tmpFile = File::getLocalTempFilePath('jpg');
  182.             $imagick->writeImage($tmpFile);
  183.             $imageBase64 = base64_encode(file_get_contents($tmpFile));
  184.             $imagick->destroy();
  185.             unlink($tmpFile);
  187.             $svg = <<<EOT
  188. <?xml version="1.0" encoding="utf-8"?>
  189. <svg version="1.1"  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="$width" height="$height" viewBox="0 0 $width $height" preserveAspectRatio="xMidYMid slice">
  190.     <filter id="blur" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
  191.     <feGaussianBlur stdDeviation="20 20" edgeMode="duplicate" />
  192.     <feComponentTransfer>
  193.       <feFuncA type="discrete" tableValues="1 1" />
  194.     </feComponentTransfer>
  195.   </filter>
  196.     <image filter="url(#blur)" x="0" y="0" height="100%" width="100%" xlink:href="data:image/jpg;base64,$imageBase64" />
  197. </svg>
  198. EOT;
  199.             $storagePath = $this->getLowQualityPreviewStoragePath();
  200.             Storage::get('thumbnail')->write($storagePath, $svg);
  202.             return $storagePath;
  203.         }
  205.         return false;
  206.     }
  208.     /**
  209.      * @return string
  210.      */
  211.     public function getLowQualityPreviewPath()
  212.     {
  213.         $storagePath = $this->getLowQualityPreviewStoragePath();
  214.         $path = $storagePath;
  216.         if (Tool::isFrontend()) {
  217.             $path = urlencode_ignore_slash($storagePath);
  218.             $prefix = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['frontend_prefixes']['source'];
  219.             $path = $prefix . $path;
  220.         }
  222.         $event = new GenericEvent($this, [
  223.             'storagePath' => $storagePath,
  224.             'frontendPath' => $path,
  225.         ]);
  226.         \Pimcore::getEventDispatcher()->dispatch($event, FrontendEvents::ASSET_IMAGE_THUMBNAIL);
  227.         $path = $event->getArgument('frontendPath');
  229.         return $path;
  230.     }
  232.     /**
  233.      * @return string
  234.      */
  235.     private function getLowQualityPreviewStoragePath()
  236.     {
  237.         return sprintf('%s/image-thumb__%s__-low-quality-preview.svg',
  238.             rtrim($this->getRealPath(), '/'),
  239.             $this->getId()
  240.         );
  241.     }
  243.     /**
  244.      * @return string|null
  245.      */
  246.     public function getLowQualityPreviewDataUri(): ?string
  247.     {
  248.         try {
  249.             $dataUri = 'data:image/svg+xml;base64,' . base64_encode(Storage::get('thumbnail')->read($this->getLowQualityPreviewStoragePath()));
  250.         } catch (\Exception $e) {
  251.             $dataUri = null;
  252.         }
  254.         return $dataUri;
  255.     }
  257.     /**
  258.      * Legacy method for backwards compatibility. Use getThumbnail($config)->getConfig() instead.
  259.      *
  260.      * @internal
  261.      *
  262.      * @param string|array|Image\Thumbnail\Config $config
  263.      *
  264.      * @return Image\Thumbnail\Config|null
  265.      */
  266.     public function getThumbnailConfig($config)
  267.     {
  268.         $thumbnail = $this->getThumbnail($config);
  270.         return $thumbnail->getConfig();
  271.     }
  273.     /**
  274.      * Returns a path to a given thumbnail or an thumbnail configuration.
  275.      *
  276.      * @param string|array|Image\Thumbnail\Config $config
  277.      * @param bool $deferred
  278.      *
  279.      * @return Image\Thumbnail
  280.      */
  281.     public function getThumbnail($config = null, $deferred = true)
  282.     {
  283.         return new Image\Thumbnail($this, $config, $deferred);
  284.     }
  286.     /**
  287.      * @internal
  288.      *
  289.      * @throws \Exception
  290.      *
  291.      * @return null|\Pimcore\Image\Adapter
  292.      */
  293.     public static function getImageTransformInstance()
  294.     {
  295.         try {
  296.             $image = \Pimcore\Image::getInstance();
  297.         } catch (\Exception $e) {
  298.             $image = null;
  299.         }
  301.         if (!$image instanceof \Pimcore\Image\Adapter) {
  302.             throw new \Exception("Couldn't get instance of image tranform processor.");
  303.         }
  305.         return $image;
  306.     }
  308.     /**
  309.      * @return string
  310.      */
  311.     public function getFormat()
  312.     {
  313.         if ($this->getWidth() > $this->getHeight()) {
  314.             return 'landscape';
  315.         } elseif ($this->getWidth() == $this->getHeight()) {
  316.             return 'square';
  317.         } elseif ($this->getHeight() > $this->getWidth()) {
  318.             return 'portrait';
  319.         }
  321.         return 'unknown';
  322.     }
  324.     /**
  325.      * @param string|null $path
  326.      * @param bool $force
  327.      *
  328.      * @return array|null
  329.      *
  330.      * @throws \Exception
  331.      */
  332.     public function getDimensions($path = null, $force = false)
  333.     {
  334.         if (!$force) {
  335.             $width = $this->getCustomSetting('imageWidth');
  336.             $height = $this->getCustomSetting('imageHeight');
  338.             if ($width && $height) {
  339.                 return [
  340.                     'width' => $width,
  341.                     'height' => $height,
  342.                 ];
  343.             }
  344.         }
  346.         if (!$path) {
  347.             $path = $this->getLocalFile();
  348.         }
  350.         $dimensions = null;
  352.         //try to get the dimensions with getimagesize because it is much faster than e.g. the Imagick-Adapter
  353.         if (is_readable($path)) {
  354.             $imageSize = getimagesize($path);
  355.             if ($imageSize && $imageSize[0] && $imageSize[1]) {
  356.                 $dimensions = [
  357.                     'width' => $imageSize[0],
  358.                     'height' => $imageSize[1],
  359.                 ];
  360.             }
  361.         }
  363.         if (!$dimensions) {
  364.             $image = self::getImageTransformInstance();
  366.             $status = $image->load($path, ['preserveColor' => true, 'asset' => $this]);
  367.             if ($status === false) {
  368.                 return null;
  369.             }
  371.             $dimensions = [
  372.                 'width' => $image->getWidth(),
  373.                 'height' => $image->getHeight(),
  374.             ];
  375.         }
  377.         // EXIF orientation
  378.         if (function_exists('exif_read_data')) {
  379.             $exif = @exif_read_data($path);
  380.             if (is_array($exif)) {
  381.                 if (array_key_exists('Orientation', $exif)) {
  382.                     $orientation = (int)$exif['Orientation'];
  383.                     if (in_array($orientation, [5, 6, 7, 8])) {
  384.                         // flip height & width
  385.                         $dimensions = [
  386.                             'width' => $dimensions['height'],
  387.                             'height' => $dimensions['width'],
  388.                         ];
  389.                     }
  390.                 }
  391.             }
  392.         }
  394.         if (($width = $dimensions['width']) && ($height = $dimensions['height'])) {
  395.             // persist dimensions to database
  396.             $this->setCustomSetting('imageDimensionsCalculated', true);
  397.             $this->setCustomSetting('imageWidth', $width);
  398.             $this->setCustomSetting('imageHeight', $height);
  399.             $this->getDao()->updateCustomSettings();
  400.             $this->clearDependentCache();
  401.         }
  403.         return $dimensions;
  404.     }
  406.     /**
  407.      * @return int
  408.      */
  409.     public function getWidth()
  410.     {
  411.         $dimensions = $this->getDimensions();
  413.         if ($dimensions) {
  414.             return $dimensions['width'];
  415.         }
  417.         return 0;
  418.     }
  420.     /**
  421.      * @return int
  422.      */
  423.     public function getHeight()
  424.     {
  425.         $dimensions = $this->getDimensions();
  427.         if ($dimensions) {
  428.             return $dimensions['height'];
  429.         }
  431.         return 0;
  432.     }
  434.     /**
  435.      * {@inheritdoc}
  436.      */
  437.     public function setCustomSetting($key, $value)
  438.     {
  439.         if (in_array($key, ['focalPointX', 'focalPointY'])) {
  440.             // if the focal point changes we need to clean all thumbnails on save
  441.             if ($this->getCustomSetting($key) != $value) {
  442.                 $this->clearThumbnailsOnSave = true;
  443.             }
  444.         }
  446.         return parent::setCustomSetting($key, $value);
  447.     }
  449.     /**
  450.      * @return bool
  451.      */
  452.     public function isVectorGraphic()
  453.     {
  454.         // we use a simple file-extension check, for performance reasons
  455.         if (preg_match("@\.(svgz?|eps|pdf|ps|ai|indd)$@", $this->getFilename())) {
  456.             return true;
  457.         }
  459.         return false;
  460.     }
  462.     /**
  463.      * Checks if this file represents an animated image (png or gif)
  464.      *
  465.      * @return bool
  466.      */
  467.     public function isAnimated()
  468.     {
  469.         $isAnimated = false;
  471.         switch ($this->getMimeType()) {
  472.             case 'image/gif':
  473.                 $isAnimated = $this->isAnimatedGif();
  475.                 break;
  476.             case 'image/png':
  477.                 $isAnimated = $this->isAnimatedPng();
  479.                 break;
  480.             default:
  481.                 break;
  482.         }
  484.         return $isAnimated;
  485.     }
  487.     /**
  488.      * Checks if this object represents an animated gif file
  489.      *
  490.      * @return bool
  491.      */
  492.     private function isAnimatedGif()
  493.     {
  494.         $isAnimated = false;
  496.         if ($this->getMimeType() == 'image/gif') {
  497.             $fileContent = $this->getData();
  499.             /**
  500.              * An animated gif contains multiple "frames", with each frame having a header made up of:
  501.              *  - a static 4-byte sequence (\x00\x21\xF9\x04)
  502.              *  - 4 variable bytes
  503.              *  - a static 2-byte sequence (\x00\x2C) (some variants may use \x00\x21 ?)
  504.              *
  505.              * @see http://it.php.net/manual/en/function.imagecreatefromgif.php#104473
  506.              */
  507.             $numberOfFrames = preg_match_all('#\x00\x21\xF9\x04.{4}\x00(\x2C|\x21)#s', $fileContent, $matches);
  509.             $isAnimated = $numberOfFrames > 1;
  510.         }
  512.         return $isAnimated;
  513.     }
  515.     /**
  516.      * Checks if this object represents an animated png file
  517.      *
  518.      * @return bool
  519.      */
  520.     private function isAnimatedPng()
  521.     {
  522.         $isAnimated = false;
  524.         if ($this->getMimeType() == 'image/png') {
  525.             $fileContent = $this->getData();
  527.             /**
  528.              * Valid APNGs have an "acTL" chunk somewhere before their first "IDAT" chunk.
  529.              *
  530.              * @see http://foone.org/apng/
  531.              */
  532.             $isAnimated = strpos(substr($fileContent, 0, strpos($fileContent, 'IDAT')), 'acTL') !== false;
  533.         }
  535.         return $isAnimated;
  536.     }
  537. }