ImageService.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Exceptions\RangeException;
use Elgg\Filesystem\MimeTypeService;
use Elgg\Traits\Loggable;
use Imagine\Filter\Basic\Autorotate;
use Imagine\Image\Box;
use Imagine\Image\ImagineInterface;
use Imagine\Image\Point;
 
class ImageService {
    
    use Loggable;
 
    const JPEG_QUALITY = 75;
    const WEBP_QUALITY = 75;
 
    protected $imagine;
 
    public function __construct(protected Config $config, protected MimeTypeService $mimetype) {
        
        switch ($config->image_processor) {
            case 'imagick':
                if (extension_loaded('imagick')) {
                    $this->imagine = new \Imagine\Imagick\Imagine();
                    break;
                }
                
                // fallback to GD if Imagick is not loaded
            default:
                // default use GD
                $this->imagine = new \Imagine\Gd\Imagine();
                break;
        }
    }
 
    public function resize(string $source, ?string $destination = null, array $params = []): bool {
 
        $destination = $destination ?? $source;
 
        try {
            $resize_params = $this->normalizeResizeParameters($source, $params);
            
            $image = $this->imagine->open($source);
            
            $max_width = (int) elgg_extract('w', $resize_params);
            $max_height = (int) elgg_extract('h', $resize_params);
 
            $x1 = (int) elgg_extract('x1', $resize_params, 0);
            $y1 = (int) elgg_extract('y1', $resize_params, 0);
            $x2 = (int) elgg_extract('x2', $resize_params, 0);
            $y2 = (int) elgg_extract('y2', $resize_params, 0);
 
            if ($x2 > $x1 && $y2 > $y1) {
                $crop_start = new Point($x1, $y1);
                $crop_size = new Box($x2 - $x1, $y2 - $y1);
                $image->crop($crop_start, $crop_size);
            }
 
            $target_size = new Box($max_width, $max_height);
            $image->resize($target_size);
            
            // create new canvas with a background (default: white)
            $background_color = elgg_extract('background_color', $params, 'ffffff');
            $thumbnail = $this->imagine->create($image->getSize(), $image->palette()->color($background_color));
            $thumbnail->paste($image, new Point(0, 0));
 
            if (pathinfo($destination, PATHINFO_EXTENSION) === 'webp') {
                $options = [
                    'webp_quality' => elgg_extract('webp_quality', $params, self::WEBP_QUALITY),
                ];
            } else {
                $options = [
                    'format' => $this->getFileFormat($source, $params),
                    'jpeg_quality' => elgg_extract('jpeg_quality', $params, self::JPEG_QUALITY),
                ];
            }
            
            $thumbnail->save($destination, $options);
 
            unset($image);
            unset($thumbnail);
        } catch (\Exception $ex) {
            $this->getLogger()->error($ex);
 
            return false;
        }
 
        return true;
    }
    
    public function fixOrientation($filename): bool {
        try {
            $this->assertValidImageDimensions($filename);
            
            $image = $this->imagine->open($filename);
            $metadata = $image->metadata();
            if (!isset($metadata['ifd0.Orientation'])) {
                // no need to perform an orientation fix
                return true;
            }
            
            $autorotate = new Autorotate();
            $autorotate->apply($image)->save($filename);
            
            $image->strip()->save($filename);
            
            return true;
        } catch (\Exception $ex) {
            $this->getLogger()->notice($ex);
        }
        
        return false;
    }
 
