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();
    }
}