GraphicalFunctions.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Imaging;
 
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Type\File\ImageInfo;
use ‪TYPO3\CMS\Core\Utility\CommandUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
use ‪TYPO3\CMS\Core\Utility\StringUtility;
 
class ‪GraphicalFunctions
{
    public ‪$addFrameSelection = true;
 
    public ‪$gifExtension = 'gif';
 
    protected ‪$colorspace = 'RGB';
 
    protected ‪$allowedColorSpaceNames = [
        'CMY',
        'CMYK',
        'Gray',
        'HCL',
        'HSB',
        'HSL',
        'HWB',
        'Lab',
        'LCH',
        'LMS',
        'Log',
        'Luv',
        'OHTA',
        'Rec601Luma',
        'Rec601YCbCr',
        'Rec709Luma',
        'Rec709YCbCr',
        'RGB',
        'sRGB',
        'Transparent',
        'XYZ',
        'YCbCr',
        'YCC',
        'YIQ',
        'YCbCr',
        'YUV',
    ];
 
    protected array ‪$imageFileExt = ['gif', 'jpg', 'jpeg', 'png', 'tif', 'bmp', 'tga', 'pcx', 'ai', 'pdf', 'webp'];
 
    protected array ‪$webImageExt = ['gif', 'jpg', 'jpeg', 'png'];
 
    public ‪$cmds = [
        'jpg' => '',
        'jpeg' => '',
        'gif' => '',
        'png' => '',
    ];
 
    protected ‪$processorEnabled;
 
    protected ‪$mayScaleUp = true;
 
    public ‪$filenamePrefix = '';
 
    public ‪$imageMagickConvert_forceFileNameBody = '';
 
    public ‪$dontCheckForExistingTempFile = false;
 
    public ‪$alternativeOutputKey = '';
 
    public ‪$IM_commands = [];
 
    public ‪$scalecmd = '-auto-orient -geometry';
 
    protected ‪$im5fx_blurSteps = '1x2,2x2,3x2,4x3,5x3,5x4,6x4,7x5,8x5,9x5';
 
    protected ‪$im5fx_sharpenSteps = '1x2,2x2,3x2,2x3,3x3,4x3,3x4,4x4,4x5,5x5';
 
    protected ‪$pixelLimitGif = 10000;
 
    protected int ‪$jpegQuality = 85;
 
    public function ‪__construct()
    {
        $gfxConf = ‪$GLOBALS['TYPO3_CONF_VARS']['GFX'];
        if ($gfxConf['processor_colorspace'] && in_array($gfxConf['processor_colorspace'], $this->allowedColorSpaceNames, true)) {
            $this->colorspace = $gfxConf['processor_colorspace'];
        }
 
        $this->processorEnabled = (bool)$gfxConf['processor_enabled'];
        // Setting default JPG parameters:
        $this->jpegQuality = ‪MathUtility::forceIntegerInRange($gfxConf['jpg_quality'], 10, 100, 85);
        $this->addFrameSelection = (bool)$gfxConf['processor_allowFrameSelection'];
        if ($gfxConf['gdlib_png']) {
            $this->gifExtension = 'png';
        }
        $this->imageFileExt = GeneralUtility::trimExplode(',', $gfxConf['imagefile_ext']);
 
        // Boolean. This is necessary if using ImageMagick 5+.
        // Effects in Imagemagick 5+ tends to render very slowly!!
        // - therefore must be disabled in order not to perform sharpen, blurring and such.
        $this->cmds['jpg'] = $this->cmds['jpeg'] = '-colorspace ' . $this->colorspace . ' -quality ' . ‪$this->jpegQuality;
 
        // ... but if 'processor_effects' is set, enable effects
        if ($gfxConf['processor_effects']) {
            $this->cmds['jpg'] .= $this->‪v5_sharpen(10);
            $this->cmds['jpeg'] .= $this->‪v5_sharpen(10);
        }
        // Secures that images are not scaled up.
        $this->mayScaleUp = (bool)$gfxConf['processor_allowUpscaling'];
    }
 
    public function ‪v5_sharpen($factor)
    {
        $factor = ‪MathUtility::forceIntegerInRange((int)ceil($factor / 10), 0, 10);
        $sharpenArr = explode(',', ',' . $this->im5fx_sharpenSteps);
        $sharpenF = trim($sharpenArr[$factor]);
        if ($sharpenF) {
            return ' -sharpen ' . $sharpenF;
        }
        return '';
    }
 
    public function ‪v5_blur($factor)
    {
        $factor = ‪MathUtility::forceIntegerInRange((int)ceil($factor / 10), 0, 10);
        $blurArr = explode(',', ',' . $this->im5fx_blurSteps);
        $blurF = trim($blurArr[$factor]);
        if ($blurF) {
            return ' -blur ' . $blurF;
        }
        return '';
    }
 
