Image_Imagick - Code Metrics - rootlocal/yii2-image2 - Measure and Improve Code Quality continuously with Scrutinizer

Image_Imagick A
last analyzed 2020-12-13 17:52 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	348
Duplicated Lines	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
eloc	125
dl	0
loc	348
rs	9.28
c	3
b	0
f	0
wmc	39
15 Methods

Rating	Name	Size	Complexity
A	_do_render()	16	1
A	_do_adapt()	10	1
A	_do_save()	24	2
A	_do_crop()	14	2
A	check()	7	2
A	_do_sharpen()	9	2
A	_do_resize()	11	2
A	__construct()	27	6
A	_get_imagetype()	22	5
A	__destruct()	4	1
A	_do_reflection()	52	4
A	_do_watermark()	21	4
A	_do_flip()	6	2
A	_do_background()	28	3
A	_do_rotate()	14	2
<?php

namespace image\components\drivers;

use image\components\Kohana\Image;
use yii\base\ErrorException;
use \Imagick;
use \ImagickPixel;

/**
 * Support for image manipulation using [Imagick](http://php.net/Imagick).
 *
 * @package    image\components\drivers
 * @category   Drivers
 * @author     Tamas Mihalik [email protected]
 * @copyright  (c) 2009-2012,2018 Kohana Team
 * @license    http://kohanaphp.com/license.html
 */
class Image_Imagick extends Image implements DriverInterface
{

    /**
     * @var  Imagick  image magick object
     */
    protected $im;

    /**
     * Checks if ImageMagick is enabled.
     *
     * @throws  ErrorException
     * @return  boolean
     */
    public static function check()
    {
        if (!extension_loaded('imagick')) {
            throw new ErrorException('Imagick is not installed, or the extension is not loaded');
        }

        return Image_Imagick::$_checked = true;
    }

    /**
     * Runs [Image_Imagick::check] and loads the image.
     *
     * @return  void
     * @param $file
     * @throws ErrorException
     * @throws \ImagickException
     */
    public function __construct($file)
    {
        if (!Image_Imagick::$_checked) {
            // Run the install check
            Image_Imagick::check();
        }

        parent::__construct($file);

        $this->im = new Imagick;
        $this->im->readImage($file);

        // Force RGB colorspace if we are using non-RGB
        $imageColorspace = $this->im->getImageColorspace();
        if ($imageColorspace !== Imagick::COLORSPACE_RGB &&
            $imageColorspace !== Imagick::COLORSPACE_SRGB
        ) {
            $imageColorspace = Imagick::COLORSPACE_RGB;
        }
        if ($this->im->getImageColorspace() !== $imageColorspace) {
            $this->im->transformImageColorspace($imageColorspace);
        }
        $this->im->setColorspace($imageColorspace);

        if (!$this->im->getImageAlphaChannel()) {
            // Force the image to have an alpha channel
            $this->im->setImageAlphaChannel(Imagick::ALPHACHANNEL_SET);
        }
    }

    /**
     * Destroys the loaded image to free up resources.
     *
     * @return  void
     */
    public function __destruct()
    {
        $this->im->clear();
        $this->im->destroy();
    }

