class.ilBadgePictureMachine.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

use ILIAS\Filesystem\Stream\FileStream;
use ILIAS\ResourceStorage\Flavour\Definition\CropToSquare;
use ILIAS\ResourceStorage\Flavour\Definition\FlavourDefinition;
use ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\AbstractMachine;
use ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\CropSquare;
use ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\GdImageToStreamTrait;
use ILIAS\ResourceStorage\Flavour\Machine\Result;
use ILIAS\ResourceStorage\Information\FileInformation;
use ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\ExtractPages;
use ILIAS\ResourceStorage\Flavour\Definition\PagesToExtract;
use ILIAS\ResourceStorage\Flavour\Engine\ImagickEngine;
use ILIAS\Filesystem\Stream\Stream;

class ilBadgePictureMachine extends AbstractMachine
{
    use GdImageToStreamTrait;

    public const ID = 'badge_image_resize_machine';
    private const FULL_QUALITY_SIZE_THRESHOLD = 100;

    private CropSquare $crop;
    private ?ilBadgePictureDefinition $definition = null;
    private ?FileInformation $information = null;
    private ExtractPages $extract_pages;

    public function __construct()
    {
        parent::__construct();
        $this->extract_pages = new ExtractPages();
        $this->crop = new CropSquare();
    }

    public function getId(): string
    {
        return self::ID;
    }

    public function canHandleDefinition(FlavourDefinition $definition): bool
    {
        return $definition instanceof ilBadgePictureDefinition;
    }

    public function dependsOnEngine(): ?string
    {
        return ImagickEngine::class;
    }

    public function processStream(
        FileInformation $information,
        FileStream $stream,
        FlavourDefinition $for_definition
    ): Generator {
        $this->definition = $for_definition;
        $this->information = $information;

        $page_stream = $this->extract_pages->processStream(
            $this->information,
            $stream,
            new PagesToExtract(
                false,
                $this->definition->getWidths()['xl'],
                1,
                false,
                100
            )
        )->current()?->getStream();

        if ($page_stream === null) {
            return;
        }

        $i = 0;
        foreach ($for_definition->getWidths() as $width) {
            yield new Result(
                $for_definition,
                $this->cropImage($page_stream, $width),
                $i,
                true
            );
            $i++;
        }
    }

    protected function cropImage(
        FileStream $stream,
        int $size
    ): ?Stream {
        $quality = $size <= self::FULL_QUALITY_SIZE_THRESHOLD
            ? 100
            : $this->definition->getQuality();


        return $this->crop->processStream(
            $this->information,
            $stream,
            new CropToSquare(
                false,
                $size,
                $quality
            )
        )->current()->getStream();
    }
}