Graphics.php

Go to the documentation of this file.

<?php

 
namespace Depage\Graphics;

function autoload($class)
{
    if (strpos($class, __NAMESPACE__ . '\\') == 0) {
        $class = str_replace('\\', '/', str_replace(__NAMESPACE__ . '\\', '', $class));
        $file = __DIR__ . '/' . $class . '.php';
 
        if (file_exists($file)) {
            require_once($file);
        }
    }
}
 
spl_autoload_register(__NAMESPACE__ . '\autoload');

abstract class Graphics
{
    protected $input;
    protected $output;
    protected $format;
    protected $outputLockFp = null;
    protected $otherRender = false;
    protected $queue = [];
    protected $size = [];
    protected $background;
    protected $quality = '';
    protected $optimize;
    protected $optimizers;
    protected $limits = [];
    protected $inputFormat;
    protected $outputFormat;
    protected $bypass = true;
    private $oldIgnoreUserAbort = false;
    public static function factory($options = [])
    {
        $extension = (isset($options['extension'])) ? $options['extension'] : 'gd';
 
        if ($extension == 'imagick' && extension_loaded('imagick')) {
            return new Providers\Imagick($options);
        } elseif ($extension == 'im' || $extension == 'imagemagick') {
            if (isset($options['executable'])) {
                return new Providers\Imagemagick($options);
            } else {
                $executable = Graphics::which('convert');
                if ($executable == null) {
                    trigger_error("Cannot find ImageMagick, falling back to GD", E_USER_WARNING);
                } else {
                    $options['executable'] = $executable;
 
                    return new Providers\Imagemagick($options);
                }
            }
        } elseif ($extension == 'gm' || $extension == 'graphicsmagick') {
            if (isset($options['executable'])) {
                return new Providers\Graphicsmagick($options);
            } else {
                $executable = Graphics::which('gm');
                if ($executable == null) {
                    trigger_error("Cannot find GraphicsMagick, falling back to GD", E_USER_WARNING);
                } else {
                    $options['executable'] = $executable;
 
                    return new Providers\Graphicsmagick($options);
                }
            }
        }
 
        return new Providers\Gd($options);
    }

    public function __construct($options = [])
    {
        $this->background = (isset($options['background'])) ? $options['background'] : 'transparent';
        $this->quality    = (isset($options['quality'])) ? intval($options['quality']) : null;
        $this->format     = (isset($options['format'])) ? $options['format'] : null;
        $this->optimize   = (isset($options['optimize'])) ? $options['optimize'] : false;
        $this->optimizers = (isset($options['optimizers'])) ? $options['optimizers'] : [];
        $this->limits     = (isset($options['limits'])) ? $options['limits'] : [
            'memory' => "64MiB",
            'map' => "128MiB",
        ];
        if (isset($this->limits['memory'])) {
            putenv("MAGICK_MEMORY_LIMIT=" . $this->limits['memory']);
            putenv("MAGICK_LIMIT_MEMORY=" . $this->limits['memory']);
        }
        if (isset($this->limits['map'])) {
            putenv("MAGICK_MAP_LIMIT=" . $this->limits['map']);
            putenv("MAGICK_LIMIT_MAP=" . $this->limits['map']);
        }
    }

    public function canRead($ext)
    {
        return in_array($ext, ['jpg', 'jpeg', 'png', 'gif', 'webp']);
    }

    public function canWrite($ext)
    {
        return in_array($ext, ['png']);
        return in_array($ext, ['jpg', 'jpeg', 'png', 'gif', 'webp']);
    }

    public function addBackground($background): self
    {
        $this->background = $background;
 
        return $this;
    }

    public function addCrop($width, $height, $x = 0, $y = 0): self
    {
        $this->queue[] = ['crop', func_get_args()];
 
        return $this;
    }

    public function addResize($width, $height): self
    {
        $this->queue[] = ['resize', func_get_args()];
 
        return $this;
    }

    public function addThumb($width, $height): self
    {
        $this->queue[] = ['thumb', func_get_args()];
 
        return $this;
    }

    public function addThumbfill($width, $height, $centerX = 50, $centerY = 50): self
    {
        $this->queue[] = ['thumbfill', func_get_args()];
 
        return $this;
    }

    protected function escapeNumber($number): ?int
    {
        return (is_numeric($number)) ? intval($number) : null;
    }

    protected function dimensions($width, $height): array
    {
        if (!is_numeric($width) && !is_numeric($height)) {
            $width  = null;
            $height = null;
        } elseif (!is_numeric($height)) {
            $height = round(($this->size[1] / $this->size[0]) * $width);
        } elseif (!is_numeric($width)) {
            $width  = round(($this->size[0] / $this->size[1]) * $height);
        }
 
        return [$width, $height];
    }