    public function _do_resize($width, $height)
    {
        if ($this->im->scaleImage($width, $height)) {
            // Reset the width and height
            $this->width = $this->im->getImageWidth();
            $this->height = $this->im->getImageHeight();

            return true;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * Adaptation the image.
     *
     * @param   integer $width image width
     * @param   integer $height image height
     * @param   integer $bg_width background width
     * @param   integer $bg_height background height
     * @param   integer $offset_x offset from the left
     * @param   integer $offset_y offset from the top
     * @throws \ImagickException
     */
    public function _do_adapt($width, $height, $bg_width, $bg_height, $offset_x, $offset_y)
    {
        $image = new Imagick();
        $image->newImage($bg_width, $bg_height, "none");
        $image->compositeImage($this->im, Imagick::COMPOSITE_ADD, $offset_x, $offset_y);
        $this->im->clear();
        $this->im->destroy();
        $this->im = $image;
        $this->width = $bg_width;
        $this->height = $bg_height;
    }

    public function _do_crop($width, $height, $offset_x, $offset_y)
    {
        if ($this->im->cropImage($width, $height, $offset_x, $offset_y)) {
            // Reset the width and height
            $this->width = $this->im->getImageWidth();
            $this->height = $this->im->getImageHeight();

            // Trim off hidden areas
            $this->im->setImagePage($this->width, $this->height, 0, 0);

            return true;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function _do_rotate($degrees)
    {
        if ($this->im->rotateImage(new ImagickPixel('transparent'), $degrees)) {
            // Reset the width and height
            $this->width = $this->im->getImageWidth();
            $this->height = $this->im->getImageHeight();

            // Trim off hidden areas
            $this->im->setImagePage($this->width, $this->height, 0, 0);

            return true;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function _do_flip($direction)
    {
        if ($direction === Image::HORIZONTAL) {
            return $this->im->flopImage();
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        } else {
            return $this->im->flipImage();
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }
    }

    public function _do_sharpen($amount)
    {
        // IM not support $amount under 5 (0.15)
        $amount = ($amount < 5) ? 5 : $amount;

        // Amount should be in the range of 0.0 to 3.0
        $amount = ($amount * 3.0) / 100;

        return $this->im->sharpenImage(0, $amount);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function _do_reflection($height, $opacity, $fade_in)
    {
        // Clone the current image and flip it for reflection
        $reflection = $this->im->clone();
        $reflection->flipImage();

        // Crop the reflection to the selected height
        $reflection->cropImage($this->width, $height, 0, 0);
        $reflection->setImagePage($this->width, $height, 0, 0);

        // Select the fade direction
        $direction = array('transparent', 'black');

        if ($fade_in) {
            // Change the direction of the fade
            $direction = array_reverse($direction);
        }

        // Create a gradient for fading
        $fade = new Imagick;
        $fade->newPseudoImage($reflection->getImageWidth(), $reflection->getImageHeight(), vsprintf('gradient:%s-%s', $direction));

        // Apply the fade alpha channel to the reflection
        $reflection->compositeImage($fade, Imagick::COMPOSITE_DSTOUT, 0, 0);

        // NOTE: Using setImageOpacity will destroy alpha channels!
        $reflection->evaluateImage(Imagick::EVALUATE_MULTIPLY, $opacity / 100, Imagick::CHANNEL_ALPHA);

        // Create a new container to hold the image and reflection
        $image = new Imagick;
        $image->newImage($this->width, $this->height + $height, new ImagickPixel);

        // Force the image to have an alpha channel
        $image->setImageAlphaChannel(Imagick::ALPHACHANNEL_SET);

        // Force the background color to be transparent
        // $image->setImageBackgroundColor(new ImagickPixel('transparent'));

        // Place the image and reflection into the container
        if ($image->compositeImage($this->im, Imagick::COMPOSITE_SRC, 0, 0)
            && $image->compositeImage($reflection, Imagick::COMPOSITE_OVER, 0, $this->height)) {
            // Replace the current image with the reflected image
            $this->im = $image;

            // Reset the width and height
            $this->width = $this->im->getImageWidth();
            $this->height = $this->im->getImageHeight();

            return true;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @param \image\components\Kohana\Image $image
     * @param int $offset_x
     * @param int $offset_y
     * @param int $opacity
     * @return bool
     * @throws \ImagickException
     */
    public function _do_watermark(\image\components\Kohana\Image $image, $offset_x, $offset_y, $opacity)
    {
        // Convert the Image intance into an Imagick instance
        $watermark = new Imagick;
        $watermark->readImageBlob($image->render(), $image->file);
        if ($this->im->getImageColorspace() !== $this->im->getColorspace()) {
            $watermark->transformImageColorspace($this->im->getColorspace());
        }

        if ($watermark->getImageAlphaChannel() !== Imagick::ALPHACHANNEL_ACTIVATE) {
            // Force the image to have an alpha channel
            $watermark->setImageAlphaChannel(Imagick::ALPHACHANNEL_OPAQUE);
        }

        if ($opacity < 100) {
            // NOTE: Using setImageOpacity will destroy current alpha channels!
            $watermark->evaluateImage(Imagick::EVALUATE_MULTIPLY, $opacity / 100, Imagick::CHANNEL_ALPHA);
        }

        // Apply the watermark to the image
        return $this->im->compositeImage($watermark, Imagick::COMPOSITE_DISSOLVE, $offset_x, $offset_y);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function _do_background($r, $g, $b, $opacity)
    {
        // Create a RGB color for the background
        $color = sprintf('rgb(%d, %d, %d)', $r, $g, $b);

        // Create a new image for the background
        $background = new Imagick;
        $background->newImage($this->width, $this->height, new ImagickPixel($color));

        if (!$background->getImageAlphaChannel()) {
            // Force the image to have an alpha channel
            $background->setImageAlphaChannel(Imagick::ALPHACHANNEL_SET);
        }

        // Clear the background image
        $background->setImageBackgroundColor(new ImagickPixel('transparent'));

        // NOTE: Using setImageOpacity will destroy current alpha channels!
        $background->evaluateImage(Imagick::EVALUATE_MULTIPLY, $opacity / 100, Imagick::CHANNEL_ALPHA);

        if ($background->compositeImage($this->im, Imagick::COMPOSITE_DISSOLVE, 0, 0)) {
            // Replace the current image with the new image
            $this->im = $background;

            return true;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }

        return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function _do_save($file, $quality)
    {
        // Get the image format and type
        list($format, $type) = $this->_get_imagetype(pathinfo($file, PATHINFO_EXTENSION));

        // Set the output image type
        $this->im->setFormat($format);

        // Set the output quality
        $this->im->setImageCompressionQuality($quality);

        // Sets the image compression
        // progressive jpeg
        $this->im->setInterlaceScheme(Imagick::INTERLACE_PLANE);

        if ($this->im->writeImage($file)) {
            // Reset the image type and mime type
            $this->type = $type;
            $this->mime = image_type_to_mime_type($type);

            return true;
        }

        return false;
    }

    public function _do_render($type, $quality)
    {
        // Get the image format and type
        list($format, $type) = $this->_get_imagetype($type);

        // Set the output image type
        $this->im->setFormat($format);

        // Set the output quality
        $this->im->setImageCompressionQuality($quality);

        // Reset the image type and mime type
        $this->type = $type;
        $this->mime = image_type_to_mime_type($type);

        return (string)$this->im;
    }

    /**
     * Get the image type and format for an extension.
     *
     * @param   string $extension image extension: png, jpg, etc
     * @return  array  IMAGETYPE_* constant
     * @throws  ErrorException
     */
    public function _get_imagetype($extension)
    {
        // Normalize the extension to a format
        $format = strtolower($extension);

        switch ($format) {
            case 'jpg':
            case 'jpeg':
                $type = IMAGETYPE_JPEG;
                break;
            case 'gif':
                $type = IMAGETYPE_GIF;
                break;
            case 'png':
                $type = IMAGETYPE_PNG;
                break;
            default:
                throw new ErrorException(sprintf('Installed ImageMagick does not support %s images', $extension));
                break;
        }

        return [$format, $type];
    }
} // End Kohana_Image_Imagick

rootlocal / yii2-image2

Image_Imagick A last analyzed 2020-12-13 17:52 UTC

Complexity

Size/Duplication

Importance

15 Methods

Duplication Side-by-Side

Filter issues like

Image_Imagick A
last analyzed 2020-12-13 17:52 UTC
