Image::export() - Code Metrics - Inspection of "Image manipulations" - suricate-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#19)

by Mathieu

created 2020-03-24 21:35 UTC

Image::export() A

↳ Parent: Image

Complexity

Conditions	6
Paths	6

Size

Total Lines	19
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	17
c	1
b	0
f	0
nc	6
nop	2
dl	0
loc	19
ccs	0
cts	17
cp	0
crap	42
rs	9.0777

<?php

declare(strict_types=1);

namespace Suricate;

use InvalidArgumentException;
use RuntimeException;

class Image
{
    use Traits\ImageFilter;

    public $source;
    private $destination;

    private $width;
    private $height;

    public function load($filename)
    {
        if (is_file($filename) && ($imgString = file_get_contents($filename))) {
            $imgString = imagecreatefromstring($imgString);
            if ($imgString !== false) {
                $this->source = $imgString;
                $this->destination = $this->source;
                $this->width = imagesx($this->source);
                $this->height = imagesy($this->source);

                return $this;
            }

            throw new InvalidArgumentException(
                'Cannot load ' . $filename . ', not an image'
            );
        }

        throw new InvalidArgumentException(
            'Cannot load ' . $filename . ', file unreadable'
        );
    }

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

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

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

    public function setResource($source)
    {
        if (!is_resource($source)) {
            throw new InvalidArgumentException("Invalid source");
        }

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

        return $this;
    }

    public function create(int $width, int $height)
    {
        $this->source = imagecreatetruecolor($width, $height);
        $this->destination = $this->source;
        $this->width = $width;
        $this->height = $height;

        return $this;
    }

    /**
     * Fill an image with a color
     *
     * @param integer $pointX  X point coordinate
     * @param integer $pointY  Y point coordinate
     * @param array   $color   RGB color
     *
     */
    public function fill(int $pointX, int $pointY, $color = [0, 0, 0])
    {
        $color = imagecolorallocate(
            $this->destination,
            $color[0],
            $color[1],
            $color[2]
        );

        imagefill($this->destination, $pointX, $pointY, $color);

        return $this->chain();
    }

    /**
     * Return true if image is in portrait mode
     *
     * @return boolean
     */
    public function isPortrait(): bool
    {
        return $this->width < $this->height;
    }

    /**
     * Return true if image is in landscape mode
     *
     * @return boolean
     */
    public function isLandscape(): bool
    {
        return $this->height < $this->width;
    }

    /**
     * Apply modification to destination image
     *
     */
    public function chain(): self
    {
        $this->source = $this->destination;
        $this->width = imagesx($this->source);
        $this->height = imagesy($this->source);

        return $this;
    }

    public function resize($width = null, $height = null)
    {
        if ($this->source) {
            if ($width == null) {
                $width = intval(
                    round(($height / $this->height) * $this->width, 0)
                );
            } elseif ($height == null) {
                $height = intval(
                    round(($width / $this->width) * $this->height, 0)
                );
            }

            $this->destination = imagecreatetruecolor($width, $height);
            if ($this->destination === false) {
                throw new RuntimeException("Can't create destination image");
            }
            imagecopyresampled(
                $this->destination,
                $this->source,
                0,
                0,
                0,
                0,
                $width,
                $height,
                $this->width,
                $this->height
            );

            return $this->chain();
        }
        return $this;
    }

    public function crop($width, $height)
    {
        $centerX = round($this->width / 2);
        $centerY = round($this->height / 2);

        $cropWidthHalf = round($width / 2);
        $cropHeightHalf = round($height / 2);

        $x1 = intval(max(0, $centerX - $cropWidthHalf));
        $y1 = intval(max(0, $centerY - $cropHeightHalf));

        $this->destination = imagecreatetruecolor($width, $height);
        if ($this->destination === false) {
            throw new RuntimeException("Can't create destination image");
        }
        imagecopy(
            $this->destination,
            $this->source,
            0,
            0,
            $x1,
            $y1,
            $width,
            $height
        );

        return $this->chain();
    }

