Image_Transform

Complexity

Total Complexity

153

Size/Duplication

Total Lines	1258
Duplicated Lines	0 %

Importance

Changes

0

63 Methods

Rating	Name	Duplication	Size	Complexity
B	fit()	0	13	6
A	_resize()	0	3	1
B	intersects()	0	19	6
A	addText()	0	3	1
A	addBorder()	0	3	1
A	greyscale()	0	3	1
A	scaleByXY()	0	3	1
A	colorarray2colorhex()	0	8	3
A	colorhex2colorarray()	0	7	1
A	keepSettingsOnSave()	0	3	1
A	fitX()	0	3	2
A	canvasResize()	0	3	1
A	_get_default_text_params()	0	3	1
A	isError()	0	7	2
A	_set_new_y()	0	3	1
A	getNewImageWidth()	0	7	2
A	grayscale()	0	3	1
A	_prepare_cmd()	0	8	3
A	resize()	0	8	3
A	setOptions()	0	3	1
A	setOption()	0	3	1
A	_send_display_headers()	0	7	1
C	_get_image_details()	0	66	18
A	_parse_size()	0	12	4
A	free()	0	3	1
A	scaleByFactor()	0	9	2
A	getHandle()	0	3	1
A	rotate()	0	3	1
D	_convert_image_type()	0	40	18
A	load()	0	3	1
A	scaleMaxLength()	0	14	3
A	addDropShadow()	0	3	1
A	fitY()	0	3	2
A	scaleByY()	0	8	2
A	gamma()	0	3	1
A	scaleByPercentage()	0	3	1
A	getNewImageHeight()	0	7	2
A	normalize()	0	3	1
A	flip()	0	3	1
B	_getColor()	0	18	5
A	_set_new_x()	0	3	1
A	_set_img_x()	0	3	1
A	crop()	0	3	1
A	_set_img_y()	0	3	1
A	getMimeType()	0	3	2
A	save()	0	3	1
A	display()	0	3	1
A	getImageType()	0	3	1
A	scaleByLength()	0	3	1
A	getImageSize()	0	8	1
A	getWebSafeFormat()	0	9	3
A	fitOnCanvas()	0	3	1
A	scale()	0	8	4
A	scaleByX()	0	8	2
A	getImageHeight()	0	3	1
A	getImageWidth()	0	3	1
A	getTempFile()	0	8	2
A	_getOption()	0	5	2
A	getTempDir()	0	5	1
C	factory()	0	62	14
A	supportsType()	0	3	2
A	_rotation_angle()	0	5	2
A	mirror()	0	3	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 38 and the first side effect is on line 33.

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * Simple and cross-library package to doing image transformations and
 * manipulations.
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category  Image
 * @package   Image_Transform
 * @author    Vincent Oostindie <vincent@sunlight.tmfweb.nl>
 * @author    Alan Knowles <alan@akbkhome.com>
 * @author    Peter Bowyer <peter@mapledesign.co.uk>
 * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright 2002-2007 The PHP Group
 * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version   CVS: $Id: Transform.php 322659 2012-01-24 11:56:22Z clockwerx $
 * @link      http://pear.php.net/package/Image_Transform
 */

/**
 * Include for error handling
 */
//require_once 'PEAR.php';
require_once XOOPS_ROOT_PATH . '/modules/extgallery/class/pear/PEAR.php';

The constant XOOPS_ROOT_PATH was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Error code for unsupported library, image format or methods
 */
define('IMAGE_TRANSFORM_ERROR_UNSUPPORTED', 1);

/**
 * Error code for failed transformation operations
 */
define('IMAGE_TRANSFORM_ERROR_FAILED', 2);

/**
 * Error code for failed i/o (Input/Output) operations
 */
define('IMAGE_TRANSFORM_ERROR_IO', 3);

/**
 * Error code for invalid arguments
 */
define('IMAGE_TRANSFORM_ERROR_ARGUMENT', 4);

/**
 * Error code for out-of-bound related errors
 */
define('IMAGE_TRANSFORM_ERROR_OUTOFBOUND', 5);

/**
 * Error code for inexsitant driver errors
 */
define('IMAGE_TRANSFORM_DRIVER_FILE_MISSING', 6);

