Picture::create() - Code Metrics - Inspection of "Feat: Refactor picture file" - video-games-records/core-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — develop ( 9333dd...574080 )

by BENARD
created 2023-05-06 17:58 UTC
Picture::create() A

↳ Parent: Picture
Complexity

Conditions	2
Paths	2
Size

Total Lines	12
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	9
c	0
b	0
f	0
dl	0
loc	12
rs	9.9666
cc	2
nc	2
nop	2
<?php

namespace VideoGamesRecords\CoreBundle\File;

use Exception;
use GdImage;

class Picture
{
    protected $picture = null;

    protected array $mimeTypes = [
        'bmp'  => 'image/bmp',
        'gif'  => 'image/gif',
        'jpeg' => 'image/jpeg',
        'jpg'  => 'image/jpeg',
        'png'  => 'image/png',
        'wbmp' => 'image/vnd.wap.wbmp',
        'xbm'  => 'image/x-xbitmap',
    ];

    private const EXTENSIONS = [
        'gd'   => ['generate' => 'imagegd', 'create' => 'imagecreatefromgd'],
        'gd2'  => ['generate' => 'imagegd2', 'create' => 'imagecreatefromgd2'],
        'gif'  => ['generate' => 'imagegif', 'create' => 'imagecreatefromgif'],
        'jpeg' => ['generate' => 'imagejpeg', 'create' => 'imagecreatefromjpeg'],
        'jpg'  => ['generate' => 'imagejpeg', 'create' => 'imagecreatefromjpeg'],
        'png'  => ['generate' => 'imagepng', 'create' => 'imagecreatefrompng'],
        'wbmp' => ['generate' => 'imagewbmp', 'create' => 'imagecreatefromwbmp'],
        'bmp'  => ['generate' => 'imagewbmp', 'create' => 'imagecreatefromwbmp'],
        'xbm'  => ['generate' => 'imagexbm', 'create' => 'imagecreatefromxbm']
    ];

    protected array $fonts = [];
    protected array $colors = [];

    protected ?string $activeColor = null;
    protected ?string $activeFont = null;


    /**
     * Picture constructor.
     * @param      $width
     * @param      $height
     * @param bool $trueColor
     */
    public function __construct($width, $height, bool $trueColor = true)
    {
        $width = (int) $width;
        $height = (int) $height;

        if ($trueColor) {
            $this->picture = imagecreatetruecolor($width, $height);
        } else {
            $this->picture = imagecreate($width, $height);
        }
    }

    /**
     * @param bool    $keepTrueColor
     * @param GdImage $picture
     * @return self
     */
    public static function create(bool $keepTrueColor, GdImage $picture): Picture
    {
        $oSelf = new self(imagesx($picture), imagesy($picture));
        if ($keepTrueColor) {
            $oSrc = new self(imagesx($picture), imagesy($picture));
            $oSrc->setPicture($picture);
            $oSelf->copyResized($oSrc, 0, 0);
            unset($oSrc);
        } else {
            $oSelf->setPicture($picture);
        }
        return $oSelf;
    }

    /**
     *
     */
    public function __destruct()
    {
        imagedestroy($this->picture);
    }

    /**
     * @param $picture
     * @return Picture
     */
    public function setPicture($picture): Picture
    {
        $this->picture = $picture;
        return $this;
    }

    /**
     * @return int
     */
    public function getWidth():int
    {
        return imagesx($this->picture);
    }

    /**
     * @return int
     */
    public function getHeight(): int
    {
        return imagesy($this->picture);
    }

    /**
     * @return false|resource|null
     */
    public function getPicture()
    {
        return $this->picture;

    }

    /**
     * @param $name
     * @return mixed
     * @throws Exception
     */
    public function getColor($name): mixed
    {
        if (!isset($this->colors[$name])) {
            throw new Exception('Unknown color ' . $name . '.');
        }
        $this->activeColor = $this->colors[$name];
        return $this->colors[$name];
    }

    /**
     * @param $name
     * @return mixed
     * @throws Exception
     */
    public function getFont($name): mixed
    {
        if (!isset($this->fonts[$name])) {
            throw new Exception('Unknown font ' . $name . '.');
        }
        $this->activeFont = $this->fonts[$name];
        return $this->fonts[$name];
    }

    /**
     * @param $name
     * @param $filePath
     * @return Picture
     * @throws Exception
     */
    public function addFont($name, $filePath): Picture
    {
        $fontPath = realpath($filePath);
        if ($fontPath === false) {
            throw new Exception('Unable to load font file. The file does not exists.');
        }
        $this->fonts[$name] = $fontPath;
        $this->activeFont = $fontPath;
        return $this;
    }

    /**
     * @param      $name
     * @param      $red
     * @param      $green
     * @param      $blue
     * @param      $alpha
     * @return Picture
     */
    public function addColor($name, $red, $green, $blue, $alpha = null): Picture
    {
        $red %= 256;
        $green %= 256;
        $blue %= 256;
        if ($alpha !== null) {
            $alpha %= 128;
            $color = imagecolorallocatealpha($this->picture, $red, $green, $blue, $alpha);
        } else {
            $color = imagecolorallocate($this->picture, $red, $green, $blue);
        }
        $this->colors[$name] = $color;
        $this->activeColor = $color;
        return $this;
    }

