Imagick.php

<?php
 
namespace Bitrix\Main\File\Image;
 
use Bitrix\Main\File;
 
class Imagick extends Engine
{
    protected $image;
    protected $animated = false;
    protected $jpegSize;
 
    public function getExifData()
    {
        if(function_exists("exif_read_data"))
        {
            return parent::getExifData();
        }
 
        $result = [];
 
        if($this->image !== null)
        {
            $exif = $this->image->getImageProperties("exif:*");
 
            foreach($exif as $name => $property)
            {
                $result[substr($name, 5)] = $property;
            }
        }
 
        return $result;
    }
 
    public function load()
    {
        $this->clear();
 
        try
        {
            $this->image = new \Imagick();
 
            $info = $this->getInfo();
            if (!$info)
            {
                return false;
            }
 
            if ($this->exceedsMaxSize())
            {
                // the image exceeds maximum sizes, optionally substitute it
                return $this->substituteImage();
            }
 
            $needResize = false;
            if ($info->getFormat() == File\Image::FORMAT_JPEG)
            {
                // only for JPEGs
                $needResize = $this->setJpegOptions();
            }
 
            $allowAnimated = (isset($this->options["allowAnimatedImages"]) && $this->options["allowAnimatedImages"] === true);
 
            // read only the first frame
            $suffix = ($allowAnimated ? '' : '[0]');
 
            $this->image->readImage($this->file . $suffix);
 
            if ($needResize)
            {
                // JPEG memory usage optimization
                $this->image->thumbnailImage($this->jpegSize->getWidth(), $this->jpegSize->getHeight());
            }
 
            if ($allowAnimated && $this->image->getNumberImages() > 1)
            {
                $this->animated = true;
                $this->image = $this->image->coalesceImages();
            }
 
            return true;
        }
        catch (\ImagickException $e)
        {
            return false;
        }
    }
 
    protected function substituteImage()
    {
        if (isset($this->options["substImage"]))
        {
            // substitute the file with a blank image
            $substImage = new Imagick($this->options["substImage"]);
 
            if ($substImage->load())
            {
                $this->image = clone $substImage->image;
                $this->substituted = true;
 
                return true;
            }
        }
        return false;
    }
 
    protected function setJpegOptions()
    {
        $this->jpegSize = $this->getJpegSize();
 
        if ($this->jpegSize)
        {
            $source = $this->getInfo()->toRectangle();
 
            $needResize = $source->resize($this->jpegSize, File\Image::RESIZE_PROPORTIONAL);
 
            if ($needResize)
            {
                // the image is too large to fit into memory
                $this->image->setOption('jpeg:size', $this->jpegSize->getWidth() . 'x' . $this->jpegSize->getHeight());
                $this->image->setSize($this->jpegSize->getWidth(), $this->jpegSize->getHeight());
 
                return true;
            }
        }
        return false;
    }
 
    public function rotate($angle, Color $bgColor)
    {
        if ($this->image === null)
        {
            return false;
        }
 
        $color = new \ImagickPixel($bgColor->toRgba());
 
        foreach ($this->image as $frame)
        {
            $frame->rotateImage($color, $angle);
        }
 
        return true;
    }
 
    public function flipVertical()
    {
        if ($this->image === null)
        {
            return false;
        }
 
        foreach ($this->image as $frame)
        {
            $frame->flipImage();
        }
 
        return true;
    }
 
    public function flipHorizontal()
    {
        if ($this->image === null)
        {
            return false;
        }
 
        foreach ($this->image as $frame)
        {
            $frame->flopImage();
        }
 
        return true;
    }
 
    public function setOrientation($orientation)
    {
        if($this->image === null)
        {
            return false;
        }
 
        return $this->image->setImageOrientation($orientation);
    }
 
    public function resize(Rectangle $source, Rectangle $destination)
    {
        if($this->image === null)
        {
            return false;
        }
 
        //need crop
        if($source->getX() <> 0 || $source->getY() <> 0)
        {
            $this->crop($source);
        }
 
        //hope Imagick will use the best filter automatically
        $filter = \Imagick::FILTER_UNDEFINED;
 
        foreach ($this->image as $frame)
        {
            //resizeImage has better quality than scaleImage (scaleImage uses a filter similar to FILTER_BOX)
            $frame->resizeImage($destination->getWidth(), $destination->getHeight(), $filter, 1);
        }
 
        return true;
    }
 
    public function crop(Rectangle $source)
    {
        if($this->image === null)
        {
            return false;
        }
 
        $this->image->setImagePage(0, 0, 0, 0);
 
        foreach ($this->image as $frame)
        {
            $frame->cropImage($source->getWidth(), $source->getHeight(), $source->getX(), $source->getY());
        }
 
        return true;
    }
 
    public function filter(Mask $mask)
    {
        if($this->image === null)
        {
            return false;
        }
 
        $imVersion = \Imagick::getVersion();
        if ($imVersion['versionNumber'] < 0x700 || phpversion('imagick') < '3.4.0')
        {
            $this->image->convolveImage($mask->getVector());
        }
        else
        {
            $kernel = \ImagickKernel::fromMatrix($mask->getValue());
            $this->image->convolveImage($kernel);
        }
 
        return true;
    }
 