/**
 * Base class with factory method for backend driver
 *
 * The main "Image_Transform" class is a container and base class which
 * provides a static method for creating an Image object as well as
 * some utility functions (maths) common to all parts of Image_Transform.
 *
 * @category  Image
 * @package   Image_Transform
 * @author    Alan Knowles <alan@akbkhome.com>
 * @author    Peter Bowyer <peter@mapledesign.co.uk>
 * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright 2002-2007 The PHP Group
 * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/Image_Transform
 * @since     PHP 4.0
 */
class Image_Transform

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * Name of the image file
     * @var string
     */
    public $image = '';

    /**
     * Type of the image file (eg. jpg, gif png ...)
     * @var string
     */
    public $type = '';

    /**
     * Original image width in x direction
     * @var int
     */
    public $img_x = '';

    /**
     * Original image width in y direction
     * @var int
     */
    public $img_y = '';

    /**
     * New image width in x direction
     * @var int
     */
    public $new_x = '';

    /**
     * New image width in y direction
     * @var int
     */
    public $new_y = '';

    /**
     * Path to the library used
     * e.g. /usr/local/ImageMagick/bin/ or
     * /usr/local/netpbm/
     */
    public $lib_path = '';

    /**
     * Flag to warn if image has been resized more than once before displaying
     * or saving.
     */
    public $resized = false;

    /**
     * @var array General options
     * @access protected
     */
    public $_options = array(
        'quality'     => 75,
        'scaleMethod' => 'smooth',
        'canvasColor' => array(255, 255, 255),
        'pencilColor' => array(0, 0, 0),
        'textColor'   => array(0, 0, 0)
    );

    /**
     * Flag for whether settings should be discarded on saving/display of image
     * @var bool
     * @see Image_Transform::keepSettingsOnSave
     */
    public $keep_settings_on_save = false;

    /**
     * Supported image types
     * @var array
     * @access protected
     */
    public $_supported_image_types = array();

    /**
     * Initialization error tracking
     * @var object
     * @access private
     **/
    public $_error = null;

    /**
     * associative array that tracks existence of programs
     * (for drivers using shell interface and a tiny performance
     * improvement if the clearstatcache() is used)
     * @var array
     * @access protected
     */
    public $_programs = array();

    /**
     * Default parameters used in the addText methods.
     */
    public $default_text_params = array(
        'text'         => 'Default text',
        'x'            => 10,
        'y'            => 20,
        'color'        => 'red',
        'font'         => 'Arial.ttf',
        'size'         => 12,
        'angle'        => 0,
        'resize_first' => false
    );

    /**
     * Creates a new Image_Transform object
     *
     * @param string $driver name of driver class to initialize. If no driver
     *                       is specified the factory will attempt to use 'Imagick' first
     *                       then 'GD' second, then 'Imlib' last
     *
     * @return object an Image_Transform object, or PEAR_Error on error
     *
     * @see PEAR::isError()
     * @see Image_Transform::setOption()
     */
    public function &factory($driver = '')
    {
        if ('' == $driver) {
            $extensions = array(
                'imagick' => 'Imagick3',
                'gd'      => 'GD',
                'imlib'   => 'Imlib'
            );
            if (version_compare(PHP_VERSION, '5.0.0', '<')) {
                //Imagick2 driver for php < 5
                $extensions['imagick'] = 'Imagick2';
            }

            foreach ($extensions as $ext => $ext_driver) {
                if (PEAR::loadExtension($ext)) {
                    $driver = $ext_driver;
                    break;
                }
            }
            if (!$driver) {
                return PEAR::raiseError('No image library specified and none can be found.' . ' You must specify driver in factory() call.', IMAGE_TRANSFORM_ERROR_ARGUMENT);

The method raiseError() does not exist on PEAR. Since you implemented __callStatic, consider adding a @method annotation.

            }
        } else {
            switch (strtolower($driver)) {
                case 'gd':
                    $driver = 'GD';
                    break;
                case 'imagick':
                    $driver = 'Imagick3';
                    if (version_compare(PHP_VERSION, '5.0.0', '<')) {
                        $driver = 'Imagick2';
                    }
                    break;
                case 'imlib':
                    $driver = 'Imlib';
                    break;
            }
        }

        //        $file = 'Image/Transform/Driver/' . $driver . '.php';
        $file = __DIR__ . '/Transform/Driver/' . $driver . '.php';
        if (!@fclose(@fopen($file, 'r', true))) {

It seems like @fopen($file, 'r', true) can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

            return PEAR::raiseError('Driver failed to load file ' . $file, IMAGE_TRANSFORM_DRIVER_FILE_MISSING);
        }

        $classname = 'Image_Transform_Driver_' . $driver;

        if (!class_exists($classname)) {
            require_once $file;

            if (!class_exists($classname)) {
                return PEAR::raiseError('Image library ' . $driver . ' not supported... aborting.', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
            }
        }
        $obj = new $classname();

        // Check startup error
        if ($error =& $obj->isError()) {
            $obj =& $error;
        }

        return $obj;
    }

    /**
     * Returns/sets an error when the instance couldn't initialize properly
     *
     * @param object $error PEAR_Error object when setting an error
     *
     * @return mixed FALSE or PEAR_Error object
     * @access protected
     */
    public function &isError($error = null)
    {
        if (!is_null($error)) {
            $this->_error =& $error;
        }

        return $this->_error;
    }

    /**
     * Resizes the image in the X and/or Y direction(s)
     *
     * If either is 0 it will keep the original size for that dimension
     *
     * @param mixed $new_x   (0, number, percentage 10% or 0.1)
     * @param mixed $new_y   (0, number, percentage 10% or 0.1)
     * @param array $options Options
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function resize($new_x = 0, $new_y = 0, $options = null)
    {
        // 0 means keep original size
        $new_x = (0 == $new_x) ? $this->img_x : $this->_parse_size($new_x, $this->img_x);
        $new_y = (0 == $new_y) ? $this->img_y : $this->_parse_size($new_y, $this->img_y);

        // Now do the library specific resizing.
        return $this->_resize($new_x, $new_y, $options);

The call to Image_Transform::_resize() has too many arguments starting with $new_x.

    } // End resize

    /**
     * Scales the image to the specified width
     *
     * This method preserves the aspect ratio
     *
     * @param int $new_x Size to scale X-dimension to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function scaleByX($new_x)
    {
        if ($new_x <= 0) {
            return PEAR::raiseError('New size must be strictly positive', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);

        return $this->_resize(max(1, $new_x), max(1, $new_y));

The call to Image_Transform::_resize() has too many arguments starting with max(1, $new_x).

    } // End scaleByX

    /**
     * Alias for resize()
     *
     * @see resize()
     */
    public function scaleByXY($new_x = 0, $new_y = 0, $options = null)
    {
        return $this->resize($new_x, $new_y, $options);
    } // End scaleByXY

    /**
     * Scales the image to the specified height.
     *
     * This method preserves the aspect ratio
     *
     * @param int $new_y Size to scale Y-dimension to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function scaleByY($new_y)
    {
        if ($new_y <= 0) {
            return PEAR::raiseError('New size must be strictly positive', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);

        return $this->_resize(max(1, $new_x), max(1, $new_y));

The call to Image_Transform::_resize() has too many arguments starting with max(1, $new_x).

    } // End scaleByY

    /**
     * Scales an image by a percentage, factor or a given length
     *
     * This method preserves the aspect ratio
     *
     * @param mixed $size (number, percentage 10% or 0.1)
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see    scaleByPercentage, scaleByFactor, scaleByLength
     */
    public function scale($size)
    {
        if ((strlen($size) > 1) && ('%' == substr($size, -1))) {
            return $this->scaleByPercentage(substr($size, 0, -1));

substr($size, 0, -1) of type string is incompatible with the type integer expected by parameter $size of Image_Transform::scaleByPercentage().

        } elseif ($size < 1) {
            return $this->scaleByFactor($size);
        } else {
            return $this->scaleByLength($size);
        }
    } // End scale

    /**
     * Scales an image to a percentage of its original size.  For example, if
     * my image was 640x480 and I called scaleByPercentage(10) then the image
     * would be resized to 64x48
     *
     * @param int $size Percentage of original size to scale to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function scaleByPercentage($size)
    {
        return $this->scaleByFactor($size / 100);
    } // End scaleByPercentage

    /**
     * Scales an image to a factor of its original size.  For example, if
     * my image was 640x480 and I called scaleByFactor(0.5) then the image
     * would be resized to 320x240.
     *
     * @param float $size Factor of original size to scale to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function scaleByFactor($size)
    {
        if ($size <= 0) {
            return PEAR::raiseError('New size must be strictly positive', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_x = round($size * $this->img_x, 0);
        $new_y = round($size * $this->img_y, 0);

        return $this->_resize(max(1, $new_x), max(1, $new_y));

The call to Image_Transform::_resize() has too many arguments starting with max(1, $new_x).

    } // End scaleByFactor

    /**
     * Scales an image so that the longest side has the specified dimension.
     *
     * This method preserves the aspect ratio
     *
     * @param int $size Max dimension in pixels
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    public function scaleMaxLength($size)
    {
        if ($size <= 0) {
            return PEAR::raiseError('New size must be strictly positive', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        if ($this->img_x >= $this->img_y) {
            $new_x = $size;
            $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);
        } else {
            $new_y = $size;
            $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);
        }

        return $this->_resize(max(1, $new_x), max(1, $new_y));

The call to Image_Transform::_resize() has too many arguments starting with max(1, $new_x).

    } // End scaleMaxLength

    /**
     * Alias for scaleMaxLength
     *
     * @param int $size Max dimension in pixels
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see    scaleMaxLength()
     */
    public function scaleByLength($size)
    {
        return $this->scaleMaxLength($size);
    }

    /**
     * Fits the image in the specified box size
     *
     * If the image is bigger than the box specified by $width and $height,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $width  Width of the box in pixels
     * @param integer $height Height of the box in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    public function fit($width, $height)
    {
        if ($width <= 0 || $height <= 0) {
            return PEAR::raiseError("Invalid arguments.", IMAGE_TRANSFORM_ERROR_ARGUMENT);
        }
        $x = $this->img_x / $width;
        $y = $this->img_y / $height;
        if ($x <= 1 && $y <= 1) {
            return true;
        } elseif ($x > $y) {
            return $this->scaleByX($width);
        } else {
            return $this->scaleByY($height);
        }
    }

    /**
     * This works as per fit, but creates the canvas of size $width x $height
     * and positions the resized image on it, by default in the centre.
     *
     * @param unknown_type $width

The type unknown_type was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param unknown_type $height
     * @param unknown_type $posn
     *
     * @return unknown

The type unknown was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function fitOnCanvas($width, $height, $posn = 'center')

The parameter $height is not used and could be removed.

The parameter $width is not used and could be removed.

The parameter $posn is not used and could be removed.

    {
        return PEAR::raiseError('fitOnCanvas() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Fits the image in the specified width
     *
     * If the image is wider than the width specified by $width,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $width Maximum width in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    public function fitX($width)
    {
        return ($this->img_x <= $width) ? true : $this->scaleByX($width);
    }

    /**
     * Fits the image in the specified height
     *
     * If the image is taller than the height specified by $height,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $height Maximum height in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    public function fitY($height)
    {
        return ($this->img_y <= $height) ? true : $this->scaleByY($height);
    }

    /**
     * Sets one options
     *
     * @param string $name  Name of option
     * @param mixed  $value Value of option
     *
     * @return void
     * @access public
     * @see    setOptions()
     */
    public function setOption($name, $value)
    {
        $this->_options[$name] = $value;
    }

    /**
     * Sets multiple options at once
     *
     * Associative array of options:
     *  - quality     (Integer: 0: poor - 100: best)
     *  - scaleMethod ('smooth', 'pixel')
     *
     * @param array $options Array of options
     *
     * @return void
     * @access public
     */
    public function setOptions($options)
    {
        $this->_options = array_merge($this->_options, $options);
    }

    /**
     * Sets the image type (in lowercase letters), the image height and width.
     *
     * @param string $image Image filename
     *
     * @return mixed TRUE or PEAR_error
     * @access protected
     * @see    PHP_Compat::image_type_to_mime_type()
     * @link   http://php.net/getimagesize
     */
    public function _get_image_details($image)
    {
        $data = @getimagesize($image);
        //  1 = GIF,   2 = JPG,  3 = PNG,  4 = SWF,  5 = PSD,  6 = BMP,
        //  7 = TIFF (intel byte order),   8 = TIFF (motorola byte order),
        //  9 = JPC,  10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC, 14 = IFF,
        // 15 = WBMP, 16 = XBM
        if (!is_array($data)) {
            return PEAR::raiseError("Cannot fetch image or images details.", true);
        }

        switch ($data[2]) {
            case IMAGETYPE_GIF:
                $type = 'gif';
                break;
            case IMAGETYPE_JPEG:
                $type = 'jpeg';
                break;
            case IMAGETYPE_PNG:
                $type = 'png';
                break;
            case IMAGETYPE_SWF:
                $type = 'swf';
                break;
            case IMAGETYPE_PSD:
                $type = 'psd';
                break;
            case IMAGETYPE_BMP:
                $type = 'bmp';
                break;
            case IMAGETYPE_TIFF_II:
            case IMAGETYPE_TIFF_MM:
                $type = 'tiff';
                break;
            case IMAGETYPE_JPC:
                $type = 'jpc';
                break;
            case IMAGETYPE_JP2:
                $type = 'jp2';
                break;
            case IMAGETYPE_JPX:
                $type = 'jpx';
                break;
            case IMAGETYPE_JB2:
                $type = 'jb2';
                break;
            case IMAGETYPE_SWC:
                $type = 'swc';
                break;
            case IMAGETYPE_IFF:
                $type = 'iff';
                break;
            case IMAGETYPE_WBMP:
                $type = 'wbmp';
                break;
            case IMAGETYPE_XBM:
                $type = 'xbm';
                break;
            default:
                return PEAR::raiseError("Cannot recognize image format", IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->img_x = $this->new_x = $data[0];
        $this->img_y = $this->new_y = $data[1];
        $this->type  = $type;

        return true;
    }

    /**
     * Returns the matching IMAGETYPE_* constant for a given image type
     *
     * @param mixed $type String (GIF, JPG,...)
     *
     * @return mixed string or integer or input on error
     * @access protected
     * @see    PHP_Compat::image_type_to_mime_type()
     **/
    public function _convert_image_type($type)
    {
        switch (strtolower($type)) {
            case 'gif':
                return IMAGETYPE_GIF;
            case 'jpeg':
            case 'jpg':
                return IMAGETYPE_JPEG;
            case 'png':
                return IMAGETYPE_PNG;
            case 'swf':
                return IMAGETYPE_SWF;
            case 'psd':
                return IMAGETYPE_PSD;
            case 'bmp':
                return IMAGETYPE_BMP;
            case 'tiff':
                return IMAGETYPE_TIFF_II;
            //IMAGETYPE_TIFF_MM;
            case 'jpc':
                return IMAGETYPE_JPC;
            case 'jp2':
                return IMAGETYPE_JP2;
            case 'jpx':
                return IMAGETYPE_JPX;
            case 'jb2':
                return IMAGETYPE_JB2;
            case 'swc':
                return IMAGETYPE_SWC;
            case 'iff':
                return IMAGETYPE_IFF;
            case 'wbmp':
                return IMAGETYPE_WBMP;
            case 'xbm':
                return IMAGETYPE_XBM;
            default:
                return $type;
        }

        return (isset($types[$t = strtolower($type)])) ? $types[$t] : $type;

return IssetNode ? $types[$t] : $type is not reachable.

    }

    /**
     * Parses input for number format and convert
     *
     * If either parameter is 0 it will be scaled proportionally
     *
     * @param mixed $new_size (0, number, percentage 10% or 0.1)
     * @param int   $old_size
     *
     * @return mixed Integer or PEAR_error
     * @access protected
     */
    public function _parse_size($new_size, $old_size)
    {
        if ('%' == substr($new_size, -1)) {
            $new_size = substr($new_size, 0, -1);
            $new_size = $new_size / 100;
        }
        if ($new_size > 1) {
            return (int)$new_size;
        } elseif (0 == $new_size) {
            return (int)$old_size;
        } else {
            return (int)round($new_size * $old_size, 0);
        }
    }

    /**
     * Returns an angle between 0 and 360 from any angle value
     *
     * @param float $angle The angle to normalize
     *
     * @return float the angle
     * @access protected
     */
    public function _rotation_angle($angle)
    {
        $angle %= 360;

        return ($angle < 0) ? $angle + 360 : $angle;
    }

    /**
     * Returns the current value of $this->default_text_params.
     *
     * @return array $this->default_text_params The current text parameters
     * @access protected
     */
    public function _get_default_text_params()
    {
        return $this->default_text_params;
    }

    /**
     * Sets the image width
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since  29/05/02 13:36:31
     */
    public function _set_img_x($size)
    {
        $this->img_x = $size;
    }

    /**
     * Sets the image height
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since  29/05/02 13:36:31
     */
    public function _set_img_y($size)
    {
        $this->img_y = $size;
    }

    /**
     * Sets the new image width
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since  29/05/02 13:36:31
     */
    public function _set_new_x($size)
    {
        $this->new_x = $size;
    }

    /**
     * Sets the new image height
     *
     * @param int $size dimension to set
     *
     * @return void
     * @since  29/05/02 13:36:31
     * @access protected
     */
    public function _set_new_y($size)
    {
        $this->new_y = $size;
    }

    /**
     * Returns the image handle so that one can further try
     * to manipulate the image
     *
     * @return resource
     *
     * @access public
     */
    public function getHandle()
    {
        return PEAR::raiseError('getHandle() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }//function getHandle()

    /**
     * Returns the type of the image being manipulated
     *
     * @return string the image type
     * @access public
     */
    public function getImageType()
    {
        return $this->type;
    }

    /**
     * Returns the MIME type of the image being manipulated
     *
     * @param string $type Image type to get MIME type for
     *
     * @return string The MIME type if available, or an empty string
     * @access public
     * @see    PHP_Compat::image_type_to_mime_type()
     * @link   http://php.net/image_type_to_mime_type
     */
    public function getMimeType($type = null)
    {
        return image_type_to_mime_type($this->_convert_image_type(($type) ? $type : $this->type));

It seems like $this->_convert_image_type($type ? $type : $this->type) can also be of type string; however, parameter $imagetype of image_type_to_mime_type() does only seem to accept integer, maybe add an additional type check?

    }

    /**
     * Returns the new image width
     *
     * This function returns the width
     * of the new image.
     *
     * @access public
     * @return int  The width of the new image.
     */
    public function getNewImageWidth()
    {
        if (isset($this->new_x)) {
            return (int)$this->new_x;
        }

        return false;

The expression return false returns the type false which is incompatible with the documented return type integer.

    }

    /**
     * Return new image Y
     *
     * This function will retrieve the
     * new image 'Y' and return it's value
     * if it's set.
     *
     * @access public
     * @return int  The new height of the image.
     */
    public function getNewImageHeight()
    {
        if (isset($this->new_y)) {
            return (int)$this->new_y;
        }

        return false;

The expression return false returns the type false which is incompatible with the documented return type integer.

    }

    /**
     * Returns the image width
     *
     * @return int the width of the image
     * @access public
     */
    public function getImageWidth()
    {
        return $this->img_x;
    }

    /**
     * Returns the image height
     *
     * @return int the width of the image
     * @access public
     */
    public function getImageHeight()
    {
        return $this->img_y;
    }

    /**
     * Returns the image size and extra format information
     *
     * @return array The width and height of the image
     * @access public
     * @see    PHP::getimagesize()
     */
    public function getImageSize()
    {
        return array(
            $this->img_x,
            $this->img_y,
            $this->_convert_image_type($this->type),
            'height="' . $this->img_y . '" width="' . $this->img_x . '"',
            'mime' => $this->getMimeType()
        );
    }

    /**
     * This looks at the current image type and attempts to determine which
     * web-safe format will be most suited.  It does not work brilliantly with
     * *.png images, because it is very difficult to know whether they are
     * 8-bit or greater.  Guess I need to have fatter code here :-)
     *
     * @return string web-safe image type
     * @access public
     */
    public function getWebSafeFormat()
    {
        switch ($this->type) {
            case 'gif':
            case 'png':
                return 'png';
                break;

break is not strictly necessary here and could be removed.

            default:
                return 'jpeg';
        } // switch
    }

    /**
     * Handles space in path and Windows/UNIX difference
     *
     * @param string $path    Base dir
     * @param string $command Command to execute
     * @param string $args    Arguments to pass to the command
     *
     * @return string A prepared string suitable for exec()
     * @access protected
     */
    public function _prepare_cmd($path, $command, $args = '')
    {
        if (!OS_WINDOWS
            || !preg_match('/\s/', $path)) {
            return $path . $command . ' ' . $args;
        }

        return 'start /D "' . $path . '" /B ' . $command . ' ' . $args;
    }

    /**
     * Place holder for the real resize method
     * used by extended methods to do the resizing
     *
     * @return PEAR_error
     * @access protected
     */
    public function _resize()
    {
        return PEAR::raiseError('Resize method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Normalizes the colors, gamma and other properties of an image
     * (this should give a result equivalent to a Photoshop autolevels)
     *
     * @return PEAR_error
     * @access public
     */
    public function normalize()
    {
        return PEAR::raiseError('Normalize method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Loads an image file to work with
     *
     * Place holder for the real load method
     * used by extended methods to do the resizing
     *
     * @param string $filename Full name of file
     *
     * @return PEAR_error
     * @access public
     */
    public function load($filename)
    {
        return PEAR::raiseError('load() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Outputs the image to standard output
     *
     * Place holder for the real display method
     * used by extended methods to do the resizing
     *
     * @param string $type    Format of image to save as
     * @param mixed  $quality Format-dependent
     *
     * @return PEAR_error
     * @access public
     */
    public function display($type, $quality = null)

The parameter $quality is not used and could be removed.

    {
        return PEAR::raiseError('display() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Returns if the driver supports a given image type
     *
     * @param string $type Image type (GIF, PNG, JPEG...)
     * @param string $mode 'r' for read, 'w' for write, 'rw' for both
     *
     * @return TRUE if type (and mode) is supported FALSE otherwise
     * @access public
     */
    public function supportsType($type, $mode = 'rw')
    {
        return (false === strpos(@$this->_supported_image_types[strtolower($type)], $mode)) ? false : true;

The expression return false === strpos(@$this->_supported_image_types[strtolower($type)], $mode) ? false : true returns the type boolean which is incompatible with the documented return type true.

    }

    /**
     * Saves image to file
     *
     * Place holder for the real save method
     * used by extended methods to do the resizing
     *
     * @param string $filename Filename to save image to
     * @param string $type     Format of image to save as
     * @param mixed  $quality  Format-dependent
     *
     * @return PEAR_error
     * @access public
     */
    public function save($filename, $type, $quality = null)

The parameter $filename is not used and could be removed.

The parameter $quality is not used and could be removed.

    {
        return PEAR::raiseError('save() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Releases resource
     *
     * Place holder for the real free method
     * used by extended methods to do the resizing
     *
     * @return PEAR_error
     * @access public
     */
    public function free()
    {
        return PEAR::raiseError('free() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts a color string into an array of RGB values
     *
     * @param string $colorhex A color following the #FFFFFF format
     *
     * @return array 3-element array with 0-255 values
     * @access public
     *
     * @see    rgb2colorname
     * @see    colorarray2colorhex
     */
    public function colorhex2colorarray($colorhex)
    {
        $r = hexdec(substr($colorhex, 1, 2));
        $g = hexdec(substr($colorhex, 3, 2));
        $b = hexdec(substr($colorhex, 5, 2));

        return array($r, $g, $b, 'type' => 'RGB');
    }

    public function _send_display_headers($type)
    {
        // Find the filename of the original image:
        $filename = explode('.', basename($this->image));
        $filename = $filename[0];
        header('Content-type: ' . $this->getMimeType($type));
        header('Content-Disposition: inline; filename=' . $filename . '.' . $type);
    }

    /**
     * Converts an array of RGB value into a #FFFFFF format color.
     *
     * @param array $color 3-element array with 0-255 values
     *
     * @return mixed A color following the #FFFFFF format or FALSE
     *               if the array couldn't be converted
     * @access public
     *
     * @see    rgb2colorname
     * @see    colorhex2colorarray
     */
    public function colorarray2colorhex($color)
    {
        if (!is_array($color)) {

The condition is_array($color) is always true.

            return false;
        }
        $color = sprintf('#%02X%02X%02X', @$color[0], @$color[1], @$color[2]);

        return (7 != strlen($color)) ? false : $color;
    }

    /**
     * Returns the temp directory according to either the TMP, TMPDIR, or TEMP env
     * variables. If these are not set it will also check for the existence of
     * /tmp, %WINDIR%\temp
     *
     * @access public
     * @return string The system tmp directory
     */
    public function getTempDir()
    {
        require_once 'System.php';

        return System::tmpdir();
    }

    /**
     * Returns a temporary filename using tempnam() and the above getTmpDir() function.
     *
     * @param string $dirname Optional directory name for the tmp file
     *
     * @return string Filename and path of the tmp file
     * @access public
     */
    public function getTempFile($dirname = null)
    {
        if (is_null($dirname)) {
            require_once 'System.php';
            $dirname = System::tmpdir();
        }

        return tempnam($dirname, 'temp.');
    }

    public function keepSettingsOnSave($bool)
    {
        $this->keep_settings_on_save = $bool;
    }

    /**
     * Methods to add to the driver classes in the future
     *
     * @return void
     */
    public function addText()
    {
        return PEAR::raiseError('addText() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    public function addDropShadow()
    {
        return PEAR::raiseError('addDropShadow() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    public function addBorder()
    {
        return PEAR::raiseError('addBorder() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Crops an image
     *
     * @param int $width  Cropped image width
     * @param int $height Cropped image height
     * @param int $x      X-coordinate to crop at
     * @param int $y      Y-coordinate to crop at
     *
     * @return mixed TRUE or a PEAR_Error object on error
     * @access public
     **/
    public function crop($width, $height, $x = 0, $y = 0)
    {
        return PEAR::raiseError('crop() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    public function canvasResize()
    {
        return PEAR::raiseError('canvasResize() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Corrects the gamma of an image
     *
     * @param float $outputgamma Gamma correction factor
     *
     * @return mixed TRUE or a PEAR_error object on error
     * @access public
     **/
    public function gamma($outputgamma = 1.0)

The parameter $outputgamma is not used and could be removed.

    {
        return PEAR::raiseError('gamma() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Rotates the image clockwise
     *
     * @param float $angle   Angle of rotation in degres
     * @param mixed $options Rotation options
     *
     * @return bool|PEAR_Error TRUE on success, PEAR_Error object on error
     * @access public
     */
    public function rotate($angle, $options = null)
    {
        return PEAR::raiseError('rotate() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Horizontal mirroring
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see    flip()
     **/
    public function mirror()
    {
        return PEAR::raiseError('mirror() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Vertical mirroring
     *
     * @return TRUE or PEAR Error object on error
     * @access public
     * @see    mirror()
     **/
    public function flip()
    {
        return PEAR::raiseError('flip() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts an image into greyscale colors
     *
     * @return mixed TRUE or a PEAR error object on error
     * @access public
     **/
    public function greyscale()
    {
        return PEAR::raiseError('greyscale() method not supported by driver', IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts an image into greyscale colors
     *
     * @return mixed TRUE or a PEAR error object on error
     * @see greyscale()
     **/
    public function grayscale()
    {
        return $this->greyscale();
    }

    /**
     * Returns a color option
     *
     * @param string $colorOf one of 'canvasColor', 'pencilColor', 'fontColor'
     * @param array  $options configuration options
     * @param array  $default default value to return if color not found
     *
     * @return array an RGB color array
     * @access protected
     */
    public function _getColor($colorOf, $options = array(), $default = array(0, 0, 0))
    {
        $opt = array_merge($this->_options, (array)$options);
        if (isset($opt[$colorOf])) {
            $color = $opt[$colorOf];
            if (is_array($color)) {
                return $color;
            }
            if ('#' == $color{0}) {
                return $this->colorhex2colorarray($color);
            }
            static $colornames = array();
            require_once 'Image/Transform/Driver/ColorsDefs.php';

            return (isset($colornames[$color])) ? $colornames[$color] : $default;
        }

        return $default;
    }

    /**
     * Returns an option
     *
     * @param string $name    name of option
     * @param array  $options local override option array
     * @param mixed  $default default value to return if option is not found
     *
     * @return mixed the option
     * @access protected
     */
    public function _getOption($name, $options = array(), $default = null)
    {
        $opt = array_merge($this->_options, (array)$options);

        return (isset($opt[$name])) ? $opt[$name] : $default;
    }

    /**
     * Checks if the rectangle passed intersects with the current image
     *
     * @param int $width  Width of rectangle
     * @param int $height Height of rectangle
     * @param int $x      X-coordinate
     * @param int $y      Y-coordinate
     *
     * @return bool|PEAR_Error TRUE if intersects, FALSE if not,
     *                         and PEAR_Error on error
     * @access public
     */
    public function intersects($width, $height, $x, $y)
    {
        $left  = $x;
        $right = $x + $width;
        if ($right < $left) {
            $left  = $right;
            $right = $x;
        }
        $top    = $y;
        $bottom = $y + $height;
        if ($bottom < $top) {
            $top    = $bottom;
            $bottom = $y;
        }

        return (bool)($left < $this->new_x
                      && $right >= 0
                      && $top < $this->new_y
                      && $bottom >= 0);
    }
}