ImageEditor::save() - Code Metrics - gwa/gwImageEditor - Measure and Improve Code Quality continuously with Scrutinizer

ImageEditor::save() A
last analyzed 2016-04-26 07:19 UTC

↳ Parent: ImageEditor

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	7
rs	9.4285
cc	2
eloc	4
nc	2
nop	1

<?php
namespace Gwa\Image;

/**
 * Class containing methods for editing images.
 */
class ImageEditor
{
    /**
     * @var string
     */
    private $filepath;

    /**
     * @var int
     */
    private $type;

    /**
     * @var int
     */
    private $width;

    /**
     * @var int
     */
    private $height;

    /**
     * @var string
     */
    private $mimetype;

    /**
     * @var resource
     */
    private $resource;

    const DEFAULT_JPEG_QUALITY = 80;

    /**
     * Constuctor
     *
     * @param string $filepath Path to an existing image
     * @throws InvalidArgumentException
     * @throws Exception
     */
    public function __construct($filepath)
    {
        // make sure the GD library is installed
        if (!function_exists('gd_info')) {
            trigger_error('You do not have the GD Library installed.');
        }

        if (!file_exists($filepath)) {
            throw new \InvalidArgumentException('File does not exist: ' . $filepath);
        }

        if (!is_readable($filepath)) {
            throw new \Exception('File is not readable: ' . $filepath);
        }

        $this->filepath = $filepath;
        $this->extractFileData();
        $this->createResource();
    }

    /**
     * Destructor
     */
    public function __destruct()
    {
        if (is_resource($this->resource)) {
            imagedestroy($this->resource);
        }
    }

    /* resize ---------------- */

    /**
     * Resizes image to be within a maximum width and a maximum height
     *
     * @param int $maxwidth
     * @param int $maxheight
     * @return ImageEditor
     */
    public function resizeToWithin($maxwidth, $maxheight)
    {
        $dimensions = new Dimensions();

        if ($newd = $dimensions->resizeToWithin($this->width, $this->height, $maxwidth, $maxheight)) {
            $this->resizeToDimensions($newd);
        }

        return $this;
    }

    /**
     * Resizes image to an exact width and height, maintaining aspect ratio. Any overhang is cropped.
     * If `null` is passed as width or height, image is resized to the new width or height with maintained aspect ratio, without cropping.
     *
     * @param int|null $width
     * @param int|null $height
     * @return ImageEditor
     */
    public function resizeTo($width, $height = null)
    {
        $dimensions = new Dimensions();

        if ($newd = $dimensions->resizeTo($this->width, $this->height, $width, $height)) {
            $this->resizeToDimensions($newd);
            if ($newd->overhang) {
                $this->cropFromCenter($width, $height);
            }
        }

        return $this;
    }

    private function resizeToDimensions(\stdClass $dimensions)
    {
        $this->resizeImage($dimensions->width, $dimensions->height);
    }

    private function resizeImage($newwidth, $newheight)
    {
        $newimage = $this->createImage($newwidth, $newheight);
        imagecopyresampled(
            $newimage,
            $this->resource,
            0,
            0,
            0,
            0,
            $newwidth,
            $newheight,
            $this->width,
            $this->height
        );
        $this->setResource($newimage);
    }

    /* crop -------- */

    /**
     * Crops the current image
     *
     * @param int $x
     * @param int $y
     * @param int $width
     * @param int $height
     *
     * @return ImageEditor
     */
    public function crop($x, $y, $width, $height)
    {
        // check that crop is within bounds of image
        if ($x + $width > $this->width || $y + $height > $this->height) {
            throw new \InvalidArgumentException('crop out of bounds');
        }

        $newimage = $this->createImage($width, $height);
        imagecopy(
            $newimage,
            $this->resource,
            0,
            0,
            $x,
            $y,
            $width,
            $height
        );
        $this->setResource($newimage);

        return $this;
    }

    /**
     * Crops the image from the center
     *
     * @param int $width
     * @param int $height
     *
     * @return ImageEditor
     */
    public function cropFromCenter($width, $height)
    {
        $x = ($this->width / 2) - ($width / 2);
        $y = ($this->height / 2) - ($height / 2);

        return $this->crop($x, $y, $width, $height);
    }

