Create image using PHP functions, but with "inline" code

Question

NOTE: it seems some think I am asking the question "Should I use this code style?", but I am actually asking "How can I achieve this?". Sorry If my question is confusing.

To create an image with PHP you can use these kind of base functions:

http://php.net/manual/en/ref.image.php

But by default it seems rather static. Example:

/* file: PHPImage.php */

$img = imagecreatefrompng('logo.png');

// Do some stuff to that image

header('Content-type: image/png');
imagepng($img);
imagedestroy($img);

I would like to create a class that can manipulate images on the fly and pass it a function that can manipulate the $img on a call back, and do all of that inline.. something like this:

<?php
    $img = new PHPImage("baseimage.png", function(&$thisimg){
        // Color functions here etc
    });
?>

<img src="<?php echo $img->URLResource; ?>" />

I see that this is a feeble example but just wondering if this kind of workflow is possible.

What I'm wondering is: I get that you could pass GET parameters to a constant page setup for this eg. scripts/PHPImage.php?w=160&h=160&bgcol=255-0-0, and then use the passed parameters to run the actual image functions on that page. But is there anyway you could use the actual functions on the image and generate it in a casual workflow, like my PHPImage class example above?

Thanks in advance for any help!

Answer 1

For an example

<?php
echo "<pre>";

class PHPImage{
    protected $callback;
    protected $src = '';
    protected $image = null;
    protected $type = null;

    public function __construct($src, $callback=null){
        $this->src = $src;
        $this->type = exif_imagetype($this->src);
        $this->image = $this->open($this->src);

        $this->callback = $callback->bindTo($this); 
        //bingTo, changes scope to this class
        //that lets us access internal methods
        //for exmaple if we had a method PHPImage::hight($image);
        //we could access it using $this->height($image); from inside
        //the callback  function($image){ $height = $this->height($image); }
    }

    public function execute(){
        if(!$this->callback)return false;
        $this->image = $this->callback->__invoke($this->image); //call the magic method __invoke ($this->callback(), is not a method)
        return $this; //for  method chaining  $obj->foo()->bar();
    }

    public function open($src){
        //if called directly
        $type = $this->type ? $this->type : exif_imagetype($src);
        switch($type)
        {
            case IMAGETYPE_GIF:
                return imagecreatefromgif($src);
                break;
            case IMAGETYPE_JPEG:
                return imagecreatefromjpeg($src);
                break;
            case IMAGETYPE_PNG:
                $image = imagecreatefrompng($src);
                imagealphablending($image, true); // setting alpha blending on
                imagesavealpha($image, true); // save alphablending setting (important)
                return $image;
                break;
            case IMAGETYPE_WBMP:
                return imagecreatefromwbmp($src);
                break;
            default:
                throw new Exception('Unknown image type', 1);
        }
    }

    public function save($dest, $res=90){
        switch($this->type){
            case IMAGETYPE_GIF:
                imagegif($this->image, $dest, $res);
                break;
            case IMAGETYPE_JPEG:
                imagejpeg($this->image, $dest, $res);
                break;
            case IMAGETYPE_PNG:
                $res = ceil($res*0.1); //convert from 0-100 to 1-10
                imagepng($this->image, $dest, $res);
                break;
            case IMAGETYPE_WBMP:
                imagewbmp($this->image, $dest, $res);
                break;
            default:
                throw new Exception('Unknown image type',1);
        }
    }

}


(new PHPImage('C:\UniServerZ\www\artisticphoenix\public_html\wp\wp-content\uploads\2018\10\ajax.png', function($image){
    return imagerotate($image, 90, 0);
}))->execute()->save(__DIR__.'/new.png');

echo "Complete";

I tested this (and it works, mostly, some issues with transparent PNGs) most of the code was taken (and modified) from my image class I mentioned that's on GitHub

Basically any GD functions that accept an image resource from on of the functions in PHPImage::open() would work by feeding it the $image argument inside the callback.

I should note the $image is a resource and not an object, so you have to pass it back with return, you may be able to do it like function(&$image) but I didn't test that.

Enjoy!