    public function normalizeResizeParameters(string $source, array $params = []): array {
        $this->assertValidImageDimensions($source);
        
        $image = $this->imagine->open($source);
 
        $width = $image->getSize()->getWidth();
        $height = $image->getSize()->getHeight();
 
        $max_width = (int) elgg_extract('w', $params, 100, false);
        $max_height = (int) elgg_extract('h', $params, 100, false);
        if (!$max_height || !$max_width) {
            throw new InvalidArgumentException('Resize width and height parameters are required');
        }
 
        $square = elgg_extract('square', $params, false);
        $upscale = elgg_extract('upscale', $params, false);
 
        $x1 = (int) elgg_extract('x1', $params, 0);
        $y1 = (int) elgg_extract('y1', $params, 0);
        $x2 = (int) elgg_extract('x2', $params, 0);
        $y2 = (int) elgg_extract('y2', $params, 0);
 
        $cropping_mode = $x1 || $y1 || $x2 || $y2;
 
        if ($cropping_mode) {
            $crop_width = $x2 - $x1;
            $crop_height = $y2 - $y1;
            if ($crop_width <= 0 || $crop_height <= 0 || $crop_width > $width || $crop_height > $height) {
                throw new RangeException("Coordinates [$x1, $y1], [$x2, $y2] are invalid for image cropping");
            }
        } else {
            // everything selected if no crop parameters
            $crop_width = $width;
            $crop_height = $height;
        }
 
        // determine cropping offsets
        if ($square) {
            // asking for a square image back
            
            // size of the new square image
            $max_width = min($max_width, $max_height);
            $max_height = $max_width;
            
            // find the largest square that fits within the selected region
            $crop_width = min($crop_width, $crop_height);
            $crop_height = $crop_width;
            
            if (!$cropping_mode) {
                // place square region in the center
                $x1 = floor(($width - $crop_width) / 2);
                $y1 = floor(($height - $crop_height) / 2);
            }
        } else {
            // maintain aspect ratio of original image/crop
            if ($crop_height / $max_height > $crop_width / $max_width) {
                $max_width = floor($max_height * $crop_width / $crop_height);
            } else {
                $max_height = floor($max_width * $crop_height / $crop_width);
            }
        }
 
        if (!$upscale && ($crop_height < $max_height || $crop_width < $max_width)) {
            // we cannot upscale and selected area is too small so we decrease size of returned image
            $max_height = $crop_height;
            $max_width = $crop_width;
        }
 
        return [
            'w' => $max_width,
            'h' => $max_height,
            'x1' => $x1,
            'y1' => $y1,
            'x2' => $x1 + $crop_width,
            'y2' => $y1 + $crop_height,
            'square' => $square,
            'upscale' => $upscale,
        ];
    }
 
    protected function getFileFormat($filename, $params) {
        
        $accepted_formats = [
            'image/jpeg' => 'jpeg',
            'image/pjpeg' => 'jpeg',
            'image/png' => 'png',
            'image/x-png' => 'png',
            'image/gif' => 'gif',
            'image/vnd.wap.wbmp' => 'wbmp',
            'image/x‑xbitmap' => 'xbm',
            'image/x‑xbm' => 'xbm',
        ];
        
        // was a valid output format supplied
        $format = elgg_extract('format', $params);
        if (in_array($format, $accepted_formats)) {
            return $format;
        }
        
        try {
            return elgg_extract($this->mimetype->getMimeType($filename), $accepted_formats);
        } catch (InvalidArgumentException $e) {
            $this->getLogger()->warning($e);
        }
    }
    
    public function hasWebPSupport(): bool {
        if ($this->config->webp_enabled === false) {
            return false;
        }
        
        if ($this->imagine instanceof \Imagine\Imagick\Imagine) {
            return !empty(\Imagick::queryformats('WEBP*'));
        } elseif ($this->imagine instanceof \Imagine\Gd\Imagine) {
            return (bool) elgg_extract('WebP Support', gd_info(), false);
        }
        
        return false;
    }
    
    protected function assertValidImageDimensions(string $path): void {
        $info = getimagesize($path);
        if (!is_array($info)) {
            throw new InvalidArgumentException("Unable to read image data for '{$path}'");
        }
        
        $height = (int) elgg_extract(1, $info);
        if ($height > $this->config->image_resize_max_height) {
            throw new RangeException('Image height too large to resize');
        }
        
        $width = (int) elgg_extract(0, $info);
        if ($width > $this->config->image_resize_max_width) {
            throw new RangeException('Image width too large to resize');
        }
        
        if (($width * $height) > $this->config->image_resize_max_resolution) {
            throw new RangeException('Image resolution too large to resize');
        }
    }
}