Image::__construct() - Code Metrics - Inspection of "dependency update" - mambax7/xoopseditors - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6ebac0...a0be99 )

by Michael
created 2022-06-12 05:36 UTC
Image::__construct() A

↳ Parent: Image
Complexity

Conditions	5
Paths	7
Size

Total Lines	32
Code Lines	21
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	5
eloc	21
c	1
b	0
f	0
nc	7
nop	1
dl	0
loc	32
rs	9.2728
<?php
/**
 * Styx::Image - Provides an Interface to the GD-Library for image manipulation
 *
 * @package    Styx
 * @subpackage Utility
 *
 * @license    MIT-style License
 * @author     Christoph Pojer <[email protected]>
 *
 * @link       http://www.bin-co.com/php/scripts/classes/gd_image/ Based on work by "Binny V A"
 */

class Image
{
    /**
     * The path to the image file
     *
     * @var string
     */
    private $file;
    /**
     * The image resource
     *
     * @var resource
     */
    private $image;
    /**
     * Metadata regarding the image
     *
     * @var array
     */
    private $meta;

    /**
     * @param string $file The path to the image file
     */
    public function __construct($file)
    {
        $file = realpath($file);
        if (!file_exists($file)) {
            return;
        }

        $this->file = $file;
        $img        = getimagesize($file);

        $this->meta = [
            'width'  => $img[0],
            'height' => $img[1],
            'mime'   => $img['mime'],
            'ext'    => end(explode('/', $img['mime'])),
        ];
        if ('jpg' == $this->meta['ext']) {
            $this->meta['ext'] = 'jpeg';
        }

        if (!in_array($this->meta['ext'], ['gif', 'png', 'jpeg'])) {
            return;
        }

        if (in_array($this->meta['ext'], ['gif', 'png'])) {
            $this->image = $this->create();

            $fn       = 'imagecreatefrom' . $this->meta['ext'];
            $original = $fn($file);
            imagecopyresampled($this->image, $original, 0, 0, 0, 0, $this->meta['width'], $this->meta['height'], $this->meta['width'], $this->meta['height']);
        } else {
            $this->image = imagecreatefromjpeg($file);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        }
    }

    public function __destruct()
    {
        if (!empty($this->image)) {
            imagedestroy($this->image);
        }
    }

    /**
     * Returns the size of the image
     *
     * @return array
     */
    public function getSize()
    {
        return [
            'width'  => $this->meta['width'],
            'height' => $this->meta['height'],
        ];
    }

