Gwa\Image\ImageEditor

Complexity

Total Complexity

55

Size/Duplication

Total Lines	532
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	12
Bugs	3	Features	1

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	4
A	__destruct()	0	6	2
A	resizeToWithin()	0	10	2
A	resizeTo()	0	13	3
A	resizeToDimensions()	0	4	1
A	resizeImage()	0	17	1
A	crop()	0	22	3
A	cropFromCenter()	0	7	1
A	rotateClockwise()	0	4	1
A	rotateCounterClockwise()	0	4	1
A	rotate180()	0	4	1
A	rotate()	0	6	1
A	grayscale()	0	5	1
A	coloroverlay()	0	8	1
A	colorize()	0	5	1
B	pasteImage()	0	47	6
A	duplicate()	0	5	1
A	save()	0	7	2
A	saveAs()	0	7	1
A	output()	0	5	1
B	outputImage()	0	18	5
A	extractFileData()	0	18	3
A	createResource()	0	14	4
A	setResource()	0	14	2
A	createImage()	0	9	1
A	getType()	0	4	1
A	getMimeType()	0	4	1
A	getWidth()	0	4	1
A	getHeight()	0	4	1
A	getResource()	0	4	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;
    }
}