    abstract protected function getImageSize(): array;

    protected function processQueue(): void
    {
        foreach ($this->queue as $task) {
            $action     = $task[0];
            $arguments  = array_map([$this, 'escapeNumber'], $task[1]);
 
            call_user_func_array([$this, $action], $arguments);
        }
    }

    public function render($input, $output = null): void
    {
        if (!file_exists($input)) {
            throw new Exceptions\FileNotFound();
        }
 
        $this->input        = $input;
        $this->output       = ($output == null) ? $input : $output;
        $this->inputFormat  = $this->obtainFormat($this->input);
        $this->outputFormat = ($this->format == null) ? $this->obtainFormat($this->output) : $this->format;
        $this->size         = $this->getImageSize();
        $this->otherRender  = false;
 
        $this->lock();
 
        $this->oldIgnoreUserAbort = ignore_user_abort();
        ignore_user_abort(true);
    }

    public function renderFinished()
    {
        ignore_user_abort($this->oldIgnoreUserAbort);
 
        $this->unlock();
    }

    public function optimizeImage($filename)
    {
        if (!file_exists($filename)) {
            return false;
        }
 
        $optimizer = new Optimizers\Optimizer($this->optimizers);
        $success = $optimizer->optimize($filename);
 
        return $success;
    }

    protected function lock()
    {
        // set lock
        $this->outputLockFp = fopen($this->output . ".lock", 'w');
        $locked = flock($this->outputLockFp, LOCK_EX | LOCK_NB, $wouldblock);
 
        if (!$locked && $wouldblock) {
            $this->otherRender = true;
            flock($this->outputLockFp, LOCK_EX);
        }
    }

    protected function unlock()
    {
        // release lock
        if (isset($this->outputLockFp)) {
            flock($this->outputLockFp, LOCK_UN);
            unlink($this->output . ".lock");
 
            $this->outputLockFp = null;
        }
    }

    protected function obtainFormat($fileName)
    {
        $parts = explode('.', $fileName);
        $extension = strtolower(end($parts));
 
        if ($extension == 'jpeg') {
            $extension = 'jpg';
        } elseif (
            $extension != 'jpg'
            && $extension != 'png'
            && $extension != 'gif'
        ) {
            if (is_callable('getimagesize') && file_exists($fileName)) {
                $info = getimagesize($fileName);
                if (isset($info[2])) {
                    $format = $info[2];
 
                    if ($format == 1) {
                        $extension = 'gif';
                    } elseif ($format == 2) {
                        $extension = 'jpg';
                    } elseif ($format == 3) {
                        $extension = 'png';
                    }
                }
            }
        }
 
        return $extension;
    }

    public static function which($binary)
    {
        exec('which ' . $binary, $commandOutput, $returnStatus);
        if ($returnStatus === 0) {
            return $commandOutput[0];
        } else {
            return null;
        }
    }

    public function setQuality($quality)
    {
        $this->quality = $quality;
    }

    protected function getQuality()
    {
        if ($this->outputFormat == 'jpg') {
            if (
                is_numeric($this->quality)
                && $this->quality >= 0
                && $this->quality <= 100
            ) {
                $quality = $this->quality;
            } else {
                $quality = 85;
            }
        } elseif ($this->outputFormat == "webp") {
            if (
                is_numeric($this->quality)
                && $this->quality >= 0
                && $this->quality <= 100
            ) {
                $quality = $this->quality;
            } else {
                $quality = 75;
            }
        } elseif ($this->outputFormat == 'png') {
            if (
                is_numeric($this->quality)
                && $this->quality >= 0
                && $this->quality <= 95
                && $this->quality % 10 <= 5
            ) {
                $quality = sprintf("%02d", $this->quality);
            } else {
                $quality = 95;
            }
        } else {
            $quality = intval($this->quality);
        }
 
        return (string) $quality;
    }

    public function getPageNumber()
    {
        if ($this->inputFormat == "pdf") {
            return "[0]";
        } else {
            return "";
        }
    }

    protected function bypassTest($width, $height, $x = 0, $y = 0)
    {
        if (
            ($width !== null && $width < 1)
            || ($height !== null && $height < 1)
            || ($width == null && $height == null)
        ) {
            $this->unlock();
 
            throw new Exceptions\Exception('Invalid image size.');
        }
 
        $bypass = (
            $width      == $this->size[0]
            && $height  == $this->size[1]
            && $x       == 0
            && $y       == 0
        );
 
        $this->bypass = $this->bypass && $bypass;
 
        return $bypass;
    }

    protected function bypass()
    {
        if ($this->input != $this->output) {
            copy($this->input, $this->output);
        }
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker et : */