Gd.php

См. документацию.

<?php
 
namespace Bitrix\Main\File\Image;
 
use Bitrix\Main\File;
 
class Gd extends Engine
{
    protected $resource;
    protected $format;

    public function load()
    {
        $this->clear();
 
        $info = $this->getInfo();
 
        if ($info && $info->isSupported())
        {
            $this->format = $info->getFormat();
            $resource = null;
 
            switch ($this->format)
            {
                case File\Image::FORMAT_GIF:
                    $resource = imagecreatefromgif($this->file);
                    break;
                case File\Image::FORMAT_PNG:
                    $resource = imagecreatefrompng($this->file);
                    break;
                case File\Image::FORMAT_WEBP:
                    $resource = imagecreatefromwebp($this->file);
                    break;
                case File\Image::FORMAT_BMP:
                    $resource = imagecreatefrombmp($this->file);
                    break;
                case File\Image::FORMAT_JPEG:
                    ini_set('gd.jpeg_ignore_warning', 1);
                    $resource = imagecreatefromjpeg($this->file);
                    break;
            }
 
            if ($resource)
            {
                $this->resource = $resource;
                return true;
            }
        }
        return false;
    }

    public function rotate($angle, Color $bgColor)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        $angle = 360 - $angle;
        $alpha = (1.0 - $bgColor->getAlpha()) * 127;
        $color = imagecolorallocatealpha($this->resource, $bgColor->getRed(), $bgColor->getGreen(), $bgColor->getBlue(), $alpha);
 
        $resource = imagerotate($this->resource, $angle, $color);
 
        if ($resource === false)
        {
            return false;
        }
 
        $this->clear();
        $this->resource = $resource;
 
