TASK: Render crops correctly slowly getting somewhere

neos · Jul 12, 2024 · 9d0f47e · 9d0f47e
1 parent f15e9b6
commit 9d0f47e
Show file tree

Hide file tree

Showing 6 changed files with 318 additions and 14 deletions.
diff --git a/Neos.Media/Classes/Domain/Model/Adjustment/FocalPointCropSpecification.php b/Neos.Media/Classes/Domain/Model/Adjustment/FocalPointCropSpecification.php
@@ -0,0 +1,67 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\Media\Domain\Model\Adjustment;
+
+use Imagine\Image\Box;
+use Imagine\Image\BoxInterface;
+use Imagine\Image\Point;
+use Imagine\Image\PointInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Annotations\Aspect;
+use Neos\Media\Domain\ValueObject\Configuration\AspectRatio;
+
+#[Flow\Proxy(false)]
+final readonly class FocalPointCropSpecification
+{
+    private function __construct(
+        public PointInterface $cropOffset,
+        public BoxInterface $cropDimensions,
+        public PointInterface $croppedFocalPoint
+    ) {
+    }
+
+    public static function createFromOriginalDimensionsRequestedDimensionsAndFocalPoint(
+        BoxInterface $originalDimensions,
+        PointInterface $originalFocalPoint,
+        BoxInterface $requestedDimensions,
+    ): self {
+        $originalAspect = new AspectRatio($originalDimensions->getWidth(), $originalDimensions->getHeight());
+        $finalAspect = new AspectRatio($requestedDimensions->getWidth(), $requestedDimensions->getHeight());
+
+        if ($originalAspect->getRatio() >= $finalAspect->getRatio()) {
+            // leading dimension = height, width is cropped
+            $factor = $requestedDimensions->getHeight() / $originalDimensions->getHeight();
+            $cropBox = new Box((int)$requestedDimensions->getWidth() / $factor, $requestedDimensions->getHeight() / $factor);
+            $cropX = $originalFocalPoint->getX() - (int)($cropBox->getWidth() / 2);
+            $cropXMax = $originalDimensions->getWidth() - $cropBox->getWidth();
+            if ($cropX < 0) {
+                $cropX = 0;
+            } elseif ($cropX > $cropXMax) {
+                $cropX = $cropXMax;
+            }
+            $cropOffset = new Point($cropX, 0);
+        } else {
+            // leading dimension = width, height is cropped
+            $factor = $requestedDimensions->getWidth() / $originalDimensions->getWidth();
+            $cropBox = new Box((int)$requestedDimensions->getWidth() / $factor, $requestedDimensions->getHeight() / $factor);
+            $cropY = $originalFocalPoint->getY() - (int)($cropBox->getHeight() / 2);
+            $cropYMax = $originalDimensions->getHeight() - $cropBox->getHeight();
+            if ($cropY < 0) {
+                $cropY = 0;
+            } elseif ($cropY > $cropYMax) {
+                $cropY = $cropYMax;
+            }
+            $cropOffset = new Point(0, $cropY);
+        }
+
+        return new self(
+            $cropOffset,
+            $cropBox,
+            new Point(
+                (int)round(($originalFocalPoint->getX() - $cropOffset->getX()) * $factor),
+                (int)round(($originalFocalPoint->getY() - $cropOffset->getY()) * $factor)
+            )
+        );
+    }
+}
diff --git a/Neos.Media/Classes/Domain/Model/FocalPointSupportInterface.php b/Neos.Media/Classes/Domain/Model/FocalPointSupportInterface.php
@@ -13,6 +13,8 @@
  * source code.
  */
 
+use Imagine\Image\PointInterface;
+
 /**
  * Interface for assets which provide methods for focal points
  */
@@ -25,4 +27,8 @@ public function setFocalPointX(?int $x): void;
     public function getFocalPointY(): ?int;
 
     public function setFocalPointY(?int $y): void;
+
+    public function hasFocalPoint(): bool;
+
+    public function getFocalPoint(): ?PointInterface;
 }
diff --git a/Neos.Media/Classes/Domain/Model/FocalPointTrait.php b/Neos.Media/Classes/Domain/Model/FocalPointTrait.php
@@ -12,6 +12,8 @@
  */
 
 use Doctrine\ORM\Mapping as ORM;