    public function resizeCanvas(
        $width,
        $height,
        $position = null,
        $color = [0, 0, 0]
    ) {
        $this->destination = imagecreatetruecolor($width, $height);
        if ($this->destination === false) {
            throw new RuntimeException("Can't create destination image");
        }
        $colorRes = imagecolorallocate(
            $this->destination,
            $color[0],
            $color[1],
            $color[2]
        );
        $imageObj = new Image();
        $imageObj->width = $width;
        $imageObj->height = $height;
        imagefill($this->destination, 0, 0, $colorRes);

        if ($position !== null) {
            list($x, $y) = $imageObj->getCoordinatesFromString(
                $position,
                $this->width,
                $this->height
            );
        } else {
            $x = 0;
            $y = 0;
        }
        imagecopy(
            $this->destination,
            $this->source,
            $x,
            $y,
            0,
            0,
            $this->width,
            $this->height
        );

        return $this->chain();
    }

    public function rotate()
    {
    }

    public function mirror()
    {
    }

    public function flip()
    {
    }

    public function merge(
        $source,
        $position = null,
        $x = null,
        $y = null,
        $percent = 100
    ) {
        if ($source instanceof \Suricate\Image) {
        } else {
            $source = with(new Image())->load($source);
        }

        if ($position !== null) {
            list($x, $y) = $this->getCoordinatesFromString(
                $position,
                $source->width,
                $source->height
            );
        }
        $x = $x !== null ? $x : 0;
        $y = $y !== null ? $y : 0;

        // Handle transparent image
        // creating a cut resource
        $cut = imagecreatetruecolor($source->getWidth(), $source->getHeight());
        if ($cut === false) {
            throw new RuntimeException("Can't create destination image");
        }
        // copying relevant section from background to the cut resource
        imagecopy(
            $cut,
            $this->destination,
            0,
            0,
            $x,
            $y,
            $source->getWidth(),
            $source->getHeight()
        );

        // copying relevant section from watermark to the cut resource
        imagecopy(
            $cut,
            $source->source,
            0,
            0,
            0,
            0,
            $source->getWidth(),
            $source->getHeight()
        );

        imagecopymerge(
            $this->destination,
            $cut,
            $x,
            $y,
            0,
            0,
            $source->getWidth(),
            $source->getHeight(),
            $percent
        );

        return $this->chain();
    }

    public function writeText($text, $x = 0, $y = 0, \Closure $callback = null)
    {
        if ($x < 0) {
            $x = $this->width + $x;
        }
        if ($y < 0) {
            $y = $this->height + $y;
        }
        $imageFont = new ImageFont($text);

        if ($callback != null) {
            $callback($imageFont);
        }

        $imageFont->apply($this->source, $x, $y);

        return $this;
    }

    public function line($x1, $y1, $x2, $y2, \Closure $callback = null)
    {
        $imageShape = new ImageShape();
        $imageShape->setImage($this->source);
        if ($callback != null) {
            $callback($imageShape);
        }

        $imageShape->drawLine($x1, $y1, $x2, $y2);

        return $this;
    }

    /**
     * Export image
     *
     * @param string $outputType output format
     * @param integer $quality   Output quality, when available
     *
     * @return void
     */
    public function export($outputType, $quality = 70)
    {
        switch ($outputType) {
            case 'jpg':
            case 'jpeg':
                imagejpeg($this->source, null, $quality);
                break;
            case 'png':
                imagepng($this->source);
                break;
            case 'gif':
                imagegif($this->source);
                break;
            case 'webp':
                imagewebp($this->source, null, $quality);
                break;
            default:
                throw new InvalidArgumentException(
                    sprintf("Invalid output format %s", $outputType)
                );
        }
    }

    public function save($filename, $outputType = null, $quality = 70)
    {
        $result = false;

        $extension =
            $outputType === null
                ? pathinfo($filename, PATHINFO_EXTENSION)
                : $outputType;

        if ($extension !== false) {
            switch (strtolower($extension)) {
                case 'jpg':
                case 'jpeg':
                    $result = imagejpeg($this->source, $filename, $quality);
                    break;
                case 'png':
                    $result = imagepng($this->source, $filename);
                    break;
                case 'gif':
                    $result = imagegif($this->source, $filename);
                    break;
                case 'webp':
                    $result = imagewebp($this->source, $filename, $quality);
                    break;
            }
        }

        return $result;
    }