        return true;
    }

    public function flipVertical()
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        return imageflip($this->resource, IMG_FLIP_VERTICAL);
    }

    public function flipHorizontal()
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        return imageflip($this->resource, IMG_FLIP_HORIZONTAL);
    }

    public function setOrientation($orientation)
    {
        // not implemented
        return true;
    }

    public function resize(Rectangle $source, Rectangle $destination)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        $destinationWidth = $destination->getWidth();
        $destinationHeight = $destination->getHeight();
 
        if (($picture = imagecreatetruecolor($destinationWidth, $destinationHeight)))
        {
            $transparentColor = -1;
 
            imagealphablending($picture, false);
 
            if ($this->format == File\Image::FORMAT_PNG || $this->format == File\Image::FORMAT_WEBP)
            {
                $color = imagecolorallocatealpha($picture, 0, 0, 0, 127);
                imagefilledrectangle($picture, 0, 0, $destinationWidth, $destinationHeight, $color);
            }
            elseif ($this->format == File\Image::FORMAT_GIF)
            {
                // save transparency
                $transparentColor = $this->getTransparentColor();
                if ($transparentColor >= 0)
                {
                    $rgb = imagecolorsforindex($this->resource, $transparentColor);
                    $transparentColor = imagecolorallocatealpha($picture, $rgb['red'], $rgb['green'], $rgb['blue'], 127);
                    imagefilledrectangle($picture, 0, 0, $destinationWidth, $destinationHeight, $transparentColor);
                }
            }
 
            if (imagecopyresampled($picture, $this->resource, 0, 0, $source->getX(), $source->getY(), $destinationWidth, $destinationHeight, $source->getWidth(), $source->getHeight()))
            {
                $this->clear();
                $this->resource = $picture;
 
                // restore transparency
                if ($transparentColor >= 0)
                {
                    $this->restoreTransparency($transparentColor);
                }
 
                return true;
            }
        }
        return false;
    }

    public function blur(int $sigma): bool
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        $sigma = max(1, min(100, round($sigma)));
 
        $originalWidth = $this->getWidth();
        $originalHeight = $this->getHeight();
 
        $minScale = 0.5;
        $smallestWidth = ceil($originalWidth * (1 - pow($minScale, 1.0 / $sigma)));
        $smallestHeight = ceil($originalHeight * (1 - pow($minScale, 1.0 / $sigma)));
 
        $prevImage = $this->resource;
        $prevWidth = $originalWidth;
        $prevHeight = $originalHeight;
        $nextImage = $this->resource;
        $nextWidth = 0;
        $nextHeight = 0;
 
        for ($i = 1; $i <= $sigma; $i += 1)
        {
            $denominator = (1 - pow($minScale, 1.0 / $i));
            $nextWidth = (int)round($smallestWidth / $denominator);
            $nextHeight = (int)round($smallestHeight / $denominator);
            $nextImage = imagecreatetruecolor($nextWidth, $nextHeight);
            if ($this->format == File\Image::FORMAT_PNG || $this->format == File\Image::FORMAT_WEBP)
            {
                imagealphablending($nextImage, false);
                imagesavealpha($nextImage, true);
            }
 
            imagecopyresampled($nextImage, $prevImage, 0, 0, 0, 0, $nextWidth, $nextHeight, $prevWidth, $prevHeight);
            imagefilter($nextImage, IMG_FILTER_GAUSSIAN_BLUR);
            if ($prevImage !== $this->resource)
            {
                imagedestroy($prevImage);
            }
 
            $prevImage = $nextImage;
            $prevWidth = $nextWidth;
            $prevHeight = $nextHeight;
        }
 
        if ($this->format == File\Image::FORMAT_PNG || $this->format == File\Image::FORMAT_WEBP)
        {
            imagealphablending($this->resource, false);
            imagesavealpha($this->resource, true);
        }
 
        imagecopyresampled($this->resource, $nextImage, 0, 0, 0, 0, $originalWidth, $originalHeight, $nextWidth, $nextHeight);
        imagefilter($this->resource, IMG_FILTER_GAUSSIAN_BLUR);
        if ($nextImage !== $this->resource)
        {
            imagedestroy($nextImage);
        }
 
        return true;
    }

    public function filter(Mask $mask)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        $transparentColor = -1;
        if ($this->format == File\Image::FORMAT_GIF)
        {
            // Process transparency for GIFs
            $transparentColor = $this->getTransparentColor();
        }
 
        // Fix left top corner
        $newPixel = $this->calculatePixel($mask, 0, 0);
 
        $result = imageconvolution($this->resource, $mask->getValue(), 1, 0);
 
        if ($result)
        {
            // Fix left top corner
            imagealphablending($this->resource, false);
            imagesetpixel($this->resource, 0, 0, $newPixel);
 
            // restore transparency
            if ($transparentColor >= 0)
            {
                $this->restoreTransparency($transparentColor);
            }
        }
        return $result;
    }
 
    protected function getTransparentColor(): int
    {
        $transparentColor = imagecolortransparent($this->resource);
        if ($transparentColor < 0 || $transparentColor >= imagecolorstotal($this->resource))
        {
            return -1;
        }
        return $transparentColor;
    }
 
    protected function restoreTransparency($transparentColor)
    {
        imagecolortransparent($this->resource, $transparentColor);
 
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        for ($y = 0; $y < $height; ++$y)
        {
            for ($x = 0; $x < $width; ++$x)
            {
                if (((imagecolorat($this->resource, $x, $y) >> 24) & 0x7F) >= 100)
                {
                    imagesetpixel($this->resource,  $x, $y, $transparentColor);
                }
            }
        }
    }

    protected function calculatePixel($mask, $x, $y)
    {
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        $alpha = (imagecolorat($this->resource, $x, $y) >> 24) & 0xFF;
        $newR = $newG = $newB = 0;
 
        for ($j = 0; $j < 3; ++$j)
        {
            $yv = $y - 1 + $j;
            if ($yv < 0)
            {
                $yv = 0;
            }
            elseif ($yv >= $height)
            {
                $yv = $height - 1;
            }
 
            for ($i = 0; $i < 3; ++$i)
            {
                $xv = $x - 1 + $i;
                if ($xv < 0)
                {
                    $xv = 0;
                }
                elseif ($xv >= $width)
                {
                    $xv = $width - 1;
                }
 
                $m = $mask[$j][$i];
                $rgb = imagecolorat($this->resource, $xv, $yv);
 
                $newR += (($rgb >> 16) & 0xFF) * $m;
                $newG += (($rgb >> 8) & 0xFF) * $m;
                $newB += ($rgb & 0xFF) * $m;
            }
        }
 
        $newR = ($newR > 255 ? 255 : ($newR < 0 ? 0 : $newR));
        $newG = ($newG > 255 ? 255 : ($newG < 0 ? 0 : $newG));
        $newB = ($newB > 255 ? 255 : ($newB < 0 ? 0 : $newB));
 
        return imagecolorallocatealpha($this->resource, $newR, $newG, $newB, $alpha);
    }

    public function drawTextWatermark(TextWatermark $watermark)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        $font = $watermark->getFont();
 
        if (!file_exists($font))
        {
            return false;
        }
 
        $utfText = $watermark->getUtfText();
 
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        if (($textWidth = $watermark->getWidth()) > 0)
        {
            $textBox = imagettfbbox(20, 0, $font, $utfText);
            if (!is_array($textBox))
            {
                return false;
            }
 
            $scale = $textWidth / ($textBox[2] - $textBox[0]);
            $fontSize = 20 * $scale;
 
            $position = new Rectangle($textWidth, ($textBox[0] - $textBox[7]) * $scale);
        }
        else
        {
            $fontSize = $watermark->getFontSize($width);
 
            $textBox = imagettfbbox($fontSize, 0, $font, $utfText);
 
            $position = new Rectangle(($textBox[2] - $textBox[0]), ($textBox[0] - $textBox[7]));
        }
 
        $watermark->alignPosition($width, $height, $position);
 
        $color = $watermark->getColor();
        $textColor = imagecolorallocate($this->resource, $color->getRed(), $color->getGreen(), $color->getBlue());
 
        if ($watermark->getVerticalAlignment() == Watermark::ALIGN_BOTTOM)
        {
            // Try to take into consideration font's descenders.
            // Coordinates in imagettftext 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; // baseline
        }
 
        $result = imagettftext($this->resource, $fontSize, 0, $position->getX(), $y, $textColor, $font, $utfText);
 
        return ($result !== false);
    }

    public function drawImageWatermark(ImageWatermark $watermark)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        if (($image = $this->loadWatermark($watermark)) === null)
        {
            return false;
        }
 
        $width = $this->getWidth();
        $height = $this->getHeight();
 
        $watermarkWidth = $image->getWidth();
        $watermarkHeight = $image->getHeight();
 
        $position = new Rectangle($watermarkWidth, $watermarkHeight);
 
        $watermark->alignPosition($width, $height, $position);
 
        $watermarkX = $position->getX();
        $watermarkY = $position->getY();
 
        $watermarkAlpha = $watermark->getAlpha();
        $repeat = ($watermark->getMode() == ImageWatermark::MODE_REPEAT);
 
        for ($y = 0; $y < $watermarkHeight; $y++)
        {
            for ($x = 0; $x < $watermarkWidth; $x++)
            {
                $posY = $watermarkY + $y;
                while (true)
                {
                    $posX = $watermarkX + $x;
                    while (true)
                    {
                        $alpha = $watermarkAlpha;
 
                        $mainRgb = imagecolorsforindex($this->resource, imagecolorat($this->resource, $posX, $posY));
                        $watermarkRgb = imagecolorsforindex($image->resource, imagecolorat($image->resource, $x, $y));
 
                        if ($watermarkRgb['alpha'] == 127)
                        {
                            $pixel = $mainRgb;
                        }
                        else
                        {
                            if ($watermarkRgb['alpha'])
                            {
                                $alpha = round((( 127 - $watermarkRgb['alpha']) / 127), 2);
                                $alpha = $alpha * $watermarkAlpha;
                            }
 
                            $pixel = [];
                            foreach (['red', 'green', 'blue', 'alpha'] as $k)
                            {
                                $pixel[$k] = round(($mainRgb[$k] * (1 - $alpha)) + ($watermarkRgb[$k] * $alpha));
                            }
                        }
 
                        $color = imagecolorexactalpha($this->resource, $pixel['red'], $pixel['green'], $pixel['blue'], $pixel['alpha']);
                        if ($color == -1)
                        {
                            $color = imagecolorallocatealpha($this->resource, $pixel['red'], $pixel['green'], $pixel['blue'], $pixel['alpha']);
                            if ($color === false)
                            {
                                $color = imagecolorclosestalpha($this->resource, $pixel['red'], $pixel['green'], $pixel['blue'], $pixel['alpha']);
                            }
                        }
 
                        imagesetpixel($this->resource, $posX, $posY, $color);
 
                        $posX += $watermarkWidth;
 
                        if (!$repeat || $posX > $width)
                        {
                            break;
                        }
                    }
 
                    $posY += $watermarkHeight;
 
                    if (!$repeat || $posY > $height)
                    {
                        break;
                    }
                }
            }
        }
 
        $image->clear();
 
        return true;
    }

    public function save($file, $quality = 95, $format = null)
    {
        if ($this->resource === null)
        {
            return false;
        }
 
        if ($format === null)
        {
            $format = $this->format;
        }
 
        $result = false;
 
        switch ($format)
        {
            case File\Image::FORMAT_GIF:
                $result = imagegif($this->resource, $file);
                break;
            case File\Image::FORMAT_PNG:
                imagealphablending($this->resource, true);
                imagesavealpha($this->resource, true);
                $result = imagepng($this->resource, $file);
                break;
            case File\Image::FORMAT_WEBP:
                imagealphablending($this->resource, true);
                imagesavealpha($this->resource, true);
                $result = imagewebp($this->resource, $file, $quality);
                break;
            case File\Image::FORMAT_BMP:
                $result = imagebmp($this->resource, $file);
                break;
            case File\Image::FORMAT_JPEG:
                $result = imagejpeg($this->resource, $file, $quality);
                break;
        }
 
        return $result;
    }

    public function getWidth()
    {
        return imagesx($this->resource);
    }

    public function getHeight()
    {
        return imagesy($this->resource);
    }

    public function clear()
    {
        if ($this->resource !== null)
        {
            imagedestroy($this->resource);
            $this->resource = null;
        }
    }

    public function setResource($resource)
    {
        $this->resource = $resource;
    }

    public function getResource()
    {
        return $this->resource;
    }
}