    public function ‪randomName()
    {
        ‪GeneralUtility::mkdir_deep(‪Environment::getVarPath() . '/transient/');
        return ‪Environment::getVarPath() . '/transient/' . md5(‪StringUtility::getUniqueId());
    }
 
    /***********************************
     *
     * Scaling, Dimensions of images
     *
     ***********************************/
    public function ‪imageMagickConvert($imagefile, $newExt = '', $w = '', $h = '', $params = '', $frame = '', $options = [], $mustCreate = false)
    {
        if (!$this->processorEnabled) {
            // Returning file info right away
            return $this->‪getImageDimensions($imagefile);
        }
        $info = $this->‪getImageDimensions($imagefile);
        if (!$info) {
            return null;
        }
 
        $newExt = strtolower(trim($newExt));
        // If no extension is given the original extension is used
        if (!$newExt) {
            $newExt = $info[2];
        }
        if ($newExt === 'web') {
            if (in_array($info[2], $this->webImageExt, true)) {
                $newExt = $info[2];
            } else {
                $newExt = $this->‪gif_or_jpg($info[2], $info[0], $info[1]);
                if (!$params) {
                    $params = $this->cmds[$newExt];
                }
            }
        }
        if (!in_array($newExt, $this->imageFileExt, true)) {
            return null;
        }
 
        $data = $this->‪getImageScale($info, $w, $h, $options);
        $w = $data['origW'];
        $h = $data['origH'];
        // If no conversion should be performed
        // this flag is TRUE if the width / height does NOT dictate
        // the image to be scaled!! (that is if no width / height is
        // given or if the destination w/h matches the original image
        // dimensions or if the option to not scale the image is set)
        $noScale = !$w && !$h || $data[0] == $info[0] && $data[1] == $info[1] || !empty($options['noScale']);
        if ($noScale && !$data['crs'] && !$params && !$frame && $newExt == $info[2] && !$mustCreate) {
            // Set the new width and height before returning,
            // if the noScale option is set
            if (!empty($options['noScale'])) {
                $info[0] = $data[0];
                $info[1] = $data[1];
            }
            $info[3] = $imagefile;
            return $info;
        }
        $info[0] = $data[0];
        $info[1] = $data[1];
        $frame = $this->addFrameSelection ? (int)$frame : 0;
        if (!$params) {
            $params = $this->cmds[$newExt] ?? '';
        }
        // Cropscaling:
        if ($data['crs']) {
            if (!$data['origW']) {
                $data['origW'] = $data[0];
            }
            if (!$data['origH']) {
                $data['origH'] = $data[1];
            }
            $offsetX = (int)(($data[0] - $data['origW']) * ($data['cropH'] + 100) / 200);
            $offsetY = (int)(($data[1] - $data['origH']) * ($data['cropV'] + 100) / 200);
            $params .= ' -crop ' . $data['origW'] . 'x' . $data['origH'] . '+' . $offsetX . '+' . $offsetY . '! +repage';
        }
        // start with the default scale command
 
        // check if we should use -sample or -geometry
        if ($options['sample'] ?? false) {
            $command = '-auto-orient -sample';
        } else {
            $command = ‪$this->scalecmd;
        }
        $command .= ' ' . $info[0] . 'x' . $info[1] . '! ' . $params . ' ';
        // re-apply colorspace-setting for the resulting image so colors don't appear to dark (sRGB instead of RGB)
        $command .= ' -colorspace ' . ‪$this->colorspace;
        $cropscale = $data['crs'] ? 'crs-V' . $data['cropV'] . 'H' . $data['cropH'] : '';
        if ($this->alternativeOutputKey) {
            $theOutputName = md5($command . $cropscale . ‪PathUtility::basename($imagefile) . $this->alternativeOutputKey . '[' . $frame . ']');
        } else {
            $theOutputName = md5($command . $cropscale . $imagefile . filemtime($imagefile) . '[' . $frame . ']');
        }
        if ($this->imageMagickConvert_forceFileNameBody) {
            $theOutputName = ‪$this->imageMagickConvert_forceFileNameBody;
            $this->imageMagickConvert_forceFileNameBody = '';
        }
        // Making the temporary filename
        ‪GeneralUtility::mkdir_deep(‪Environment::getPublicPath() . '/typo3temp/assets/images/');
        ‪$output = ‪Environment::getPublicPath() . '/typo3temp/assets/images/' . $this->filenamePrefix . $theOutputName . '.' . $newExt;
        if ($this->dontCheckForExistingTempFile || !file_exists(‪$output)) {
            $this->‪imageMagickExec($imagefile, ‪$output, $command, $frame);
        }
        if (file_exists(‪$output)) {
            $info[3] = ‪$output;
            $info[2] = $newExt;
            // params might change some image data!
            if ($params) {
                $info = $this->‪getImageDimensions($info[3]);
            }
            return $info;
        }
        return null;
    }
 