    /**
     * @param Picture $pic
     * @param                   $dstX
     * @param                   $dstY
     * @param int               $srcX
     * @param int               $srcY
     * @param null              $dstW

     * @param null              $dstH

     * @param null              $srcW

     * @param null              $srcH

     * @return Picture
     */
    public function copyResized(
        Picture $pic,
        $dstX,
        $dstY,
        $srcX = 0,
        $srcY = 0,
        $dstW = null,
        $dstH = null,
        $srcW = null,
        $srcH = null
    ): Picture {
        $dstW = is_null($dstW) ? $pic->getWidth() : $dstW;

        $dstH = is_null($dstH) ? $pic->getHeight() : $dstH;

        $srcW = is_null($srcW) ? $pic->getWidth() : $srcW;

        $srcH = is_null($srcH) ? $pic->getHeight() : $srcH;


        imagecopyresized($this->picture, $pic->getPicture(), $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH);
        return $this;
    }

    /**
     * @param      $xA
     * @param      $yA
     * @param      $xB
     * @param      $yB
     * @param null $color

     * @return Picture
     * @throws Exception
     */
    public function addRectangle($xA, $yA, $xB, $yB, $color = null): Picture
    {
        if ($color === null) {

            $color = $this->activeColor;
            if ($color === null) {
                throw new Exception('No active color defined.');
            }
        }
        imagefilledrectangle($this->picture, $xA, $yA, $xB, $yB, $color);
        imagefilledrectangle($this->picture, $xA, $yA, $xB, $yB, /** @scrutinizer ignore-type */ $color);
        return $this;
    }

    /**
     * @param      $message
     * @param      $size
     * @param      $x
     * @param      $y
     * @param int  $angle
     * @param null $color

     * @param null $font

     * @return Picture
     * @throws Exception
     */
    public function write($message, $size, $x, $y, int $angle = 0, $color = null, $font = null): Picture
    {
        if ($color === null) {

            $color = $this->activeColor;
            if ($color === null) {
                throw new Exception('No active color defined.');
            }
        }
        if ($font === null) {

            $font = $this->activeFont;
            if ($font === null) {
                throw new Exception('No active font defined.');
            }
        }
        imagettftext($this->picture, $size, $angle, $x, $y, $color, $font, $message);
        imagettftext($this->picture, $size, $angle, $x, $y, /** @scrutinizer ignore-type */ $color, $font, $message);
        return $this;
    }

    /**
     * @param      $file
     * @param bool $keepTrueColor
     * @return Picture
     * @throws Exception
     */
    public static function loadFile($file, bool $keepTrueColor = false): Picture
    {
        $file = realpath($file);
        if ($file === false) {
            throw new Exception('Unable to load picture file. The file does not exists.');
        }

        $extension = mb_strtolower(pathinfo($file, PATHINFO_EXTENSION));
        $extension = mb_strtolower(/** @scrutinizer ignore-type */ pathinfo($file, PATHINFO_EXTENSION));

        if (!array_key_exists($extension, self::EXTENSIONS)) {
            throw new Exception('Unknown extension of file when converting to PHP resource.');
        }

        $method = self::getCreateMethod($extension);
        $picture = $method($file);

        return self::create($keepTrueColor, $picture);
    }

    /**
     * @param string $data
     * @param bool $keepTrueColor
     * @return Picture
     * @throws Exception
     */
    public static function loadFileFromStream(string $data, bool $keepTrueColor = false): Picture
    {
        $picture = imagecreatefromstring($data);

        return self::create($keepTrueColor, $picture);
        return self::create($keepTrueColor, /** @scrutinizer ignore-type */ $picture);
    }

    /**
     * @param        $type
     * @param string $filename
     * @throws Exception
     */
    public function downloadPicture($type, string $filename): void
    {
        header('Content-Disposition: "attachement"; filename="' . $filename . '"');
        $this->showPicture($type);
    }

    /**
     * @param $type
     * @throws Exception
     */
    public function showPicture($type)
    {
        $method = $this->getGererateMethod($type);
        $contentType = $this->getMimeType($type);

        header('Content-Type: ' . $contentType);
        $method($this->picture);
        exit;

    }

    /**
     * @param $filename
     * @return $this
     * @throws Exception
     */
    public function savePicture($filename): static
    {
        $sExtension = pathinfo($filename, PATHINFO_EXTENSION);
        $method = $this->getGererateMethod($sExtension);

        $method($this->picture, $filename);
        return $this;
    }

    /**
     * @param $type
     * @return string
     * @throws Exception
     */
    protected function getGererateMethod($type): string
    {
        if (!array_key_exists($type, self::EXTENSIONS)) {
            throw new Exception('Unknown picture type.');
        }
        return self::EXTENSIONS[$type]['generate'];
    }

    /**
     * @param $type
     * @return string
     * @throws Exception
     */
    protected static function getCreateMethod($type): string
    {
        if (!array_key_exists($type, self::EXTENSIONS)) {
            throw new Exception('Unknown picture type.');
        }
        return self::EXTENSIONS[$type]['create'];
    }

    /**
     * @param $extension
     * @return mixed|string
     */
    public function getMimeType($extension): mixed
    {
        if (!isset($this->mimeTypes[$extension])) {
            return 'application/octet-stream';
        }
        return $this->mimeTypes[$extension];
    }
}

video-games-records / core-bundle

Push — develop ( 9333dd...574080 )

Picture::create() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