    /* rotation -------- */

    /**
     * @return ImageEditor
     */
    public function rotateClockwise()
    {
        return $this->rotate(270);
    }

    /**
     * @return ImageEditor
     */
    public function rotateCounterClockwise()
    {
        return $this->rotate(90);
    }

    /**
     * @return ImageEditor
     */
    public function rotate180()
    {
        return $this->rotate(180);
    }

    /**
     * @param int $deg
     * @return ImageEditor
     */
    private function rotate($deg)
    {
        imagealphablending($this->resource, false);
        $this->setResource(imagerotate($this->resource, $deg, 0));
        return $this;
    }

    /* filter -------- */

    /**
     * @return ImageEditor
     */
    public function grayscale()
    {
        imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
        return $this;
    }

    /**
     * @param int $red [0, +255]
     * @param int $green [0, +255]
     * @param int $blue [0, +255]
     * @param int $alpha [0, 1]
     *
     * @return ImageEditor
     */
    public function coloroverlay($red, $green, $blue, $alpha = 50)
    {
        imagealphablending($this->resource, true);
        $color = imagecolorallocatealpha($this->resource, $red, $green, $blue, $alpha * 1.27);
        imagefilledrectangle($this->resource, 0, 0, $this->width, $this->height, $color);
        imagealphablending($this->resource, false);
        return $this;
    }

    /**
     * @param int $red [0, 255]
     * @param int $green [0, 255]
     * @param int $blue [0, 255]
     * @param int $alpha [0, 127]
     *
     * @return ImageEditor
     */
    public function colorize($red, $green, $blue, $alpha = 0)
    {
        imagefilter($this->resource, IMG_FILTER_COLORIZE, $red, $green, $blue, $alpha);
        return $this;
    }

    /**
     * Paste another image onto this one.
     * @note Basically a wrapper method for http://www.php.net/manual/en/function.imagecopyresampled.php
     *
     * @param ImageEditor|string $imageeditor
     * @param int $dst_x
     * @param int $dst_y
     * @param int $dst_w
     * @param int $dst_h
     * @param int $src_x
     * @param int $src_y
     * @param int $src_w
     * @param int $src_h
     */
    public function pasteImage(
        $imageeditor,
        $dst_x = 0,
        $dst_y = 0,
        $dst_w = null,
        $dst_h = null,
        $src_x = null,
        $src_y = null,
        $src_w = null,
        $src_h = null
    ) {
        if (is_string($imageeditor)) {
            $imageeditor = new ImageEditor($imageeditor);
        }

        if ($src_w === null) {
            $src_w = $imageeditor->getWidth();
        }
        if ($src_h === null) {
            $src_h = $imageeditor->getHeight();
        }
        if ($dst_w === null) {
            $dst_w = $src_w;
        }
        if ($dst_h === null) {
            $dst_h = $src_h;
        }

        imagealphablending($this->resource, true);

        imagecopyresampled(
            $this->resource,
            $imageeditor->getResource(),
            $dst_x,
            $dst_y,
            $src_x,
            $src_y,
            $dst_w,
            $dst_h,
            $src_w,
            $src_h
        );

        imagealphablending($this->resource, false);

        return $this;
    }

    /* -------- */

    /**
     * "Duplicates" the image.
     * Basically unsets the filepath, so we have to use `saveAs()` and not `save()`.
     *
     * @return ImageEditor
     */
    public function duplicate()
    {
        $this->filepath = null;
        return $this;
    }

    /**
     * Saves the image
     *
     * @param int $quality 0-100 (only for jpegs)
     *
     * @return ImageEditor
     */
    public function save($quality = self::DEFAULT_JPEG_QUALITY)
    {
        if (!isset($this->filepath)) {
            throw new \LogicException('Use saveTo() to save an unnamed file.');
        }
        return $this->saveAs($this->filepath, $quality);
    }

    /**
     * Saves the image under a path
     *
     * @param string $filepath
     * @param int $type IMAGETYPE constant
     * @param int $quality 0-100 (only for jpegs)
     *
     * @return ImageEditor
     */
    public function saveAs($filepath, $type = null, $quality = self::DEFAULT_JPEG_QUALITY)
    {
        $this->outputImage($filepath, $type, $quality);
        $this->filepath = $filepath;

        return $this;
    }