+use Imagine\Image\Point;
+use Imagine\Image\PointInterface;
 
 /**
  * Trait for assets which provide methods for focal points
@@ -50,4 +52,20 @@ public function setFocalPointY(?int $y): void
     {
         $this->focalPointY = $y;
     }
+
+    public function hasFocalPoint(): bool
+    {
+        if ($this->focalPointX !== null && $this->focalPointY !== null) {
+            return true;
+        }
+        return false;
+    }
+
+    public function getFocalPoint(): ?PointInterface
+    {
+        if ($this->hasFocalPoint()) {
+            return new Point($this->focalPointX, $this->focalPointY);
+        }
+        return null;
+    }
 }
diff --git a/Neos.Media/Classes/Domain/Model/ThumbnailGenerator/ImageThumbnailGenerator.php b/Neos.Media/Classes/Domain/Model/ThumbnailGenerator/ImageThumbnailGenerator.php
@@ -12,12 +12,17 @@
  */
 
 use Neos\Flow\Annotations as Flow;
+use Neos\Media\Domain\Model\Adjustment\CropImageAdjustment;
+use Neos\Media\Domain\Model\Adjustment\FocalPointCropSpecification;
+use Neos\Media\Domain\Model\Adjustment\ImageDimensionCalculationHelperThingy;
 use Neos\Media\Domain\Model\Adjustment\QualityImageAdjustment;
 use Neos\Media\Domain\Model\Adjustment\ResizeImageAdjustment;
+use Neos\Media\Domain\Model\FocalPointSupportInterface;
 use Neos\Media\Domain\Model\ImageInterface;
 use Neos\Media\Domain\Model\Thumbnail;
 use Neos\Media\Domain\Service\ImageService;
 use Neos\Media\Exception;