    public function ‪crop(string $imageFile, string $targetFileExtension, string $cropInformation): ?array
    {
        // check if it is a json object
        $cropData = json_decode($cropInformation);
        if ($cropData) {
            $offsetLeft = (int)($cropData->x ?? 0);
            $offsetTop = (int)($cropData->y ?? 0);
            $newWidth = (int)($cropData->width ?? 0);
            $newHeight = (int)($cropData->height ?? 0);
        } else {
            [$offsetLeft, $offsetTop, $newWidth, $newHeight] = explode(',', $cropInformation, 4);
        }
 
        return $this->‪imageMagickConvert(
            $imageFile,
            $targetFileExtension,
            '',
            '',
            sprintf('-crop %dx%d+%d+%d +repage -quality %d', $newWidth, $newHeight, $offsetLeft, $offsetTop, $this->jpegQuality),
            '',
            ['noScale' => true],
            true
        );
    }
 
    public function ‪mask(string $inputFile, string $outputFile, string $maskImage, string $maskBackgroundImage, string $params)
    {
        $tmpStr = $this->‪randomName();
        //  m_mask
        $intermediateMaskFile = $tmpStr . '_mask.png';
        $this->‪imageMagickExec($maskImage, $intermediateMaskFile, $params);
        //  m_bgImg
        $intermediateMaskBackgroundFile = $tmpStr . '_bgImg.miff';
        $this->‪imageMagickExec($maskBackgroundImage, $intermediateMaskBackgroundFile, $params);
        // The image onto the background
        $this->‪combineExec($intermediateMaskBackgroundFile, $inputFile, $intermediateMaskFile, $outputFile);
        // Unlink the temp-images...
        @unlink($intermediateMaskFile);
        @unlink($intermediateMaskBackgroundFile);
    }
 
    public function ‪getImageDimensions($imageFile)
    {
        preg_match('/([^\\.]*)$/', $imageFile, $reg);
        if (!file_exists($imageFile)) {
            return null;
        }
        // @todo: check if we actually need this, ass ImageInfo deals with this much more professionally
        if (!in_array(strtolower($reg[0]), $this->imageFileExt, true)) {
            return null;
        }
        $imageInfoObject = GeneralUtility::makeInstance(ImageInfo::class, $imageFile);
        if ($imageInfoObject->isFile() && $imageInfoObject->getWidth()) {
            return [
                $imageInfoObject->getWidth(),
                $imageInfoObject->getHeight(),
                $imageInfoObject->getExtension(),
                $imageFile,
            ];
        }
        return null;
    }
 
    public function ‪getImageScale($info, $w, $h, $options)
    {
        $out = [];
        $max = str_contains($w . $h, 'm') ? 1 : 0;
        if (str_contains($w . $h, 'c')) {
            $out['cropH'] = (int)substr((string)strstr((string)$w, 'c'), 1);
            $out['cropV'] = (int)substr((string)strstr((string)$h, 'c'), 1);
            $crs = true;
        } else {
            $crs = false;
        }
        $out['crs'] = $crs;
        $w = (int)$w;
        $h = (int)$h;
        // If there are max-values...
        if (!empty($options['maxW'])) {
            // If width is given...
            if ($w) {
                if ($w > $options['maxW']) {
                    $w = $options['maxW'];
                    // Height should follow
                    $max = 1;
                }
            } else {
                if ($info[0] > $options['maxW']) {
                    $w = $options['maxW'];
                    // Height should follow
                    $max = 1;
                }
            }
        }
        if (!empty($options['maxH'])) {
            // If height is given...
            if ($h) {
                if ($h > $options['maxH']) {
                    $h = $options['maxH'];
                    // Height should follow
                    $max = 1;
                }
            } else {
                // Changed [0] to [1] 290801
                if ($info[1] > $options['maxH']) {
                    $h = $options['maxH'];
                    // Height should follow
                    $max = 1;
                }
            }
        }
        $out['origW'] = $w;
        $out['origH'] = $h;
        $out['max'] = $max;
        if (!$this->mayScaleUp) {
            if ($w > $info[0]) {
                $w = $info[0];
            }
            if ($h > $info[1]) {
                $h = $info[1];
            }
        }
        // If scaling should be performed. Check that input "info" array will not cause division-by-zero
        if (($w || $h) && $info[0] && $info[1]) {
            if ($w && !$h) {
                $info[1] = (int)ceil($info[1] * ($w / $info[0]));
                $info[0] = $w;
            }
            if (!$w && $h) {
                $info[0] = (int)ceil($info[0] * ($h / $info[1]));
                $info[1] = $h;
            }
            if ($w && $h) {
                if ($max) {
                    $ratio = $info[0] / $info[1];
                    if ($h * $ratio > $w) {
                        $h = (int)round($w / $ratio);
                    } else {
                        $w = (int)round($h * $ratio);
                    }
                }
                if ($crs) {
                    $ratio = $info[0] / $info[1];
                    if ($h * $ratio < $w) {
                        $h = (int)round($w / $ratio);
                    } else {
                        $w = (int)round($h * $ratio);
                    }
                }
                $info[0] = $w;
                $info[1] = $h;
            }
        }
        $out[0] = $info[0];
        $out[1] = $info[1];
        // Set minimum-measures!
        if (isset($options['minW']) && $out[0] < $options['minW']) {
            if (($max || $crs) && $out[0]) {
                $out[1] = (int)round($out[1] * $options['minW'] / $out[0]);
            }
            $out[0] = $options['minW'];
        }
        if (isset($options['minH']) && $out[1] < $options['minH']) {
            if (($max || $crs) && $out[1]) {
                $out[0] = (int)round($out[0] * $options['minH'] / $out[1]);
            }
            $out[1] = $options['minH'];
        }
        return $out;
    }
 
