Class yii\imagine\Image

                public static function autorotate($image, $color = '000000')
{
    return (new Autorotate($color))->apply(static::ensureImageInterfaceInstance($image));
}

            

                protected static function createImagine()
{
    foreach ((array) static::$driver as $driver) {
        switch ($driver) {
            case self::DRIVER_GMAGICK:
                if (class_exists('Gmagick', false)) {
                    return new \Imagine\Gmagick\Imagine();
                }
                break;
            case self::DRIVER_IMAGICK:
                if (class_exists('Imagick', false)) {
                    return new \Imagine\Imagick\Imagine();
                }
                break;
            case self::DRIVER_GD2:
                if (function_exists('gd_info')) {
                    return new \Imagine\Gd\Imagine();
                }
                break;
            default:
                throw new InvalidConfigException("Unknown driver: $driver");
        }
    }
    throw new InvalidConfigException('Your system does not support any of these drivers: ' . implode(',', (array) static::$driver));
}

            

                public static function crop($image, $width, $height, array $start = [0, 0])
{
    if (!isset($start[0], $start[1])) {
        throw new InvalidParamException('$start must be an array of two elements.');
    }
    return static::ensureImageInterfaceInstance($image)
        ->copy()
        ->crop(new Point($start[0], $start[1]), new Box($width, $height));
}

            

                protected static function ensureImageInterfaceInstance($image)
{
    if ($image instanceof ImageInterface) {
        return $image;
    }
    if (is_resource($image)) {
        return static::getImagine()->read($image);
    }
    if (is_string($image)) {
        return static::getImagine()->open(Yii::getAlias($image));
    }
    throw new InvalidParamException('File should be either ImageInterface, resource or a string containing file path.');
}

            

                public static function frame($image, $margin = 20, $color = '666', $alpha = 100)
{
    $img = self::ensureImageInterfaceInstance($image);
    $size = $img->getSize();
    $pasteTo = new Point($margin, $margin);
    $palette = new RGB();
    $color = $palette->color($color, $alpha);
    $box = new Box($size->getWidth() + ceil($margin * 2), $size->getHeight() + ceil($margin * 2));
    $finalImage = static::getImagine()->create($box, $color);
    $finalImage->paste($img, $pasteTo);
    return $finalImage;
}

            

                public static function getBox(BoxInterface $sourceBox, $width, $height, $keepAspectRatio = true)
{
    if ($width === null && $height === null) {
        throw new InvalidParamException('Width and height cannot be null at same time.');
    }
    $ratio = $sourceBox->getWidth() / $sourceBox->getHeight();
    if ($keepAspectRatio === false) {
        if ($height === null) {
            $height = ceil($width / $ratio);
        } elseif ($width === null) {
            $width = ceil($height * $ratio);
        }
    } else {
        if ($height === null) {
            $height = ceil($width / $ratio);
        } elseif ($width === null) {
            $width = ceil($height * $ratio);
        } elseif ($width / $height > $ratio) {
            $width = $height * $ratio;
        } else {
            $height = $width / $ratio;
        }
    }
    return new Box($width, $height);
}

            

                public static function getImagine()
{
    if (self::$_imagine === null) {
        self::$_imagine = static::createImagine();
    }
    return self::$_imagine;
}

            

                public static function getThumbnailBox(BoxInterface $sourceBox, $width, $height)
{
    if ($width !== null && $height !== null) {
        return new Box($width, $height);
    }
    return self::getBox($sourceBox, $width, $height, false);
}

            

                public static function isUpscaling(BoxInterface $sourceBox, BoxInterface $destinationBox)
{
    return ($sourceBox->getWidth() <= $destinationBox->getWidth() && $sourceBox->getHeight() <= $destinationBox->getHeight()) || (!$destinationBox->getWidth() && !$destinationBox->getHeight());
}

            

                public static function resize($image, $width, $height, $keepAspectRatio = true, $allowUpscaling = false)
{
    $img = self::ensureImageInterfaceInstance($image)->copy();
    /** @var BoxInterface $sourceBox */
    $sourceBox = $img->getSize();
    $destinationBox = static::getBox($sourceBox, $width, $height, $keepAspectRatio);
    if ($allowUpscaling === false && self::isUpscaling($sourceBox, $destinationBox)) {
        return $img;
    }
    return $img->resize($destinationBox);
}

            

                public static function setImagine($imagine)
{
    self::$_imagine = $imagine;
}

            

                public static function text($image, $text, $fontFile, array $start = [0, 0], array $fontOptions = [])
{
    if (!isset($start[0], $start[1])) {
        throw new InvalidParamException('$start must be an array of two elements.');
    }
    $fontSize = ArrayHelper::getValue($fontOptions, 'size', 12);
    $fontColor = ArrayHelper::getValue($fontOptions, 'color', 'fff');
    $fontAngle = ArrayHelper::getValue($fontOptions, 'angle', 0);
    $palette = new RGB();
    $color = $palette->color($fontColor);
    $img = self::ensureImageInterfaceInstance($image);
    $font = static::getImagine()->font(Yii::getAlias($fontFile), $fontSize, $color);
    $img->draw()->text($text, $font, new Point($start[0], $start[1]), $fontAngle);
    return $img;
}

            

                public static function thumbnail($image, $width, $height, $settings = ManipulatorInterface::THUMBNAIL_OUTBOUND)
{
    $img = self::ensureImageInterfaceInstance($image);
    /** @var BoxInterface $sourceBox */
    $sourceBox = $img->getSize();
    $thumbnailBox = static::getThumbnailBox($sourceBox, $width, $height);
    $allowUpscale = (bool) ($settings & ImageInterface::THUMBNAIL_FLAG_UPSCALE);
    if (self::isUpscaling($sourceBox, $thumbnailBox) && !$allowUpscale) {
        return $img->copy();
    }
    $img = $img->thumbnail($thumbnailBox, $settings);
    if ($settings & ImageInterface::THUMBNAIL_OUTBOUND) {
        return $img;
    }
    $size = $img->getSize();
    if ($size->getWidth() == $width && $size->getHeight() == $height) {
        return $img;
    }
    $palette = new RGB();
    $color = $palette->color(static::$thumbnailBackgroundColor, static::$thumbnailBackgroundAlpha);
    // create empty image to preserve aspect ratio of thumbnail
    $thumb = static::getImagine()->create($thumbnailBox, $color);
    // calculate points
    $startX = 0;
    $startY = 0;
    if ($size->getWidth() < $width) {
        $startX = ceil(($width - $size->getWidth()) / 2);
    }
    if ($size->getHeight() < $height) {
        $startY = ceil(($height - $size->getHeight()) / 2);
    }
    $thumb->paste($img, new Point($startX, $startY));
    return $thumb;
}

            

                public static function watermark($image, $watermarkImage, array $start = [0, 0])
{
    if (!isset($start[0], $start[1])) {
        throw new InvalidParamException('$start must be an array of two elements.');
    }
    $img = self::ensureImageInterfaceInstance($image);
    $watermark = self::ensureImageInterfaceInstance($watermarkImage);
    $img->paste($watermark, new Point($start[0], $start[1]));
    return $img;
}