    /**
     * Creates a new, empty image with the desired size
     *
     * @param int    $x
     * @param int    $y
     * @param string $ext
     * @return resource
     */
    private function create($x = null, $y = null, $ext = null)
    {
        if (!$x) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $x = $this->meta['width'];
        }
        if (!$y) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $y = $this->meta['height'];
        }

        $image = imagecreatetruecolor($x, $y);
        if (!$ext) {
            $ext = $this->meta['ext'];
        }
        if ('png' == $ext) {
            imagealphablending($image, false);
            imagefilledrectangle($image, 0, 0, $x, $y, imagecolorallocatealpha($image, 0, 0, 0, 127));
        }

        return $image;

    }

    /**
     * Replaces the image resource with the given parameter
     *
     * @param resource $new
     */
    private function set($new)
    {
        imagedestroy($this->image);
        $this->image = $new;

        $this->meta['width']  = imagesx($this->image);
        $this->meta['height'] = imagesy($this->image);
    }

    /**
     * Returns the path to the image file
     *
     * @return string
     */
    public function getPathname()
    {
        return $this->file;
    }

    /**
     * Rotates the image by the given angle
     *
     * @param int   $angle
     * @param array $bgcolor An indexed array with red/green/blue/alpha values
     * @return Image
     */
    public function rotate($angle, $bgcolor = null)
    {
        if (empty($this->image) || !$angle || $angle >= 360) {
            return $this;
        }

        $this->set(imagerotate($this->image, $angle, is_array($bgcolor) ? imagecolorallocatealpha($this->image, $bgcolor[0], $bgcolor[1], $bgcolor[2], !empty($bgcolor[3]) ? $bgcolor[3] : null) : $bgcolor));
        $this->set(/** @scrutinizer ignore-type */ imagerotate($this->image, $angle, is_array($bgcolor) ? imagecolorallocatealpha($this->image, $bgcolor[0], $bgcolor[1], $bgcolor[2], !empty($bgcolor[3]) ? $bgcolor[3] : null) : $bgcolor));

        return $this;
    }

    /**
     * Resizes the image to the given size, automatically calculates
     * the new ratio if parameter {@link $ratio} is set to true
     *
     * @param int  $x
     * @param int  $y
     * @param bool $ratio
     * @return Image
     */
    public function resize($x = null, $y = null, $ratio = true)
    {
        if (empty($this->image) || (!$x && !$y)) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return $this;
        }

        if (!$y) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $y = $ratio ? $this->meta['height'] * $x / $this->meta['width'] : $this->meta['height'];
        }
        if (!$x) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $x = $ratio ? $this->meta['width'] * $y / $this->meta['height'] : $this->meta['width'];
        }

        $new = $this->create($x, $y);
        imagecopyresampled($new, $this->image, 0, 0, 0, 0, $x, $y, $this->meta['width'], $this->meta['height']);
        $this->set($new);

        return $this;
    }

    /**
     * Crops the image. The values are given like margin/padding values in css
     *
     * <b>Example</b>
     * <ul>
     * <li>crop(10) - Crops by 10px on all sides</li>
     * <li>crop(10, 5) - Crops by 10px on top and bottom and by 5px on left and right sides</li>
     * <li>crop(10, 5, 5) - Crops by 10px on top and by 5px on left, right and bottom sides</li>
     * <li>crop(10, 5, 3, 2) - Crops by 10px on top, 5px by right, 3px by bottom and 2px by left sides</li>
     * </ul>
     *
     * @param int $top
     * @param int $right
     * @param int $bottom
     * @param int $left
     * @return Image
     */
    public function crop($top, $right = null, $bottom = null, $left = null)
    {
        if (empty($this->image)) {
            return $this;
        }

        if (!is_numeric($right) && !is_numeric($bottom) && !is_numeric($left)) {
            $right = $bottom = $left = $top;
        }

        if (!is_numeric($bottom) && !is_numeric($left)) {
            $bottom = $top;
            $left   = $right;
        }

        if (!is_numeric($left)) {
            $left = $right;
        }

        $x = $this->meta['width'] - $left - $right;
        $y = $this->meta['height'] - $top - $bottom;

        if ($x < 0 || $y < 0) {
            return $this;
        }

        $new = $this->create($x, $y);
        imagecopy($new, $this->image, 0, 0, $left, $top, $x, $y);
        $this->set($new);

        return $this;
    }

    /**
     * Flips the image horizontally or vertically. To Flip both just use ->rotate(180)
     *
     * @param string $type Either horizontal or vertical
     * @return Image
     * @see Image::rotate()
     */
    public function flip($type)
    {
        if (empty($this->image) || !in_array($type, ['horizontal', 'vertical'])) {
            return $this;
        }

        $new = $this->create();

        if ('horizontal' == $type) {
            for ($x = 0; $x < $this->meta['width']; $x++) {
                imagecopy($new, $this->image, $this->meta['width'] - $x - 1, 0, $x, 0, 1, $this->meta['height']);
            }
        } elseif ('vertical' == $type) {
            for ($y = 0; $y < $this->meta['height']; $y++) {
                imagecopy($new, $this->image, 0, $this->meta['height'] - $y - 1, 0, $y, $this->meta['width'], 1);
            }
        }

        $this->set($new);

        return $this;
    }

    /**
     * Stores the image in the desired directory or outputs it
     *
     * @param string $ext
     * @param string $file
     */
    private function process($ext = null, $file = null)
    {
        if (!$ext) {
            $ext = $this->meta['ext'];
        }

        if ('png' == $ext) {
            imagesavealpha($this->image, true);
        }
        $fn = 'image' . $ext;
        $fn($this->image, $file);

        // If there is a new filename change the internal name too
        if ($file) {
            $this->file = $file;
        }
    }

    /**
     * Saves the image to the given path
     *
     * @param string $file Leave empty to replace the original file
     * @return Image
     */
    public function save($file = null)
    {
        if (empty($this->image)) {
            return $this;
        }

        if (!$file) {
            $file = $this->file;
        }

        $ext = strtolower(pathinfo($file, PATHINFO_EXTENSION));
        $ext = strtolower(/** @scrutinizer ignore-type */ pathinfo($file, PATHINFO_EXTENSION));
        if (!$ext) {
            $file .= '.' . $this->meta['ext'];
            $ext  = $this->meta['ext'];
        }

        if ('jpg' == $ext) {
            $ext = 'jpeg';
        }

        if (!in_array($ext, ['png', 'jpeg', 'gif'])) {
            return $this;
        }

        $this->process($ext, $file);

        return $this;
    }

    /**
     * Outputs the manipulated image
     *
     * @return Image
     */
    public function show()
    {
        if (empty($this->image)) {
            return $this;
        }

        header('Content-type: ' . $this->meta['mime']);
        $this->process();

        return $this;
    }

}

mambax7 / xoopseditors

Push — master ( 6ebac0...a0be99 )

Image::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