    public function drawTextWatermark(TextWatermark $watermark)
    {
        if($this->image === null)
        {
            return false;
        }
 
        $font = $watermark->getFont();
 
        if(!file_exists($font))
        {
            return false;
        }
 
        $utfText = $watermark->getUtfText();
 
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        $draw = new \ImagickDraw();
        $draw->setFont($font);
        $draw->setFillColor(new \ImagickPixel($watermark->getColor()->toRgba()));
 
        if(($textWidth = $watermark->getWidth()) > 0)
        {
            $draw->setFontSize(20);
 
            $metrics = $this->image->queryFontMetrics($draw, $utfText);
 
            $scale = 1.0;
            if($metrics["textWidth"] > 0)
            {
                $scale = $textWidth / $metrics["textWidth"];
            }
 
            $fontSize = 20 * $scale;
            $draw->setFontSize($fontSize);
 
            $position = new Rectangle($textWidth, $metrics["textHeight"] * $scale);
        }
        else
        {
            //in GD resolution is 96 dpi, we should increase size
            $fontSize = $watermark->getFontSize($width) * (96/72);
            $draw->setFontSize($fontSize);
 
            $metrics = $this->image->queryFontMetrics($draw, $utfText);
 
            $position = new Rectangle($metrics["textWidth"], $metrics["textHeight"]);
        }
 
        $watermark->alignPosition($width, $height, $position);
 
        $fontSize *= (72/90); //back to pixels
 
        if($watermark->getVerticalAlignment() == Watermark::ALIGN_BOTTOM)
        {
            //Try to take into consideration font's descenders.
            //Coordinates in annotateImage are for font's *baseline*.
            //Let the descenders be 20% of the font size.
            $descender = $fontSize * 0.2;
            $y = $position->getY() + $position->getHeight() - $descender; //baseline
        }
        else
        {
            $y = $position->getY() + $fontSize;
        }
 
        return $this->image->annotateImage($draw, $position->getX(), $y, 0, $utfText);
    }
 
    public function drawImageWatermark(ImageWatermark $watermark)
    {
        if($this->image === null)
        {
            return false;
        }
 
        if(($image = $this->loadWatermark($watermark)) === null)
        {
            return false;
        }
 
        $watermarkWidth = $image->getWidth();
        $watermarkHeight = $image->getHeight();
 
        $position = new Rectangle($watermarkWidth, $watermarkHeight);
 
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        $watermark->alignPosition($width, $height, $position);
 
        $watermarkAlpha = $watermark->getAlpha();
 
        if(intval(round($watermarkAlpha, 2)) < 1) //1% precision
        {
            //apply alpha to the watermark
            $image->image->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $watermarkAlpha, \Imagick::CHANNEL_ALPHA);
        }
 
        $repeat = ($watermark->getMode() == ImageWatermark::MODE_REPEAT);
 
        $posY = $position->getY();
        while(true)
        {
            $posX = $position->getX();
            while(true)
            {
                $this->image->compositeImage($image->image, \Imagick::COMPOSITE_OVER, $posX, $posY);
 
                $posX += $watermarkWidth;
                if($repeat == false || $posX > $width)
                {
                    break;
                }
            }
 
            $posY += $watermarkHeight;
            if($repeat == false || $posY > $height)
            {
                break;
            }
        }
 
        $image->clear();
 
        return true;
    }
 
    public function save($file, $quality = 95, $format = null)
    {
        if ($this->image === null)
        {
            return false;
        }
 
        $prefix = "";
        if ($format !== null)
        {
            $format = static::convertFormat($format);
            if($format !== null)
            {
                $prefix = "{$format}:";
            }
        }
 
        $this->image->setImageCompressionQuality($quality);
 
        if ($format === "gif" || ($format = $this->image->getImageFormat()) === "GIF" || $format === "GIF87")
        {
            //strange artefacts with transparency - we limit the palette to 255 colors to fix it
            $this->image->quantizeImage(255, \Imagick::COLORSPACE_SRGB, 0, false, false);
        }
 
        if ($this->animated)
        {
            return $this->image->deconstructImages()->writeImages($prefix.$file, true);
        }
        else
        {
            return $this->image->writeImage($prefix.$file);
        }
    }
 
    public function getWidth()
    {
        return $this->image->getImageWidth();
    }
 
    public function getHeight()
    {
        return $this->image->getImageHeight();
    }
 
    public function clear()
    {
        if($this->image !== null)
        {
            $this->image->clear();
            $this->image = null;
            $this->animated = false;
            $this->jpegSize = null;
        }
    }
 
    protected static function convertFormat($format)
    {
        static $formats = [
            File\Image::FORMAT_BMP => "bmp",
            File\Image::FORMAT_GIF => "gif",
            File\Image::FORMAT_JPEG => "jpg",
            File\Image::FORMAT_PNG => "png",
            File\Image::FORMAT_WEBP => "webp",
        ];
 
        if(isset($formats[$format]))
        {
            return $formats[$format];
        }
        return null;
    }
 
    protected function getJpegSize()
    {
        if (isset($this->options["jpegLoadSize"]) && is_array($this->options["jpegLoadSize"]))
        {
            return new Rectangle($this->options["jpegLoadSize"][0], $this->options["jpegLoadSize"][1]);
        }
 
        return null;
    }
}