    /**
     * Outputs the image with the correct header.
     *
     * @param int $quality 0-100 (only for jpegs)
     */
    public function output($quality = self::DEFAULT_JPEG_QUALITY)
    {
        header('Content-type: ' . $this->mimetype);
        $this->outputImage(null, $quality);
    }

    /**
     * @param string $filepath
     * @param int $type IMAGETYPE constant
     * @param int $quality 0-100 (only for jpegs)
     */
    private function outputImage($filepath = null, $type = null, $quality = self::DEFAULT_JPEG_QUALITY)
    {
        $type = !isset($type) ? $this->type : $type;

        switch ($type) {
            case IMAGETYPE_JPEG:
                imagejpeg($this->resource, $filepath, $quality);
                break;

            case IMAGETYPE_PNG:
                imagepng($this->resource, $filepath);
                break;

            case IMAGETYPE_GIF:
                imagegif($this->resource, $filepath);
                break;
        }
    }

    /* -------- */

    /**
     * Retrieves format.
     */
    private function extractFileData()
    {
        if (!$this->type = exif_imagetype($this->filepath)) {
            throw new \Exception('Wrong file type');
        }

        $mimetypes = array(
            IMAGETYPE_GIF  => 'image/gif',
            IMAGETYPE_JPEG => 'image/jpeg',
            IMAGETYPE_PNG  => 'image/png'
        );

        if (!array_key_exists($this->type, $mimetypes)) {
            throw new \Exception('Unsupported image type');
        }

        $this->mimetype = $mimetypes[$this->type];
    }

    private function createResource()
    {
        switch ($this->type) {
            case IMAGETYPE_GIF:
                $this->setResource(imagecreatefromgif($this->filepath));
                break;
            case IMAGETYPE_JPEG:
                $this->setResource(imagecreatefromjpeg($this->filepath));
                break;
            case IMAGETYPE_PNG:
                $this->setResource(imagecreatefrompng($this->filepath));
                break;
        }
    }

    /**
     * @param resource $resource
     */
    private function setResource($resource)
    {
        if (is_resource($this->resource)) {
            imagedestroy($this->resource);
        }

        $this->width = imagesx($resource);
        $this->height = imagesy($resource);

        imagealphablending($resource, false);
        imagesavealpha($resource, true);

        $this->resource = $resource;
    }

    /**
     * @param int $width
     * @param int $height
     *
     * @return resource
     */
    private function createImage($width, $height)
    {
        $resource = imagecreatetruecolor($width, $height);

        imagealphablending($resource, false);
        imagesavealpha($resource, true);

        return $resource;
    }

    /* -------- GETTER / SETTERS -------- */

    /**
     * Gets format of this image [IMAGETYPE_GIF|IMAGETYPE_GIF|IMAGETYPE_GIF]
     *
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Gets mimetype
     *
     * @return string
     */
    public function getMimeType()
    {
        return $this->mimetype;
    }

    /**
     * Returns the width.
     *
     * @return int
     */
    public function getWidth()
    {
        return $this->width;
    }

