Imagick - Code Metrics - oscarotero/imagecow - Measure and Improve Code Quality continuously with Scrutinizer

Imagick D
last analyzed 2020-01-08 10:30 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	379
Duplicated Lines	3.69 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	58
lcom	1
cbo	3
dl	14
loc	379
rs	4.5599
c	0
b	0
f	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	createFromFile()	0	10	2
A	createFromString()	0	8	1
A	__construct()	0	18	3
A	__destruct()	0	4	1
A	flip()	0	6	2
A	flop()	0	6	2
A	save()	0	16	4
A	getImage()	0	4	1
A	getString()	0	22	3
A	getMimeType()	0	8	2
A	getWidth()	0	8	2
A	getHeight()	0	8	2
A	format()	0	13	3
A	resize()	7	18	4
A	getCropOffsets()	0	10	2
A	crop()	7	19	4
A	rotate()	0	8	2
A	blur()	0	15	2
B	getCompressed()	0	39	6
A	watermark()	0	8	2
A	opacity()	0	13	4
A	setProgressive()	0	8	2
A	checkCompatibility()	0	4	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Imagick often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Imagick, and based on these observations, apply Extract Interface, too.

<?php

namespace Imagecow\Libs;

use Imagick as BaseImagick;
use ImagickPixel as BaseImagickPixel;
use Imagecow\ImageException;

/**
 * Imagick library.
 */
class Imagick extends AbstractLib implements LibInterface
{
    protected $image;

    /**
     * {@inheritdoc}
     */
    public static function checkCompatibility()
    {
        return extension_loaded('imagick') && !empty(BaseImagick::queryformats());
    }

    /**
     * {@inheritdoc}
     *
     * @return Imagick
     */
    public static function createFromFile($filename)
    {
        $imagick = new BaseImagick();

        if ($imagick->readImage($filename) !== true) {
            throw new ImageException("The image file '{$filename}' cannot be loaded");
        }

        return new static($imagick);
    }

    /**
     * {@inheritdoc}
     *
     * @return Imagick
     */
    public static function createFromString($string)
    {
        $imagick = new BaseImagick();

        $imagick->readImageBlob($string);

        return new static($imagick);
    }

    /**
     * Constructor of the class.
     *
     * @param BaseImagick $image The Imagick instance
     */
    public function __construct(BaseImagick $image)
    {
        $this->image = $image;

        //Convert CMYK to RGB
        if ($this->image->getImageColorspace() !== BaseImagick::COLORSPACE_CMYK) {
            return $this;

        }

        $profiles = $this->image->getImageProfiles('*', false);

        if (array_search('icc', $profiles) === false) {
            $this->image->profileImage('icc', file_get_contents(__DIR__.'/icc/us_web_uncoated.icc'));
        }

        $this->image->profileImage('icm', file_get_contents(__DIR__.'/icc/srgb.icm'));
        $this->image->transformImageColorspace(BaseImagick::COLORSPACE_SRGB);
    }

    /**
     * Destroy the image.
     */
    public function __destruct()
    {
        $this->image->destroy();
    }