    /***********************************
     *
     * ImageMagick API functions
     *
     ***********************************/
    public function ‪imageMagickIdentify($imagefile)
    {
        if (!$this->processorEnabled) {
            return null;
        }
 
        $result = $this->‪executeIdentifyCommandForImageFile($imagefile);
        if ($result) {
            [$width, $height, $fileExtension, $fileType] = explode(' ', $result);
            if ((int)$width && (int)$height) {
                return [$width, $height, strtolower($fileExtension), $imagefile, strtolower($fileType)];
            }
        }
        return null;
    }
 
    protected function ‪executeIdentifyCommandForImageFile(string $imageFile): ?string
    {
        $frame = $this->addFrameSelection ? 0 : null;
        $cmd = ‪CommandUtility::imageMagickCommand(
            'identify',
            '-format "%w %h %e %m" ' . ‪ImageMagickFile::fromFilePath($imageFile, $frame)
        );
        $returnVal = [];
        ‪CommandUtility::exec($cmd, $returnVal);
        $result = array_pop($returnVal);
        $this->IM_commands[] = ['identify', $cmd, $result];
        return $result;
    }
 
    public function ‪imageMagickExec($input, ‪$output, $params, $frame = 0)
    {
        if (!$this->processorEnabled) {
            return '';
        }
        // If addFrameSelection is set in the Install Tool, a frame number is added to
        // select a specific page of the image (by default this will be the first page)
        $frame = $this->addFrameSelection ? (int)$frame : null;
        $cmd = ‪CommandUtility::imageMagickCommand(
            'convert',
            $params
                . ' ' . ‪ImageMagickFile::fromFilePath($input, $frame)
                . ' ' . CommandUtility::escapeShellArgument(‪$output)
        );
        $this->IM_commands[] = [‪$output, $cmd];
        $ret = ‪CommandUtility::exec($cmd);
        // Change the permissions of the file
        ‪GeneralUtility::fixPermissions(‪$output);
        return $ret;
    }
 
    public function ‪combineExec($input, $overlay, $mask, ‪$output)
    {
        if (!$this->processorEnabled) {
            return '';
        }
        $theMask = $this->‪randomName() . '.' . ‪$this->gifExtension;
        // +matte = no alpha layer in output
        $this->‪imageMagickExec($mask, $theMask, '-colorspace GRAY +matte');
 
        $parameters = '-compose over'
            . ' -quality ' . $this->jpegQuality
            . ' +matte '
            . ‪ImageMagickFile::fromFilePath($input) . ' '
            . ‪ImageMagickFile::fromFilePath($overlay) . ' '
            . ‪ImageMagickFile::fromFilePath($theMask) . ' '
            . CommandUtility::escapeShellArgument(‪$output);
        $cmd = ‪CommandUtility::imageMagickCommand('combine', $parameters);
        $this->IM_commands[] = [‪$output, $cmd];
        $ret = ‪CommandUtility::exec($cmd);
        // Change the permissions of the file
        ‪GeneralUtility::fixPermissions(‪$output);
        if (is_file($theMask)) {
            @unlink($theMask);
        }
        return $ret;
    }
 
    /***********************************
     *
     * Various IO functions
     *
     ***********************************/
 
    public function ‪gif_or_jpg($type, $w, $h)
    {
        if ($type === 'ai' || $w * $h < $this->pixelLimitGif) {
            return ‪$this->gifExtension;
        }
        return 'jpg';
    }
 
    public function ‪setImageFileExt(array ‪$imageFileExt): void
    {
        $this->imageFileExt = ‪$imageFileExt;
    }
 
    public function ‪getImageFileExt(): array
    {
        return ‪$this->imageFileExt;
    }
}