Object Oriented GD

Sooner or later we all need to use the gd library whether it be for generating thumbnails, scaling images, cropping, or whatever. When compiled with gd support, PHP offers a massive arsenal of functions to accomplish all of the image related tasks you can think of. With the advent of object oriented frameworks such as the Zend Framework and others, it can get a little awkward mixing procedural code with with objects. Additionally code for processing images can get quite ugly with all of the variable juggling.

After a number of image heavy projects, I got tired of the cut’n'paste headache and decided that it would be much easier to maintain graphical applications that interacted with images in an object-oriented fashion. I developed a small tool chain for encapsulating images and mechanisms for processing them. I start with a simple class definition which allows me to treat an image as an object.

This class takes a file path or url as its constructor argument. Using some tricky http header sniffing we are able to determine if the provided url is actually a redirect and in turn we are able to get the real url of the image. This is a handy feature as it allows us to process remotely hosted images on the fly which gives us the option of using CDNs or clouds for image storage. Next a gd resource is created and stored internally.

The object exposes 3 properties (width, height, and image). The first two are obvious while the image property is a reference to the gd resource should we ever need to deal with it directly. The save method allows the image to be saved to a file in the format specified by the extension of the destination path. The stream function is useful for streaming the raw image data to a web browser when you need to link to a dynamically generated image. The object destructor frees the gd resource from memory.

So at first glance this class isn’t terribly useful aside from the fact that it handles the image format automatically. It’s true utility comes by extending it to encapsulate additional functionality. We can use this class as a rich base class that provides the mundane common functionality that all of the subclasses need. The simplest example would be probably the most common use of gd on the web: the generation of thumbnails

Generate Thumbnails

Here all we overload is the constructor. This class has the added bonus of being able to accept other objects that extend the FP_Image class as well as raw gd resources. The constructor takes this agnostic image as well as a width and height desired for the thumbnail. The class does all of the processing it needs and then stores the created thumbnail internally which we can then access using the methods provided by FP_Image.

Here is a quick example of how to generate dynamic thumbnails from a Zend Framework controller action using this class:

Scale Images

This class isn’t all that different, instead of scaling down both dimensions it scales either vertically or horizontally while preserving the aspect ratio.

Crop Images

This class takes another image and crops it to the specifications passed into the constructor.

Watermark an Image

This is a handy class for embedding a watermark into an image. This takes a base image and a secondary image and overlays it with alpha blending allowing for subtle semi-transparent watermarks.

Overlay True Type Text over Image

This one is fairly sophisticated compared to the others. In a nutshell it allows multiple lines of true type text to be overlayed ontop of an image. It takes a wide array of configuration option to specify things like font color, padding, justification, angle, etc. This class probably deserves a post all in itself so trust me when I say it excels in utility.

Because all of these classes all extend the same base class they can be used in elaborate combinations by overlaying text over a watermarked image that is then in turn scaled down. Also in this structure, these classes are completely generalized and are portable to any application that needs image processing.