    private function getCoordinatesFromString(
        $position,
        $offsetWidth = 0,
        $offsetHeight = 0
    ) {
        switch ($position) {
            case 'top':
                $x = floor($this->width / 2 - $offsetWidth / 2);
                $y = 0;
                break;
            case 'top-right':
                $x = $this->width - $offsetWidth;
                $y = 0;
                break;
            case 'left':
                $x = 0;
                $y = floor($this->height / 2 - $offsetHeight / 2);
                break;
            case 'center':
                $x = floor($this->width / 2 - $offsetWidth / 2);
                $y = floor($this->height / 2 - $offsetHeight / 2);
                break;
            case 'right':
                $x = $this->width - $offsetWidth;
                $y = floor($this->height / 2 - $offsetHeight / 2);
                break;
            case 'bottom-left':
                $x = 0;
                $y = $this->height - $offsetHeight;
                break;
            case 'bottom':
                $x = floor($this->width / 2 - $offsetWidth / 2);
                $y = $this->height - $offsetHeight;
                break;
            case 'bottom-right':
                $x = $this->width - $offsetWidth;
                $y = $this->height - $offsetHeight;
                break;

            case 'top-left':
            default:
                $x = 0;
                $y = 0;
                break;
        }

        return [intval($x), intval($y)];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Suricate;
6
7			use InvalidArgumentException;
8			use RuntimeException;
9
10			class Image
11			{
12			use Traits\ImageFilter;
13
14			public $source;
15			private $destination;
16
17			private $width;
18			private $height;
19
20			public function load($filename)
21			{
22			if (is_file($filename) && ($imgString = file_get_contents($filename))) {
23			$imgString = imagecreatefromstring($imgString);
24			if ($imgString !== false) {
25			$this->source = $imgString;
26			$this->destination = $this->source;
27			$this->width = imagesx($this->source);
28			$this->height = imagesy($this->source);
29
30			return $this;
31			}
32
33			throw new InvalidArgumentException(
34			'Cannot load ' . $filename . ', not an image'
35			);
36			}
37
38			throw new InvalidArgumentException(
39			'Cannot load ' . $filename . ', file unreadable'
40			);
41			}
42
43			public function getWidth()
44			{
45			return $this->width;
46			}
47
48			public function getHeight()
49			{
50			return $this->height;
51			}
52
53			public function getResource()
54			{
55			return $this->source;
56			}
57
58			public function setResource($source)
59			{
60			if (!is_resource($source)) {
61			throw new InvalidArgumentException("Invalid source");
62			}
63
64			$this->source = $source;
65			$this->width = imagesx($this->source);
66			$this->height = imagesy($this->source);
67
68			return $this;
69			}
70
71			public function create(int $width, int $height)
72			{
73			$this->source = imagecreatetruecolor($width, $height);
74			$this->destination = $this->source;
75			$this->width = $width;
76			$this->height = $height;
77
78			return $this;
79			}
80
81			/**
82			* Fill an image with a color
83			*
84			* @param integer $pointX X point coordinate
85			* @param integer $pointY Y point coordinate
86			* @param array $color RGB color
87			*
88			*/
89			public function fill(int $pointX, int $pointY, $color = [0, 0, 0])
90			{
91			$color = imagecolorallocate(
92			$this->destination,
93			$color[0],
94			$color[1],
95			$color[2]
96			);
97
98			imagefill($this->destination, $pointX, $pointY, $color);
99
100			return $this->chain();
101			}
102
103			/**
104			* Return true if image is in portrait mode
105			*
106			* @return boolean
107			*/
108			public function isPortrait(): bool
109			{
110			return $this->width < $this->height;
111			}
112
113			/**
114			* Return true if image is in landscape mode
115			*
116			* @return boolean
117			*/
118			public function isLandscape(): bool
119			{
120			return $this->height < $this->width;
121			}
122
123			/**
124			* Apply modification to destination image
125			*
126			*/
127			public function chain(): self
128			{
129			$this->source = $this->destination;
130			$this->width = imagesx($this->source);
131			$this->height = imagesy($this->source);
132
133			return $this;
134			}
135
136			public function resize($width = null, $height = null)
137			{
138			if ($this->source) {
139			if ($width == null) {
140			$width = intval(
141			round(($height / $this->height) * $this->width, 0)
142			);
143			} elseif ($height == null) {
144			$height = intval(
145			round(($width / $this->width) * $this->height, 0)
146			);
147			}
148
149			$this->destination = imagecreatetruecolor($width, $height);
150			if ($this->destination === false) {
151			throw new RuntimeException("Can't create destination image");
152			}
153			imagecopyresampled(
154			$this->destination,
155			$this->source,
156			0,
157			0,
158			0,
159			0,
160			$width,
161			$height,
162			$this->width,
163			$this->height
164			);
165
166			return $this->chain();
167			}
168			return $this;
169			}
170
171			public function crop($width, $height)
172			{
173			$centerX = round($this->width / 2);
174			$centerY = round($this->height / 2);
175
176			$cropWidthHalf = round($width / 2);
177			$cropHeightHalf = round($height / 2);
178
179			$x1 = intval(max(0, $centerX - $cropWidthHalf));
180			$y1 = intval(max(0, $centerY - $cropHeightHalf));
181
182			$this->destination = imagecreatetruecolor($width, $height);
183			if ($this->destination === false) {
184			throw new RuntimeException("Can't create destination image");
185			}
186			imagecopy(
187			$this->destination,
188			$this->source,
189			0,
190			0,
191			$x1,
192			$y1,
193			$width,
194			$height
195			);
196
197			return $this->chain();
198			}
199
200			public function resizeCanvas(
201			$width,
202			$height,
203			$position = null,
204			$color = [0, 0, 0]
205			) {
206			$this->destination = imagecreatetruecolor($width, $height);
207			if ($this->destination === false) {
208			throw new RuntimeException("Can't create destination image");
209			}
210			$colorRes = imagecolorallocate(
211			$this->destination,
212			$color[0],
213			$color[1],
214			$color[2]
215			);
216			$imageObj = new Image();
217			$imageObj->width = $width;
218			$imageObj->height = $height;
219			imagefill($this->destination, 0, 0, $colorRes);
220
221			if ($position !== null) {
222			list($x, $y) = $imageObj->getCoordinatesFromString(
223			$position,
224			$this->width,
225			$this->height
226			);
227			} else {
228			$x = 0;
229			$y = 0;
230			}
231			imagecopy(
232			$this->destination,
233			$this->source,
234			$x,
235			$y,
236			0,
237			0,
238			$this->width,
239			$this->height
240			);
241
242			return $this->chain();
243			}
244
245			public function rotate()
246			{
247			}
248
249			public function mirror()
250			{
251			}
252
253			public function flip()
254			{
255			}
256
257			public function merge(
258			$source,
259			$position = null,
260			$x = null,
261			$y = null,
262			$percent = 100
263			) {
264			if ($source instanceof \Suricate\Image) {
265			} else {
266			$source = with(new Image())->load($source);
267			}
268
269			if ($position !== null) {
270			list($x, $y) = $this->getCoordinatesFromString(
271			$position,
272			$source->width,
273			$source->height
274			);
275			}
276			$x = $x !== null ? $x : 0;
277			$y = $y !== null ? $y : 0;
278
279			// Handle transparent image
280			// creating a cut resource
281			$cut = imagecreatetruecolor($source->getWidth(), $source->getHeight());
282			if ($cut === false) {
283			throw new RuntimeException("Can't create destination image");
284			}
285			// copying relevant section from background to the cut resource
286			imagecopy(
287			$cut,
288			$this->destination,
289			0,
290			0,
291			$x,
292			$y,
293			$source->getWidth(),
294			$source->getHeight()
295			);
296
297			// copying relevant section from watermark to the cut resource
298			imagecopy(
299			$cut,
300			$source->source,
301			0,
302			0,
303			0,
304			0,
305			$source->getWidth(),
306			$source->getHeight()
307			);
308
309			imagecopymerge(
310			$this->destination,
311			$cut,
312			$x,
313			$y,
314			0,
315			0,
316			$source->getWidth(),
317			$source->getHeight(),
318			$percent
319			);
320
321			return $this->chain();
322			}
323
324			public function writeText($text, $x = 0, $y = 0, \Closure $callback = null)
325			{
326			if ($x < 0) {
327			$x = $this->width + $x;
328			}
329			if ($y < 0) {
330			$y = $this->height + $y;
331			}
332			$imageFont = new ImageFont($text);
333
334			if ($callback != null) {
335			$callback($imageFont);
336			}
337
338			$imageFont->apply($this->source, $x, $y);
339
340			return $this;
341			}
342
343			public function line($x1, $y1, $x2, $y2, \Closure $callback = null)
344			{
345			$imageShape = new ImageShape();
346			$imageShape->setImage($this->source);
347			if ($callback != null) {
348			$callback($imageShape);
349			}
350
351			$imageShape->drawLine($x1, $y1, $x2, $y2);
352
353			return $this;
354			}
355
356			/**
357			* Export image
358			*
359			* @param string $outputType output format
360			* @param integer $quality Output quality, when available
361			*
362			* @return void
363			*/
364			public function export($outputType, $quality = 70)
365			{
366			switch ($outputType) {
367			case 'jpg':
368			case 'jpeg':
369			imagejpeg($this->source, null, $quality);
370			break;
371			case 'png':
372			imagepng($this->source);
373			break;
374			case 'gif':
375			imagegif($this->source);
376			break;
377			case 'webp':
378			imagewebp($this->source, null, $quality);
379			break;
380			default:
381			throw new InvalidArgumentException(
382			sprintf("Invalid output format %s", $outputType)
383			);
384			}
385			}
386
387			public function save($filename, $outputType = null, $quality = 70)
388			{
389			$result = false;
390
391			$extension =
392			$outputType === null
393			? pathinfo($filename, PATHINFO_EXTENSION)
394			: $outputType;
395
396			if ($extension !== false) {
397			switch (strtolower($extension)) {
398			case 'jpg':
399			case 'jpeg':
400			$result = imagejpeg($this->source, $filename, $quality);
401			break;
402			case 'png':
403			$result = imagepng($this->source, $filename);
404			break;
405			case 'gif':
406			$result = imagegif($this->source, $filename);
407			break;
408			case 'webp':
409			$result = imagewebp($this->source, $filename, $quality);
410			break;
411			}
412			}
413
414			return $result;
415			}
416
417			private function getCoordinatesFromString(
418			$position,
419			$offsetWidth = 0,
420			$offsetHeight = 0
421			) {
422			switch ($position) {
423			case 'top':
424			$x = floor($this->width / 2 - $offsetWidth / 2);
425			$y = 0;
426			break;
427			case 'top-right':
428			$x = $this->width - $offsetWidth;
429			$y = 0;
430			break;
431			case 'left':
432			$x = 0;
433			$y = floor($this->height / 2 - $offsetHeight / 2);
434			break;
435			case 'center':
436			$x = floor($this->width / 2 - $offsetWidth / 2);
437			$y = floor($this->height / 2 - $offsetHeight / 2);
438			break;
439			case 'right':
440			$x = $this->width - $offsetWidth;
441			$y = floor($this->height / 2 - $offsetHeight / 2);
442			break;
443			case 'bottom-left':
444			$x = 0;
445			$y = $this->height - $offsetHeight;
446			break;
447			case 'bottom':
448			$x = floor($this->width / 2 - $offsetWidth / 2);
449			$y = $this->height - $offsetHeight;
450			break;
451			case 'bottom-right':
452			$x = $this->width - $offsetWidth;
453			$y = $this->height - $offsetHeight;
454			break;
455
456			case 'top-left':
457			default:
458			$x = 0;
459			$y = 0;
460			break;
461			}
462
463			return [intval($x), intval($y)];
464			}
465			}
466

suricate-php / framework

Pull Request — master (#19)

Image::export() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like