Imagemagick.php

Go to the documentation of this file.

<?php

 
namespace Depage\Graphics\Providers;

class Imagemagick extends \Depage\Graphics\Graphics
{
    protected $command = '';
    protected $executable;
    protected $timeout = 0;
    public function __construct($options = [])
    {
        parent::__construct($options);
 
        $this->executable = $options['executable'] ?? null;
        $this->timeout = $options['timeout'] ?? 0;
    }

    public function canRead($ext)
    {
        return parent::canRead($ext) || in_array($ext, ['tif', 'tiff', 'pdf', 'eps']);
    }

    protected function crop($width, $height, $x = 0, $y = 0)
    {
        if (!$this->bypassTest($width, $height, $x, $y)) {
            // '+' for positive offset (the '-' is already there)
            $x = ($x < 0) ? $x : '+' . $x;
            $y = ($y < 0) ? $y : '+' . $y;
 
            $this->command .= " -gravity NorthWest -crop {$width}x{$height}{$x}{$y}! -flatten";
            $this->size = [$width, $height];
        }
    }

    protected function resize($width, $height)
    {
        $newSize = $this->dimensions($width, $height);
 
        if (!$this->bypassTest($newSize[0], $newSize[1])) {
            $resizeAction = $this->getResizeAction($newSize[0], $newSize[1]);
 
            $this->command .= " $resizeAction {$newSize[0]}x{$newSize[1]}!";
 
            $this->size = $newSize;
        }
    }

    protected function thumb($width, $height)
    {
        if (!$this->bypassTest($width, $height)) {
            $resizeAction = $this->getResizeAction($width, $height);
 
            $this->command .= " -gravity Center $resizeAction {$width}x{$height} -extent {$width}x{$height}";
            $this->size = [$width, $height];
        }
    }

    protected function thumbfill($width, $height, $centerX = 50, $centerY = 50)
    {
        if (!$this->bypassTest($width, $height)) {
            $newSize = $this->dimensions($width, null);
            $centerX = $centerX / -100 + 0.5;
            $centerY = $centerY / -100 + 0.5;
 
            if ($newSize[1] < $height) {
                $newSize = $this->dimensions(null, $height);
                $x = round(($width - $newSize[0]) * $centerX);
                $y = 0;
            } else {
                $x = 0;
                $y = round(($height - $newSize[1]) * $centerY);
            }
            $x = ($x < 0) ? $x : '+' . $x;
            $y = ($y < 0) ? $y : '+' . $y;
 
            $resizeAction = $this->getResizeAction($width, $height);
 
            $this->command .= " -gravity Center $resizeAction {$width}x{$height}^ -extent {$width}x{$height}{$x}{$y}";
            $this->size = [$width, $height];
        }
    }

    protected function getImageSize(): array
    {
        $imageSize = false;
        if (is_callable('getimagesize')) {
            $imageSize = getimagesize($this->input);
        }
        if (!$imageSize) {
            $pageNumber = $this->getPageNumber();
            $identify       = preg_replace('/convert$/', 'identify', $this->executable);
            $command        = "{$identify} -ping -format \"%wx%h\" " . escapeshellarg($this->input) . $pageNumber;
            $escapedCommand = str_replace('!', '\!', escapeshellcmd($command));
 
            exec($escapedCommand . ' 2>&1', $commandOutput, $returnStatus);
            if ($returnStatus === 0) {
                $imageSize = explode('x', $commandOutput[0]);
            } else {
                $this->unlock();
 
                throw new \Depage\Graphics\Exceptions\Exception(implode("\n", $commandOutput));
            }
        }
 
        return $imageSize;
    }

    public function render($input, $output = null): void
    {
        parent::render($input, $output);
 
        $this->command = '';
        $this->processQueue();
 
        if ($this->otherRender && file_exists($this->output)) {
            // do nothing file is already generated
        } elseif (
            $this->bypass
            && $this->inputFormat == $this->outputFormat
        ) {
            $this->bypass();
        } else {
            $background = $this->getBackground();
            $quality    = $this->getQuality();
            $optimize   = $this->getOptimize();
            $pageNumber = $this->getPageNumber();
 
            $this->command = "{$this->executable} {$background} ( -auto-orient '+profile' '*' -auto-orient " . escapeshellarg($this->input) . "{$pageNumber}{$this->command}";
            $this->command .= " ) -colorspace sRGB -flatten {$quality}{$optimize}";
 
            $this->command .= " {$this->outputFormat}:" . escapeshellarg($this->output);
 
            $this->execCommand();
 
            if ($this->optimize) {
                $this->optimizeImage($this->output);
            }
        }
 
        parent::renderFinished();
    }

    protected function execCommand()
    {
        $command = str_replace('!', '\!', escapeshellcmd($this->command));
 
        $descriptorspec = [
            0 => ["pipe", "r"],  // stdin is a pipe that the child will read from
            1 => ["pipe", "w"],  // stdout is a pipe that the child will write to
            2 => ["pipe", "w"], // stderr is pipe that the child will write errors to
        ];
        $process = proc_open("exec " . $command, $descriptorspec, $pipes);
 
        // set pipes non blocking
        stream_set_blocking($pipes[1], false);
        stream_set_blocking($pipes[2], false);
 
        $startTime = time();
        $output = [1 => "", 2 => ""];
        $terminated = false;
 
        if (is_resource($process)) {
            // read stdin and stderr
            while (!feof($pipes[1]) && !feof($pipes[2])) {
                for ($i = 1; $i < 3; $i++) {
                    $s = fgets($pipes[$i]);
                    $output[$i] .= $s;
                }
 
                usleep(10000);
                if ($this->timeout > 0 && time() - $startTime > $this->timeout) {
                    // terminate process of takes longer than timeout
                    proc_terminate($process);
                    $terminated = true;
                }
            }
 
            for ($i = 0; $i < 3; $i++) {
                fclose($pipes[$i]);
            }
            $returnStatus = proc_close($process);
        }
 
        if ($terminated) {
            $this->unlock();
 
            throw new \Depage\Graphics\Exceptions\Exception("Conversion over timeout");
        } elseif ($returnStatus != 0) {
            $this->unlock();
 
            throw new \Depage\Graphics\Exceptions\Exception($output[2]);
        }
    }

    protected function getBackground()
    {
        $background = "-size {$this->size[0]}x{$this->size[1]}";
 
        if ($this->background[0] === '#') {
            $background .= " -background {$this->background}";
        } elseif ($this->background == 'checkerboard') {
            $background .= " -background none pattern:checkerboard";
        } else {
            if ($this->outputFormat == 'jpg') {
                $background .= " -background #FFF";
            } else {
                $background .= " -background none";
            }
        }
 
        return $background;
    }

    protected function getQuality()
    {
        if (
            $this->outputFormat == 'jpg'
            || $this->outputFormat == 'png'
            || $this->outputFormat == 'webp'
        ) {
            return '-quality ' . parent::getQuality();
        } else {
            return '';
        }
    }

    protected function getOptimize()
    {
        $param = " -strip";
 
        if ($this->outputFormat == 'jpg') {
            $param .= " -interlace Plane";
        } elseif ($this->outputFormat == 'png') {
            $param .= " -define png:format=png00";
        } elseif ($this->outputFormat == "webp" && $this->inputFormat == "png") {
            $param .= " -define webp:lossless=true -define webp:image-hint=graph";
        }
 
        return $param;
    }

    protected function getResizeAction($width, $height)
    {
        if ($width <= 160 && $height <= 160) {
            return "-thumbnail";
        } else {
            return "-resize";
        }
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker et : */