    /**
     * Returns the height.
     *
     * @return int
     */
    public function getHeight()
    {
        return $this->height;
    }

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


1			<?php
2			namespace Gwa\Image;
3
4			/**
5			* Class containing methods for editing images.
6			*/
7			class ImageEditor
8			{
9			/**
10			* @var string
11			*/
12			private $filepath;
13
14			/**
15			* @var int
16			*/
17			private $type;
18
19			/**
20			* @var int
21			*/
22			private $width;
23
24			/**
25			* @var int
26			*/
27			private $height;
28
29			/**
30			* @var string
31			*/
32			private $mimetype;
33
34			/**
35			* @var resource
36			*/
37			private $resource;
38
39			const DEFAULT_JPEG_QUALITY = 80;
40
41			/**
42			* Constuctor
43			*
44			* @param string $filepath Path to an existing image
45			* @throws InvalidArgumentException
46			* @throws Exception
47			*/
48			public function __construct($filepath)
49			{
50			// make sure the GD library is installed
51			if (!function_exists('gd_info')) {
52			trigger_error('You do not have the GD Library installed.');
53			}
54
55			if (!file_exists($filepath)) {
56			throw new \InvalidArgumentException('File does not exist: ' . $filepath);
57			}
58
59			if (!is_readable($filepath)) {
60			throw new \Exception('File is not readable: ' . $filepath);
61			}
62
63			$this->filepath = $filepath;
64			$this->extractFileData();
65			$this->createResource();
66			}
67
68			/**
69			* Destructor
70			*/
71			public function __destruct()
72			{
73			if (is_resource($this->resource)) {
74			imagedestroy($this->resource);
75			}
76			}
77
78			/* resize ---------------- */
79
80			/**
81			* Resizes image to be within a maximum width and a maximum height
82			*
83			* @param int $maxwidth
84			* @param int $maxheight
85			* @return ImageEditor
86			*/
87			public function resizeToWithin($maxwidth, $maxheight)
88			{
89			$dimensions = new Dimensions();
90
91			if ($newd = $dimensions->resizeToWithin($this->width, $this->height, $maxwidth, $maxheight)) {
92			$this->resizeToDimensions($newd);
93			}
94
95			return $this;
96			}
97
98			/**
99			* Resizes image to an exact width and height, maintaining aspect ratio. Any overhang is cropped.
100			* If `null` is passed as width or height, image is resized to the new width or height with maintained aspect ratio, without cropping.
101			*
102			* @param int\|null $width
103			* @param int\|null $height
104			* @return ImageEditor
105			*/
106			public function resizeTo($width, $height = null)
107			{
108			$dimensions = new Dimensions();
109
110			if ($newd = $dimensions->resizeTo($this->width, $this->height, $width, $height)) {
111			$this->resizeToDimensions($newd);
112			if ($newd->overhang) {
113			$this->cropFromCenter($width, $height);
114			}
115			}
116
117			return $this;
118			}
119
120			private function resizeToDimensions(\stdClass $dimensions)
121			{
122			$this->resizeImage($dimensions->width, $dimensions->height);
123			}
124
125			private function resizeImage($newwidth, $newheight)
126			{
127			$newimage = $this->createImage($newwidth, $newheight);
128			imagecopyresampled(
129			$newimage,
130			$this->resource,
131			0,
132			0,
133			0,
134			0,
135			$newwidth,
136			$newheight,
137			$this->width,
138			$this->height
139			);
140			$this->setResource($newimage);
141			}
142
143			/* crop -------- */
144
145			/**
146			* Crops the current image
147			*
148			* @param int $x
149			* @param int $y
150			* @param int $width
151			* @param int $height
152			*
153			* @return ImageEditor
154			*/
155			public function crop($x, $y, $width, $height)
156			{
157			// check that crop is within bounds of image
158			if ($x + $width > $this->width \|\| $y + $height > $this->height) {
159			throw new \InvalidArgumentException('crop out of bounds');
160			}
161
162			$newimage = $this->createImage($width, $height);
163			imagecopy(
164			$newimage,
165			$this->resource,
166			0,
167			0,
168			$x,
169			$y,
170			$width,
171			$height
172			);
173			$this->setResource($newimage);
174
175			return $this;
176			}
177
178			/**
179			* Crops the image from the center
180			*
181			* @param int $width
182			* @param int $height
183			*
184			* @return ImageEditor
185			*/
186			public function cropFromCenter($width, $height)
187			{
188			$x = ($this->width / 2) - ($width / 2);
189			$y = ($this->height / 2) - ($height / 2);
190
191			return $this->crop($x, $y, $width, $height);
192			}
193
194			/* rotation -------- */
195
196			/**
197			* @return ImageEditor
198			*/
199			public function rotateClockwise()
200			{
201			return $this->rotate(270);
202			}
203
204			/**
205			* @return ImageEditor
206			*/
207			public function rotateCounterClockwise()
208			{
209			return $this->rotate(90);
210			}
211
212			/**
213			* @return ImageEditor
214			*/
215			public function rotate180()
216			{
217			return $this->rotate(180);
218			}
219
220			/**
221			* @param int $deg
222			* @return ImageEditor
223			*/
224			private function rotate($deg)
225			{
226			imagealphablending($this->resource, false);
227			$this->setResource(imagerotate($this->resource, $deg, 0));
228			return $this;
229			}
230
231			/* filter -------- */
232
233			/**
234			* @return ImageEditor
235			*/
236			public function grayscale()
237			{
238			imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
239			return $this;
240			}
241
242			/**
243			* @param int $red [0, +255]
244			* @param int $green [0, +255]
245			* @param int $blue [0, +255]
246			* @param int $alpha [0, 1]
247			*
248			* @return ImageEditor
249			*/
250			public function coloroverlay($red, $green, $blue, $alpha = 50)
251			{
252			imagealphablending($this->resource, true);
253			$color = imagecolorallocatealpha($this->resource, $red, $green, $blue, $alpha * 1.27);
254			imagefilledrectangle($this->resource, 0, 0, $this->width, $this->height, $color);
255			imagealphablending($this->resource, false);
256			return $this;
257			}
258
259			/**
260			* @param int $red [0, 255]
261			* @param int $green [0, 255]
262			* @param int $blue [0, 255]
263			* @param int $alpha [0, 127]
264			*
265			* @return ImageEditor
266			*/
267			public function colorize($red, $green, $blue, $alpha = 0)
268			{
269			imagefilter($this->resource, IMG_FILTER_COLORIZE, $red, $green, $blue, $alpha);
270			return $this;
271			}
272
273			/**
274			* Paste another image onto this one.
275			* @note Basically a wrapper method for http://www.php.net/manual/en/function.imagecopyresampled.php
276			*
277			* @param ImageEditor\|string $imageeditor
278			* @param int $dst_x
279			* @param int $dst_y
280			* @param int $dst_w
281			* @param int $dst_h
282			* @param int $src_x
283			* @param int $src_y
284			* @param int $src_w
285			* @param int $src_h
286			*/
287			public function pasteImage(
288			$imageeditor,
289			$dst_x = 0,
290			$dst_y = 0,
291			$dst_w = null,
292			$dst_h = null,
293			$src_x = null,
294			$src_y = null,
295			$src_w = null,
296			$src_h = null
297			) {
298			if (is_string($imageeditor)) {
299			$imageeditor = new ImageEditor($imageeditor);
300			}
301
302			if ($src_w === null) {
303			$src_w = $imageeditor->getWidth();
304			}
305			if ($src_h === null) {
306			$src_h = $imageeditor->getHeight();
307			}
308			if ($dst_w === null) {
309			$dst_w = $src_w;
310			}
311			if ($dst_h === null) {
312			$dst_h = $src_h;
313			}
314
315			imagealphablending($this->resource, true);
316
317			imagecopyresampled(
318			$this->resource,
319			$imageeditor->getResource(),
320			$dst_x,
321			$dst_y,
322			$src_x,
323			$src_y,
324			$dst_w,
325			$dst_h,
326			$src_w,
327			$src_h
328			);
329
330			imagealphablending($this->resource, false);
331
332			return $this;
333			}
334
335			/* -------- */
336
337			/**
338			* "Duplicates" the image.
339			* Basically unsets the filepath, so we have to use `saveAs()` and not `save()`.
340			*
341			* @return ImageEditor
342			*/
343			public function duplicate()
344			{
345			$this->filepath = null;
346			return $this;
347			}
348
349			/**
350			* Saves the image
351			*
352			* @param int $quality 0-100 (only for jpegs)
353			*
354			* @return ImageEditor
355			*/
356			public function save($quality = self::DEFAULT_JPEG_QUALITY)
357			{
358			if (!isset($this->filepath)) {
359			throw new \LogicException('Use saveTo() to save an unnamed file.');
360			}
361			return $this->saveAs($this->filepath, $quality);
362			}
363
364			/**
365			* Saves the image under a path
366			*
367			* @param string $filepath
368			* @param int $type IMAGETYPE constant
369			* @param int $quality 0-100 (only for jpegs)
370			*
371			* @return ImageEditor
372			*/
373			public function saveAs($filepath, $type = null, $quality = self::DEFAULT_JPEG_QUALITY)
374			{
375			$this->outputImage($filepath, $type, $quality);
376			$this->filepath = $filepath;
377
378			return $this;
379			}
380
381			/**
382			* Outputs the image with the correct header.
383			*
384			* @param int $quality 0-100 (only for jpegs)
385			*/
386			public function output($quality = self::DEFAULT_JPEG_QUALITY)
387			{
388			header('Content-type: ' . $this->mimetype);
389			$this->outputImage(null, $quality);
390			}
391
392			/**
393			* @param string $filepath
394			* @param int $type IMAGETYPE constant
395			* @param int $quality 0-100 (only for jpegs)
396			*/
397			private function outputImage($filepath = null, $type = null, $quality = self::DEFAULT_JPEG_QUALITY)
398			{
399			$type = !isset($type) ? $this->type : $type;
400
401			switch ($type) {
402			case IMAGETYPE_JPEG:
403			imagejpeg($this->resource, $filepath, $quality);
404			break;
405
406			case IMAGETYPE_PNG:
407			imagepng($this->resource, $filepath);
408			break;
409
410			case IMAGETYPE_GIF:
411			imagegif($this->resource, $filepath);
412			break;
413			}
414			}
415
416			/* -------- */
417
418			/**
419			* Retrieves format.
420			*/
421			private function extractFileData()
422			{
423			if (!$this->type = exif_imagetype($this->filepath)) {
424			throw new \Exception('Wrong file type');
425			}
426
427			$mimetypes = array(
428			IMAGETYPE_GIF => 'image/gif',
429			IMAGETYPE_JPEG => 'image/jpeg',
430			IMAGETYPE_PNG => 'image/png'
431			);
432
433			if (!array_key_exists($this->type, $mimetypes)) {
434			throw new \Exception('Unsupported image type');
435			}
436
437			$this->mimetype = $mimetypes[$this->type];
438			}
439
440			private function createResource()
441			{
442			switch ($this->type) {
443			case IMAGETYPE_GIF:
444			$this->setResource(imagecreatefromgif($this->filepath));
445			break;
446			case IMAGETYPE_JPEG:
447			$this->setResource(imagecreatefromjpeg($this->filepath));
448			break;
449			case IMAGETYPE_PNG:
450			$this->setResource(imagecreatefrompng($this->filepath));
451			break;
452			}
453			}
454
455			/**
456			* @param resource $resource
457			*/
458			private function setResource($resource)
459			{
460			if (is_resource($this->resource)) {
461			imagedestroy($this->resource);
462			}
463
464			$this->width = imagesx($resource);
465			$this->height = imagesy($resource);
466
467			imagealphablending($resource, false);
468			imagesavealpha($resource, true);
469
470			$this->resource = $resource;
471			}
472
473			/**
474			* @param int $width
475			* @param int $height
476			*
477			* @return resource
478			*/
479			private function createImage($width, $height)
480			{
481			$resource = imagecreatetruecolor($width, $height);
482
483			imagealphablending($resource, false);
484			imagesavealpha($resource, true);
485
486			return $resource;
487			}
488
489			/* -------- GETTER / SETTERS -------- */
490
491			/**
492			* Gets format of this image [IMAGETYPE_GIF\|IMAGETYPE_GIF\|IMAGETYPE_GIF]
493			*
494			* @return int
495			*/
496			public function getType()
497			{
498			return $this->type;
499			}
500
501			/**
502			* Gets mimetype
503			*
504			* @return string
505			*/
506			public function getMimeType()
507			{
508			return $this->mimetype;
509			}
510
511			/**
512			* Returns the width.
513			*
514			* @return int
515			*/
516			public function getWidth()
517			{
518			return $this->width;
519			}
520
521			/**
522			* Returns the height.
523			*
524			* @return int
525			*/
526			public function getHeight()
527			{
528			return $this->height;
529			}
530
531			/**
532			* @return resource
533			*/
534			public function getResource()
535			{
536			return $this->resource;
537			}
538			}
539

gwa / gwImageEditor

ImageEditor::save() A last analyzed 2016-04-26 07:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ImageEditor::save() A
last analyzed 2016-04-26 07:19 UTC