    /**
     * {@inheritdoc}
     */
    public function flip()
    {
        if ($this->image->flipImage() !== true) {
            throw new ImageException('There was an error on flip the image');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function flop()
    {
        if ($this->image->flopImage() !== true) {
            throw new ImageException('There was an error on flop the image');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function save($filename)
    {
        $image = $this->getCompressed();

        if ($this->animated) {
            if (!($fp = fopen($filename, 'w'))) {
                throw new ImageException("The image file '{$filename}' cannot be saved");
            }

            $image->writeImagesFile($fp);

            fclose($fp);
        } elseif (!$image->writeImage($filename)) {
            throw new ImageException("The image file '{$filename}' cannot be saved");
        }
    }

    /**
     * Gets the original image object.
     *
     * @return object
     */
    public function getImage()
    {
        return $this->image;
    }

    /**
     * {@inheritdoc}
     */
    public function getString()
    {
        $image = $this->getCompressed();

        if (!$this->animated) {
            return $image->getImageBlob();
        }

        if (!($fp = fopen($file = tempnam(sys_get_temp_dir(), 'imagick'), 'w'))) {
            throw new ImageException('Cannot create a temp file to generate the string data image');
        }

        $image->writeImagesFile($fp);

        fclose($fp);

        $string = file_get_contents($file);

        unlink($file);

        return $string;
    }

    /**
     * {@inheritdoc}
     */
    public function getMimeType()
    {
        $format = strtolower($this->image->getImageFormat());

        if (in_array($format, ['jpeg', 'jpg', 'gif', 'png', 'webp'], true)) {
            return "image/$format";
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getWidth()
    {
        if ($this->animated) {
            return $this->image->coalesceImages()->getImageWidth();
        } else {
            return $this->image->getImageWidth();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getHeight()
    {
        if ($this->animated) {
            return $this->image->coalesceImages()->getImageHeight();
        } else {
            return $this->image->getImageHeight();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function format($format)
    {
        if (preg_match('/jpe?g/i', $format)) {
            list($r, $g, $b) = $this->background;

            $this->image->setImageBackgroundColor("rgb($r,$g,$b)");
            $this->image = $this->image->mergeImageLayers(BaseImagick::LAYERMETHOD_FLATTEN);
        }

        if ($this->image->setImageFormat($format) !== true) {
            throw new ImageException("The image format '{$format}' is not valid");
        }
    }

    /**
     * {@inheritdoc}
     */
    public function resize($width, $height)
    {
        if ($this->animated) {
            $this->image = $this->image->coalesceImages();

            foreach ($this->image as $frame) {
                $frame->scaleImage($width, $height);
            }

            $this->image = $this->image->deconstructImages();
        } else {

            if ($this->image->scaleImage($width, $height) !== true) {
                throw new ImageException('There was an error resizing the image');
            }

            $this->image->setImagePage(0, 0, 0, 0);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getCropOffsets($width, $height, $method)
    {
        $class = 'Imagecow\\Crops\\'.ucfirst(strtolower($method));

        if (!class_exists($class)) {
            throw new ImageException("The crop method '$method' is not available for Imagick");
        }

        return $class::getOffsets($this->image, $width, $height);
    }

    /**
     * {@inheritdoc}
     */
    public function crop($width, $height, $x, $y)
    {
        if ($this->animated) {
            $this->image = $this->image->coalesceImages();

            foreach ($this->image as $frame) {
                $frame->cropImage($width, $height, $x, $y);
                $frame->setImagePage(0, 0, 0, 0);
            }

            $this->image = $this->image->deconstructImages();
        } else {

            if ($this->image->cropImage($width, $height, $x, $y) !== true) {
                throw new ImageException('There was an error cropping the image');
            }

            $this->image->setImagePage(0, 0, 0, 0);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function rotate($angle)
    {
        if ($this->image->rotateImage(new BaseImagickPixel('#FFFFFF'), $angle) !== true) {
            throw new ImageException('There was an error rotating the image');
        }

        $this->image->setImagePage(0, 0, 0, 0);
    }

    /**
     * {@inheritdoc}
     */
    public function blur($loops)
    {
        $width = $this->getWidth();
        $height = $this->getHeight();

        $this->resize($width / 5, $height / 5);

        for ($i = 0; $i < $loops; $i++) {
            $this->image->blurImage(5, 100);
        }

        $this->resize($width, $height);

        $this->image->blurImage(10, 100);
    }

    /**
     * Returns a copy of the image compressed and ready to save or print.
     *
     * @return BaseImagick The instance of the image
     */
    private function getCompressed()
    {
        $image = $this->image;


        if ($this->animated) {
            $image = $image->coalesceImages();

            foreach ($image as $frame) {
                $frame->stripImage();
                $frame->setImageUnits(1);
                $frame->setImageCompressionQuality($this->quality);
            }

            return $image->deconstructImages();
        }

        $format = strtolower($image->getImageFormat());

        $image->stripImage();
        $image->setImageUnits(1);
        $image->setImageCompressionQuality($this->quality);

        switch ($format) {
            case 'jpeg':
                $image->setInterlaceScheme(BaseImagick::INTERLACE_JPEG);
                $image->setImageCompression(BaseImagick::COMPRESSION_JPEG);
                break;

            case 'gif':
                $image->setInterlaceScheme(BaseImagick::INTERLACE_GIF);
                break;

            case 'png':
                $image->setInterlaceScheme(BaseImagick::INTERLACE_PNG);
                break;
        }

        return $image;
    }

    /**
     * {@inheritdoc}
     */
    public function watermark(LibInterface $image, $x, $y)
    {
        if (!($image instanceof self)) {
            $image = self::createFromString($image->getString());
        }

        $this->image->compositeImage($image->getImage(), BaseImagick::COMPOSITE_DISSOLVE, $x, $y);
    }

    /**
     * {@inheritdoc}
     */
    public function opacity($opacity)
    {
        if ($opacity >= 100 || $opacity < 0) {
            return;
        }

        if ($this->image->getImageAlphaChannel() !== BaseImagick::ALPHACHANNEL_ACTIVATE) {
            $this->image->setImageAlphaChannel(BaseImagick::ALPHACHANNEL_OPAQUE);
        }

        // NOTE: Using setImageOpacity will destroy current alpha channels!
        $this->image->evaluateImage(BaseImagick::EVALUATE_MULTIPLY, $opacity / 100, BaseImagick::CHANNEL_ALPHA);
    }

    /**
     * {@inheritdoc}
     */
    public function setProgressive($progressive)
    {
        if ($progressive) {
            $this->image->setInterlaceScheme(BaseImagick::INTERLACE_PLANE);
        } else {
            $this->image->setInterlaceScheme(BaseImagick::INTERLACE_NO);
        }
    }
}


1		<?php
2
3		namespace Imagecow\Libs;
4
5		use Imagick as BaseImagick;
6		use ImagickPixel as BaseImagickPixel;
7		use Imagecow\ImageException;
8
9		/**
10		* Imagick library.
11		*/
12		class Imagick extends AbstractLib implements LibInterface
13		{
14		protected $image;
15
16		/**
17		* {@inheritdoc}
18		*/
19		public static function checkCompatibility()
20		{
21		return extension_loaded('imagick') && !empty(BaseImagick::queryformats());
22		}
23
24		/**
25		* {@inheritdoc}
26		*
27		* @return Imagick
28		*/
29		public static function createFromFile($filename)
30		{
31		$imagick = new BaseImagick();
32
33		if ($imagick->readImage($filename) !== true) {
34		throw new ImageException("The image file '{$filename}' cannot be loaded");
35		}
36
37		return new static($imagick);
38		}
39
40		/**
41		* {@inheritdoc}
42		*
43		* @return Imagick
44		*/
45		public static function createFromString($string)
46		{
47		$imagick = new BaseImagick();
48
49		$imagick->readImageBlob($string);
50
51		return new static($imagick);
52		}
53
54		/**
55		* Constructor of the class.
56		*
57		* @param BaseImagick $image The Imagick instance
58		*/
59		public function __construct(BaseImagick $image)
60		{
61		$this->image = $image;
62
63		//Convert CMYK to RGB
64		if ($this->image->getImageColorspace() !== BaseImagick::COLORSPACE_CMYK) {
65		return $this;
		0 ignored issues – show Bug introduced 2016-05-11 22:27 UTC by Report Bug Copy Issue Report Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct? Loading history...
66		}
67
68		$profiles = $this->image->getImageProfiles('*', false);
69
70		if (array_search('icc', $profiles) === false) {
71		$this->image->profileImage('icc', file_get_contents(__DIR__.'/icc/us_web_uncoated.icc'));
72		}
73
74		$this->image->profileImage('icm', file_get_contents(__DIR__.'/icc/srgb.icm'));
75		$this->image->transformImageColorspace(BaseImagick::COLORSPACE_SRGB);
76		}
77
78		/**
79		* Destroy the image.
80		*/
81		public function __destruct()
82		{
83		$this->image->destroy();
84		}
85
86		/**
87		* {@inheritdoc}
88		*/
89		public function flip()
90		{
91		if ($this->image->flipImage() !== true) {
92		throw new ImageException('There was an error on flip the image');
93		}
94		}
95
96		/**
97		* {@inheritdoc}
98		*/
99		public function flop()
100		{
101		if ($this->image->flopImage() !== true) {
102		throw new ImageException('There was an error on flop the image');
103		}
104		}
105
106		/**
107		* {@inheritdoc}
108		*/
109		public function save($filename)
110		{
111		$image = $this->getCompressed();
112
113		if ($this->animated) {
114		if (!($fp = fopen($filename, 'w'))) {
115		throw new ImageException("The image file '{$filename}' cannot be saved");
116		}
117
118		$image->writeImagesFile($fp);
119
120		fclose($fp);
121		} elseif (!$image->writeImage($filename)) {
122		throw new ImageException("The image file '{$filename}' cannot be saved");
123		}
124		}
125
126		/**
127		* Gets the original image object.
128		*
129		* @return object
130		*/
131		public function getImage()
132		{
133		return $this->image;
134		}
135
136		/**
137		* {@inheritdoc}
138		*/
139		public function getString()
140		{
141		$image = $this->getCompressed();
142
143		if (!$this->animated) {
144		return $image->getImageBlob();
145		}
146
147		if (!($fp = fopen($file = tempnam(sys_get_temp_dir(), 'imagick'), 'w'))) {
148		throw new ImageException('Cannot create a temp file to generate the string data image');
149		}
150
151		$image->writeImagesFile($fp);
152
153		fclose($fp);
154
155		$string = file_get_contents($file);
156
157		unlink($file);
158
159		return $string;
160		}
161
162		/**
163		* {@inheritdoc}
164		*/
165		public function getMimeType()
166		{
167		$format = strtolower($this->image->getImageFormat());
168
169		if (in_array($format, ['jpeg', 'jpg', 'gif', 'png', 'webp'], true)) {
170		return "image/$format";
171		}
172		}
173
174		/**
175		* {@inheritdoc}
176		*/
177		public function getWidth()
178		{
179		if ($this->animated) {
180		return $this->image->coalesceImages()->getImageWidth();
181		} else {
182		return $this->image->getImageWidth();
183		}
184		}
185
186		/**
187		* {@inheritdoc}
188		*/
189		public function getHeight()
190		{
191		if ($this->animated) {
192		return $this->image->coalesceImages()->getImageHeight();
193		} else {
194		return $this->image->getImageHeight();
195		}
196		}
197
198		/**
199		* {@inheritdoc}
200		*/
201		public function format($format)
202		{
203		if (preg_match('/jpe?g/i', $format)) {
204		list($r, $g, $b) = $this->background;
205
206		$this->image->setImageBackgroundColor("rgb($r,$g,$b)");
207		$this->image = $this->image->mergeImageLayers(BaseImagick::LAYERMETHOD_FLATTEN);
208		}
209
210		if ($this->image->setImageFormat($format) !== true) {
211		throw new ImageException("The image format '{$format}' is not valid");
212		}
213		}
214
215		/**
216		* {@inheritdoc}
217		*/
218		public function resize($width, $height)
219		{
220		if ($this->animated) {
221		$this->image = $this->image->coalesceImages();
222
223		foreach ($this->image as $frame) {
224		$frame->scaleImage($width, $height);
225		}
226
227		$this->image = $this->image->deconstructImages();
228	View Code Duplication	} else {
		0 ignored issues – show Duplication introduced 2016-05-12 11:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
229		if ($this->image->scaleImage($width, $height) !== true) {
230		throw new ImageException('There was an error resizing the image');
231		}
232
233		$this->image->setImagePage(0, 0, 0, 0);
234		}
235		}
236
237		/**
238		* {@inheritdoc}
239		*/
240		public function getCropOffsets($width, $height, $method)
241		{
242		$class = 'Imagecow\\Crops\\'.ucfirst(strtolower($method));
243
244		if (!class_exists($class)) {
245		throw new ImageException("The crop method '$method' is not available for Imagick");
246		}
247
248		return $class::getOffsets($this->image, $width, $height);
249		}
250
251		/**
252		* {@inheritdoc}
253		*/
254		public function crop($width, $height, $x, $y)
255		{
256		if ($this->animated) {
257		$this->image = $this->image->coalesceImages();
258
259		foreach ($this->image as $frame) {
260		$frame->cropImage($width, $height, $x, $y);
261		$frame->setImagePage(0, 0, 0, 0);
262		}
263
264		$this->image = $this->image->deconstructImages();
265	View Code Duplication	} else {
		0 ignored issues – show Duplication introduced 2016-05-12 11:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
266		if ($this->image->cropImage($width, $height, $x, $y) !== true) {
267		throw new ImageException('There was an error cropping the image');
268		}
269
270		$this->image->setImagePage(0, 0, 0, 0);
271		}
272		}
273
274		/**
275		* {@inheritdoc}
276		*/
277		public function rotate($angle)
278		{
279		if ($this->image->rotateImage(new BaseImagickPixel('#FFFFFF'), $angle) !== true) {
280		throw new ImageException('There was an error rotating the image');
281		}
282
283		$this->image->setImagePage(0, 0, 0, 0);
284		}
285
286		/**
287		* {@inheritdoc}
288		*/
289		public function blur($loops)
290		{
291		$width = $this->getWidth();
292		$height = $this->getHeight();
293
294		$this->resize($width / 5, $height / 5);
295
296		for ($i = 0; $i < $loops; $i++) {
297		$this->image->blurImage(5, 100);
298		}
299
300		$this->resize($width, $height);
301
302		$this->image->blurImage(10, 100);
303		}
304
305		/**
306		* Returns a copy of the image compressed and ready to save or print.
307		*
308		* @return BaseImagick The instance of the image
309		*/
310		private function getCompressed()
311		{
312		$image = $this->image;
		0 ignored issues – show Bug Compatibility introduced 2016-05-11 22:27 UTC by Report Bug Copy Issue Report The expression `$this->image;` of type `Imagick\|boolean` adds the type `boolean` to the return on line 347 which is incompatible with the return type documented by `Imagecow\Libs\Imagick::getCompressed` of type `Imagick`. Loading history...
313
314		if ($this->animated) {
315		$image = $image->coalesceImages();
316
317		foreach ($image as $frame) {
318		$frame->stripImage();
319		$frame->setImageUnits(1);
320		$frame->setImageCompressionQuality($this->quality);
321		}
322
323		return $image->deconstructImages();
324		}
325
326		$format = strtolower($image->getImageFormat());
327
328		$image->stripImage();
329		$image->setImageUnits(1);
330		$image->setImageCompressionQuality($this->quality);
331
332		switch ($format) {
333		case 'jpeg':
334		$image->setInterlaceScheme(BaseImagick::INTERLACE_JPEG);
335		$image->setImageCompression(BaseImagick::COMPRESSION_JPEG);
336		break;
337
338		case 'gif':
339		$image->setInterlaceScheme(BaseImagick::INTERLACE_GIF);
340		break;
341
342		case 'png':
343		$image->setInterlaceScheme(BaseImagick::INTERLACE_PNG);
344		break;
345		}
346
347		return $image;
348		}
349
350		/**
351		* {@inheritdoc}
352		*/
353		public function watermark(LibInterface $image, $x, $y)
354		{
355		if (!($image instanceof self)) {
356		$image = self::createFromString($image->getString());
357		}
358
359		$this->image->compositeImage($image->getImage(), BaseImagick::COMPOSITE_DISSOLVE, $x, $y);
360		}
361
362		/**
363		* {@inheritdoc}
364		*/
365		public function opacity($opacity)
366		{
367		if ($opacity >= 100 \|\| $opacity < 0) {
368		return;
369		}
370
371		if ($this->image->getImageAlphaChannel() !== BaseImagick::ALPHACHANNEL_ACTIVATE) {
372		$this->image->setImageAlphaChannel(BaseImagick::ALPHACHANNEL_OPAQUE);
373		}
374
375		// NOTE: Using setImageOpacity will destroy current alpha channels!
376		$this->image->evaluateImage(BaseImagick::EVALUATE_MULTIPLY, $opacity / 100, BaseImagick::CHANNEL_ALPHA);
377		}
378
379		/**
380		* {@inheritdoc}
381		*/
382		public function setProgressive($progressive)
383		{
384		if ($progressive) {
385		$this->image->setInterlaceScheme(BaseImagick::INTERLACE_PLANE);
386		} else {
387		$this->image->setInterlaceScheme(BaseImagick::INTERLACE_NO);
388		}
389		}
390		}
391

oscarotero / imagecow

Imagick D last analyzed 2020-01-08 10:30 UTC