FEATURE: Add focal-point support for ImageVariants (crops) and Thumbnails

Neos.Media/Classes/Domain/Model/Adjustment/MarkPointAdjustment.php

@@ -0,0 +1,94 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\Media\Domain\Model\Adjustment;
+
+/*
+ * This file is part of the Neos.Media package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Imagine\Image\ImageInterface as ImagineImageInterface;
+use Imagine\Image\Point;
+use Neos\Flow\Annotations as Flow;
+use Imagine\Image\Palette;
+
+/**
+ * An adjustment to draw on circle on an image
+ * this is solely for debugging of focal points
+ * @todo remove before merging
+ *
+ * @deprecated
+ * @Flow\Entity
+ */
+class MarkPointAdjustment extends AbstractImageAdjustment
+{
+    protected $position = 99;
+
+    protected int $x;
+
+    protected int $y;
+
+    protected int $radius;
+
+    protected int $thickness = 1;
+
+    protected string $color = '#000';
+
+
+    public function setX(int $x): void
+    {
+        $this->x = $x;
+    }
+
+    public function setY(int $y): void
+    {
+        $this->y = $y;
+    }
+
+    public function setRadius(int $radius): void
+    {
+        $this->radius = $radius;
+    }
+
+    public function setThickness(int $thickness): void
+    {
+        $this->thickness = $thickness;
+    }
+
+    public function setColor(string $color): void
+    {
+        $this->color = $color;
+    }
+
+
+    public function applyToImage(ImagineImageInterface $image)
+    {
+        $palette = new Palette\RGB();
+        $color = $palette->color($this->color);
+        $image->draw()
+            ->circle(
+                new Point($this->x, $this->y),
+                $this->radius,
+                $color,
+                false,
+                $this->thickness
+            )
+        ;
+
+        return $image;
+    }
+
+    public function canBeApplied(ImagineImageInterface $image)
+    {
+        if (is_null($this->x) || is_null($this->y) || is_null($this->radius)) {
+            return false;
+        }
+        return true;
+    }
+}

Neos.Media/Classes/Domain/Model/Adjustment/ResizeDimensionCalculator.php