+use Neos\Media\Imagine\Box;
 
 /**
  * A system-generated preview version of an Image
@@ -57,11 +62,6 @@ public function canRefresh(Thumbnail $thumbnail)
     public function refresh(Thumbnail $thumbnail)
     {
         try {
-            /**
-             * @todo ... add additional crop to ensure that the focal point is in view
-             * in view after resizing ... needs common understanding wit
-             * the thumbnail service here: Packages/Neos/Neos.Media/Classes/Domain/Service/ThumbnailService.php:151
-             */
             $adjustments = [
                 new ResizeImageAdjustment(
                     [
@@ -80,13 +80,58 @@ public function refresh(Thumbnail $thumbnail)
                 )
             ];
 
+            $asset = $thumbnail->getOriginalAsset();
+            $focalPointCropSpec = null;
+            if ($asset instanceof FocalPointSupportInterface && $asset->hasFocalPoint()) {
+
+                // in case we have a focal point we calculate the target dimension and adds an
+                // additional crop to ensure that the focal point stays inside the final image
+
+                $originalFocalPoint = $asset->getFocalPoint();
+                $originalDimensions = new Box($asset->getWidth(), $asset->getHeight());
+                $requestedDimensions = ImageDimensionCalculationHelperThingy::calculateRequestedDimensions(
+                    originalDimensions: $originalDimensions,
+                    width: $thumbnail->getConfigurationValue('width'),
+                    maximumWidth: $thumbnail->getConfigurationValue('maximumWidth'),
+                    height: $thumbnail->getConfigurationValue('height'),
+                    maximumHeight: $thumbnail->getConfigurationValue('maximumHeight'),
+                    ratioMode: $thumbnail->getConfigurationValue('ratioMode'),
+                    allowUpScaling: $thumbnail->getConfigurationValue('allowUpScaling'),
+                );
+
+                $focalPointCropSpec = FocalPointCropSpecification::createFromOriginalDimensionsRequestedDimensionsAndFocalPoint(
+                    originalDimensions: $originalDimensions,
+                    originalFocalPoint: $originalFocalPoint,
+                    requestedDimensions: $requestedDimensions,
+                );
+
+                $adjustments = array_merge(
+                    [
+                        new CropImageAdjustment(
+                            [
+                                'width' => $focalPointCropSpec->cropDimensions->getWidth(),
+                                'height' =>  $focalPointCropSpec->cropDimensions->getHeight(),
+                                'x' => $focalPointCropSpec->cropOffset->getX(),
+                                'y' => $focalPointCropSpec->cropOffset->getY(),
+                            ]
+                        )
+                    ],
+                    $adjustments
+                );
+            }
+
             $targetFormat = $thumbnail->getConfigurationValue('format');
             $processedImageInfo = $this->imageService->processImage($thumbnail->getOriginalAsset()->getResource(), $adjustments, $targetFormat);
 
             $thumbnail->setResource($processedImageInfo['resource']);
             $thumbnail->setWidth($processedImageInfo['width']);
             $thumbnail->setHeight($processedImageInfo['height']);
             $thumbnail->setQuality($processedImageInfo['quality']);
+
+            if ($focalPointCropSpec instanceof FocalPointCropSpecification) {
+                $thumbnail->setFocalPointX($focalPointCropSpec->croppedFocalPoint->getX());
+                $thumbnail->setFocalPointY($focalPointCropSpec->croppedFocalPoint->getY());
+            }
         } catch (\Exception $exception) {
             $message = sprintf('Unable to generate thumbnail for the given image (filename: %s, SHA1: %s)', $thumbnail->getOriginalAsset()->getResource()->getFilename(), $thumbnail->getOriginalAsset()->getResource()->getSha1());
             throw new Exception\NoThumbnailAvailableException($message, 1433109654, $exception);

diff --git a/Neos.Media/Classes/Domain/Service/ThumbnailService.php b/Neos.Media/Classes/Domain/Service/ThumbnailService.php
@@ -18,13 +18,16 @@
 use Neos\Flow\Persistence\Exception\IllegalObjectTypeException;
 use Neos\Flow\Persistence\PersistenceManagerInterface;
 use Neos\Flow\ResourceManagement\ResourceManager;
+use Neos\Media\Domain\Model\Adjustment\FocalPointCropSpecification;
+use Neos\Media\Domain\Model\Adjustment\ImageDimensionCalculationHelperThingy;
 use Neos\Media\Domain\Model\AssetInterface;
 use Neos\Media\Domain\Model\FocalPointSupportInterface;
 use Neos\Media\Domain\Model\ImageInterface;
 use Neos\Media\Domain\Model\Thumbnail;
 use Neos\Media\Domain\Model\ThumbnailConfiguration;
 use Neos\Media\Domain\Repository\ThumbnailRepository;
 use Neos\Media\Exception\ThumbnailServiceException;
+use Neos\Media\Imagine\Box;
 use Neos\Utility\Arrays;
 use Neos\Utility\MediaTypes;
 use Psr\Log\LoggerInterface;
@@ -85,6 +88,12 @@ class ThumbnailService
      */
     protected $throwableStorage;
 
+    /**
+     * @var ImageDimensionCalculationHelperThingy
+     * @Flow\Inject
+     */
+    protected $imageDimensionCalculationHelperThingy;
+
     /**
      * Returns a thumbnail of the given asset
      *
@@ -148,15 +157,38 @@ public function getThumbnail(AssetInterface $asset, ThumbnailConfiguration $conf
         if ($thumbnail === null) {
             $thumbnail = new Thumbnail($asset, $configuration);
 
-            if ($asset instanceof FocalPointSupportInterface) {
-                // @todo: needs common understanding of dimension change with resize adjustment
-                // - if a focal point was set
-                // - calculate target dimensions here
-                // - calculate new focalPointAfter transformation
-                // - store focal point in new image
-                // has to work closely with: Packages/Neos/Neos.Media/Classes/Domain/Model/ThumbnailGenerator/ImageThumbnailGenerator.php:58
-                $thumbnail->setFocalPointX($asset->getFocalPointX() ? $asset->getFocalPointX() + 1 : null);
-                $thumbnail->setFocalPointY($asset->getFocalPointY() ? $asset->getFocalPointY() + 1 : null);
+            // predict dimensions async image thumbnails, this is not needed for immediately calculated images as those
+            // values are stored again after calculating
+            if ($async === true && $asset instanceof ImageInterface) {
+
+                $originalDimensions = new Box($asset->getWidth(), $asset->getHeight());
+
+                $requestedDimensions = ImageDimensionCalculationHelperThingy::calculateRequestedDimensions(
+                    originalDimensions: $originalDimensions,
+                    width: $configuration->getWidth(),
+                    maximumWidth: $configuration->getMaximumWidth(),
+                    height: $configuration->getHeight(),
+                    maximumHeight: $configuration->getMaximumHeight(),
+                    ratioMode: $configuration->getRatioMode(),
+                    allowUpScaling: $configuration->isUpScalingAllowed()
+                );
+
+                $thumbnail->setWidth($requestedDimensions->getWidth());
+                $thumbnail->setHeight($requestedDimensions->getHeight());
+
+                // calculate focal point for new thumbnails
+                if ($asset instanceof FocalPointSupportInterface && $asset->hasFocalPoint()) {
+                    $originalFocalPoint = $asset->getFocalPoint();
+
+                    $focalPointCropSpec = FocalPointCropSpecification::createFromOriginalDimensionsRequestedDimensionsAndFocalPoint(
+                        originalDimensions: $originalDimensions,
+                        originalFocalPoint: $originalFocalPoint,
+                        requestedDimensions: $requestedDimensions,
+                    );
+
+                    $thumbnail->setFocalPointX($focalPointCropSpec->croppedFocalPoint->getX());
+                    $thumbnail->setFocalPointY($focalPointCropSpec->croppedFocalPoint->getY());
+                }
             }
 
             // If the thumbnail strategy failed to generate a valid thumbnail