@@ -0,0 +1,252 @@
+<?php
+declare(strict_types=1);
+
+namespace Neos\Media\Domain\Model\Adjustment;
+
+/*
+ * This file is part of the Neos.Media package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Imagine\Image\BoxInterface;
+use Imagine\Image\Point;
+use Imagine\Image\PointInterface;
+use Neos\Media\Domain\Model\Dto\PreliminaryCropSpecification;
+use Neos\Media\Domain\Model\ImageInterface;
+use Neos\Media\Domain\ValueObject\Configuration\AspectRatio;
+use Neos\Media\Imagine\Box;
+
+/**
+ * Container for static methods to calculate the target dimensions for resizing images
+ *
+ * @see: ResizeImageAdjustment, ImageThumbnailGenerator(to calculte a preliminary crop for images with focal point),
+ *       ThumbnailService(to calculate dimensions and focal points for async thumbnails)
+ *
+ * @internal
+ */
+class ResizeDimensionCalculator
+{
+    /**
+     * @param BoxInterface $originalDimensions
+     * @param int|null $width
+     * @param int|null $height
+     * @param int|null $maximumWidth
+     * @param int|null $maximumHeight
+     * @param bool $allowUpScaling
+     * @param string $ratioMode
+     * @return BoxInterface
+     */
+    public static function calculateRequestedDimensions(
+        BoxInterface $originalDimensions,
+        ?int $width = null,
+        ?int $height = null,
+        ?int $maximumWidth = null,
+        ?int $maximumHeight = null,
+        bool $allowUpScaling = false,
+        string $ratioMode = ImageInterface::RATIOMODE_INSET
+    ): BoxInterface {
+        $newDimensions = clone $originalDimensions;
+
+        switch (true) {
+            case ($width !== null && $height !== null): // height and width are set explicitly
+                $newDimensions = self::calculateWithFixedDimensions($originalDimensions, $width, $height, $allowUpScaling, $ratioMode);
+                break;
+            case ($width !== null): // only width is set explicitly
+                $newDimensions = self::calculateScalingToWidth($originalDimensions, $width, $allowUpScaling);
+                break;
+            case ($height !== null): // only height is set explicitly
+                $newDimensions = self::calculateScalingToHeight($originalDimensions, $height, $allowUpScaling);
+                break;
+        }
+
+        // We apply maximum dimensions and scale the new dimensions proportionally down to fit into the maximum.
+        if ($maximumWidth !== null && $newDimensions->getWidth() > $maximumWidth) {
+            $newDimensions = $newDimensions->widen($maximumWidth);
+        }
+
+        if ($maximumHeight !== null && $newDimensions->getHeight() > $maximumHeight) {
+            $newDimensions = $newDimensions->heighten($maximumHeight);
+        }
+
+        return $newDimensions;
+    }
+
+    /**
+     * @param BoxInterface $originalDimensions
+     * @param integer $requestedWidth
+     * @param integer $requestedHeight
+     * @param bool $allowUpScaling
+     * @param string $ratioMode
+     * @return BoxInterface
+     */
+    protected static function calculateWithFixedDimensions(BoxInterface $originalDimensions, int $requestedWidth, int $requestedHeight, bool $allowUpScaling = false, string $ratioMode = ImageInterface::RATIOMODE_INSET): BoxInterface
+    {
+        if ($ratioMode === ImageInterface::RATIOMODE_OUTBOUND) {
+            return self::calculateOutboundBox($originalDimensions, $requestedWidth, $requestedHeight, $allowUpScaling);
+        }
+
+        $newDimensions = clone $originalDimensions;
+
+        $ratios = [
+            $requestedWidth / $originalDimensions->getWidth(),
+            $requestedHeight / $originalDimensions->getHeight()
+        ];
+
+        $ratio = min($ratios);
+        $newDimensions = $newDimensions->scale($ratio);
+
+        if ($allowUpScaling === false && $originalDimensions->contains($newDimensions) === false) {
+            return clone $originalDimensions;
+        }
+
+        return $newDimensions;
+    }
+
+    /**
+     * Calculate the final dimensions for an outbound box. usually exactly the requested width and height unless that
+     * would require upscaling and it is not allowed.
+     *
+     * @param BoxInterface $originalDimensions
+     * @param integer $requestedWidth
+     * @param integer $requestedHeight
+     * @param bool $allowUpScaling
+     * @return BoxInterface
+     */
+    protected static function calculateOutboundBox(BoxInterface $originalDimensions, int $requestedWidth, int $requestedHeight, bool $allowUpScaling): BoxInterface
+    {
+        $newDimensions = new Box($requestedWidth, $requestedHeight);
+
+        if ($allowUpScaling === true || $originalDimensions->contains($newDimensions) === true) {
+            return $newDimensions;
+        }
+
+        // We need to make sure that the new dimensions are such that no upscaling is needed.
+        $ratios = [
+            $originalDimensions->getWidth() / $requestedWidth,
+            $originalDimensions->getHeight() / $requestedHeight
+        ];
+
+        $ratio = min($ratios);
+        $newDimensions = $newDimensions->scale($ratio);
+
+        return $newDimensions;
+    }
+
+    /**
+     * Calculates new dimensions with a requested width applied. Takes upscaling into consideration.
+     *
+     * @param BoxInterface $originalDimensions
+     * @param integer $requestedWidth
+     * @param bool $allowUpScaling
+     * @return BoxInterface
+     */
+    protected static function calculateScalingToWidth(BoxInterface $originalDimensions, int $requestedWidth, bool $allowUpScaling): BoxInterface
+    {
+        if ($allowUpScaling === false && $requestedWidth >= $originalDimensions->getWidth()) {
+            return $originalDimensions;
+        }
+
+        $newDimensions = clone $originalDimensions;
+        $newDimensions = $newDimensions->widen($requestedWidth);
+
+        return $newDimensions;
+    }
+
+    /**
+     * Calculates new dimensions with a requested height applied. Takes upscaling into consideration.
+     *
+     * @param BoxInterface $originalDimensions
+     * @param integer $requestedHeight
+     * @param bool $allowUpScaling
+     * @return BoxInterface
+     */
+    protected static function calculateScalingToHeight(BoxInterface $originalDimensions, int $requestedHeight, bool $allowUpScaling): BoxInterface
+    {
+        if ($allowUpScaling === false && $requestedHeight >= $originalDimensions->getHeight()) {
+            return $originalDimensions;
+        }
+
+        $newDimensions = clone $originalDimensions;
+        $newDimensions = $newDimensions->heighten($requestedHeight);
+
+        return $newDimensions;
+    }
+
+    /**
+     * Calculates a resize dimension box that allows for outbound resize.
+     * The scaled image will be bigger than the requested dimensions in one dimension and then cropped.
+     *
+     * @param BoxInterface $imageSize
+     * @param BoxInterface $requestedDimensions
+     * @return BoxInterface
+     */
+    public static function calculateOutboundScalingDimensions(BoxInterface $imageSize, BoxInterface $requestedDimensions, string $ratioMode = ImageInterface::RATIOMODE_INSET): BoxInterface
+    {
+        if ($ratioMode === ImageInterface::RATIOMODE_OUTBOUND) {
+            $ratios = [
+                $requestedDimensions->getWidth() / $imageSize->getWidth(),
+                $requestedDimensions->getHeight() / $imageSize->getHeight()
+            ];
+
+            return $imageSize->scale(max($ratios));
+        }
+        return $requestedDimensions;
+    }
+
+    /**
+     * Calculate the informations for a preliminary crop to ensure that the given focal point stays inside the final image
+     * with the requested dimensions
+     *
+     * - The cropDimensions have the aspect of requested dimensions and have the maximal possible dimensions
+     * - The cropOffset will position the crop with the focal point as close to the center as possible
+     * - The returned focal point is the position of the focal point after the crop inside the requested dimensions
+     */
+    public static function calculatePreliminaryCropSpecification(
+        BoxInterface $originalDimensions,
+        PointInterface $originalFocalPoint,
+        BoxInterface $targetDimensions,
+    ): PreliminaryCropSpecification {
+        $originalAspect = new AspectRatio($originalDimensions->getWidth(), $originalDimensions->getHeight());
+        $targetAspect = new AspectRatio($targetDimensions->getWidth(), $targetDimensions->getHeight());
+
+        if ($originalAspect->getRatio() >= $targetAspect->getRatio()) {
+            // target-aspect is wider as original-aspect or same: use full height, width is cropped
+            $factor = $originalDimensions->getHeight() / $targetDimensions->getHeight();
+            $cropDimensions = new \Imagine\Image\Box((int)($targetDimensions->getWidth() * $factor), $originalDimensions->getHeight());
+            $cropOffsetX = $originalFocalPoint->getX() - (int)($cropDimensions->getWidth() / 2);
+            $cropOffsetXMax = $originalDimensions->getWidth() - $cropDimensions->getWidth();
+            if ($cropOffsetX < 0) {
+                $cropOffsetX = 0;
+            } elseif ($cropOffsetX > $cropOffsetXMax) {
+                $cropOffsetX = $cropOffsetXMax;
+            }
+            $cropOffset = new Point($cropOffsetX, 0);
+        } else {
+            // target-aspect is higher than original-aspect: use full width, height is cropped
+            $factor = $originalDimensions->getWidth() / $targetDimensions->getWidth();
+            $cropDimensions = new Box($originalDimensions->getWidth(), (int)($targetDimensions->getHeight() * $factor));
+            $cropOffsetY = $originalFocalPoint->getY() - (int)($cropDimensions->getHeight() / 2);
+            $cropOffsetYMax = $originalDimensions->getHeight() - $cropDimensions->getHeight();
+            if ($cropOffsetY < 0) {
+                $cropOffsetY = 0;
+            } elseif ($cropOffsetY > $cropOffsetYMax) {
+                $cropOffsetY = $cropOffsetYMax;
+            }
+            $cropOffset = new Point(0, $cropOffsetY);
+        }
+
+        return new PreliminaryCropSpecification(
+            $cropOffset,
+            $cropDimensions,
+            new Point(
+                (int)round(($originalFocalPoint->getX() - $cropOffset->getX()) / $factor),
+                (int)round(($originalFocalPoint->getY() - $cropOffset->getY()) / $factor)
+            )
+        );
+    }
+}