Image_Transform
[ class tree: Image_Transform ] [ index: Image_Transform ] [ all elements ]

Source for file Transform.php

Documentation is available at Transform.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  4.  
  5. /**
  6.  * Simple and cross-library package to doing image transformations and
  7.  * manipulations.
  8.  *
  9.  * PHP versions 4 and 5
  10.  *
  11.  * LICENSE: This source file is subject to version 3.0 of the PHP license
  12.  * that is available through the world-wide-web at the following URI:
  13.  * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
  14.  * the PHP License and are unable to obtain it through the web, please
  15.  * send a note to license@php.net so we can mail you a copy immediately.
  16.  *
  17.  * @category  Image
  18.  * @package   Image_Transform
  19.  * @author    Vincent Oostindie <vincent@sunlight.tmfweb.nl>
  20.  * @author    Alan Knowles <alan@akbkhome.com>
  21.  * @author    Peter Bowyer <peter@mapledesign.co.uk>
  22.  * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
  23.  * @copyright 2002-2007 The PHP Group
  24.  * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
  25.  * @version   CVS: $Id: Transform.php 322659 2012-01-24 11:56:22Z clockwerx $
  26.  * @link      http://pear.php.net/package/Image_Transform
  27.  */
  28.  
  29. /**
  30.  * Include for error handling
  31.  */
  32. require_once 'PEAR.php';
  33.  
  34. /**
  35.  * Error code for unsupported library, image format or methods
  36.  */
  37. define('IMAGE_TRANSFORM_ERROR_UNSUPPORTED'1);
  38.  
  39. /**
  40.  * Error code for failed transformation operations
  41.  */
  42. define('IMAGE_TRANSFORM_ERROR_FAILED'2);
  43.  
  44. /**
  45.  * Error code for failed i/o (Input/Output) operations
  46.  */
  47. define('IMAGE_TRANSFORM_ERROR_IO'3);
  48.  
  49. /**
  50.  * Error code for invalid arguments
  51.  */
  52. define('IMAGE_TRANSFORM_ERROR_ARGUMENT'4);
  53.  
  54. /**
  55.  * Error code for out-of-bound related errors
  56.  */
  57. define('IMAGE_TRANSFORM_ERROR_OUTOFBOUND'5);
  58.  
  59. /**
  60.  * Error code for inexsitant driver errors
  61.  */
  62. define('IMAGE_TRANSFORM_DRIVER_FILE_MISSING'6);
  63.  
  64. /**
  65.  * Base class with factory method for backend driver
  66.  *
  67.  * The main "Image_Transform" class is a container and base class which
  68.  * provides a static method for creating an Image object as well as
  69.  * some utility functions (maths) common to all parts of Image_Transform.
  70.  *
  71.  * @category  Image
  72.  * @package   Image_Transform
  73.  * @author    Alan Knowles <alan@akbkhome.com>
  74.  * @author    Peter Bowyer <peter@mapledesign.co.uk>
  75.  * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
  76.  * @copyright 2002-2007 The PHP Group
  77.  * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
  78.  * @version   Release: @package_version@
  79.  * @link      http://pear.php.net/package/Image_Transform
  80.  * @since     PHP 4.0
  81.  */
  82. {
  83.     /**
  84.      * Name of the image file
  85.      * @var string 
  86.      */
  87.     var $image = '';
  88.  
  89.     /**
  90.      * Type of the image file (eg. jpg, gif png ...)
  91.      * @var string 
  92.      */
  93.     var $type = '';
  94.  
  95.     /**
  96.      * Original image width in x direction
  97.      * @var int 
  98.      */
  99.     var $img_x = '';
  100.  
  101.     /**
  102.      * Original image width in y direction
  103.      * @var int 
  104.      */
  105.     var $img_y = '';
  106.  
  107.     /**
  108.      * New image width in x direction
  109.      * @var int 
  110.      */
  111.     var $new_x = '';
  112.  
  113.     /**
  114.      * New image width in y direction
  115.      * @var int 
  116.      */
  117.     var $new_y = '';
  118.  
  119.     /**
  120.      * Path to the library used
  121.      * e.g. /usr/local/ImageMagick/bin/ or
  122.      * /usr/local/netpbm/
  123.      */
  124.     var $lib_path = '';
  125.  
  126.     /**
  127.      * Flag to warn if image has been resized more than once before displaying
  128.      * or saving.
  129.      */
  130.     var $resized = false;
  131.  
  132.     /**
  133.      * @var array General options
  134.      * @access protected
  135.      */
  136.     var $_options = array(
  137.         'quality'     => 75,
  138.         'scaleMethod' => 'smooth',
  139.         'canvasColor' => array(255255255),
  140.         'pencilColor' => array(000),
  141.         'textColor'   => array(000)
  142.         );
  143.  
  144.     /**
  145.      * Flag for whether settings should be discarded on saving/display of image
  146.      * @var bool 
  147.      * @see Image_Transform::keepSettingsOnSave
  148.      */
  149.     var $keep_settings_on_save = false;
  150.  
  151.     /**
  152.      * Supported image types
  153.      * @var array 
  154.      * @access protected
  155.      */
  156.     var $_supported_image_types = array();
  157.  
  158.     /**
  159.      * Initialization error tracking
  160.      * @var object 
  161.      * @access private
  162.      ***/
  163.     var $_error = null;
  164.  
  165.     /**
  166.      * associative array that tracks existence of programs
  167.      * (for drivers using shell interface and a tiny performance
  168.      * improvement if the clearstatcache() is used)
  169.      * @var array 
  170.      * @access protected
  171.      */
  172.     var $_programs = array();
  173.  
  174.      /**
  175.       * Default parameters used in the addText methods.
  176.       */
  177.     var $default_text_params = array(
  178.         'text' => 'Default text',
  179.         'x'     => 10,
  180.         'y'     => 20,
  181.         'color' => 'red',
  182.         'font'  => 'Arial.ttf',
  183.         'size'  => 12,
  184.         'angle' => 0,
  185.         'resize_first' => false
  186.     );
  187.  
  188.     /**
  189.      * Creates a new Image_Transform object
  190.      *
  191.      * @param string $driver name of driver class to initialize. If no driver
  192.      *                is specified the factory will attempt to use 'Imagick' first
  193.      *                then 'GD' second, then 'Imlib' last
  194.      *
  195.      * @return object an Image_Transform object, or PEAR_Error on error
  196.      *
  197.      * @see PEAR::isError()
  198.      * @see Image_Transform::setOption()
  199.      */
  200.     function &factory($driver '')
  201.     {
  202.         if ($driver == ''{
  203.             $extensions = array(
  204.                 'imagick' => 'Imagick3',
  205.                 'gd'      => 'GD',
  206.                 'imlib'   => 'Imlib'
  207.             );
  208.             if (version_compare(PHP_VERSION'5.0.0''<')) {
  209.                 //Imagick2 driver for php < 5
  210.                 $extensions['imagick''Imagick2';
  211.             }
  212.  
  213.             foreach ($extensions as $ext => $ext_driver{
  214.                 if (PEAR::loadExtension($ext)) {
  215.                     $driver $ext_driver;
  216.                     break;
  217.                 }
  218.             }
  219.             if (!$driver{
  220.                 return PEAR::raiseError(
  221.                     'No image library specified and none can be found.'
  222.                     . ' You must specify driver in factory() call.',
  223.                     IMAGE_TRANSFORM_ERROR_ARGUMENT
  224.                 );
  225.             }
  226.         else {
  227.             switch (strtolower($driver)) {
  228.                 case 'gd':
  229.                     $driver 'GD';
  230.                     break;
  231.                 case 'imagick':
  232.                     $driver 'Imagick3';
  233.                     if (version_compare(PHP_VERSION'5.0.0''<')) {
  234.                         $driver 'Imagick2';
  235.                     }
  236.                     break;
  237.                 case 'imlib':
  238.                     $driver 'Imlib';
  239.                     break;
  240.             }
  241.         }
  242.  
  243.         $file 'Image/Transform/Driver/' $driver '.php';
  244.         if (!@fclose(@fopen($file'r'true))) {
  245.             return PEAR::raiseError('Driver failed to load file ' $file,
  246.                                     IMAGE_TRANSFORM_DRIVER_FILE_MISSING);
  247.         }
  248.  
  249.         $classname 'Image_Transform_Driver_' $driver;
  250.  
  251.         if (!class_exists($classname)) {
  252.             include_once $file;
  253.  
  254.             if (!class_exists($classname)) {
  255.                 return PEAR::raiseError(
  256.                     'Image library ' $driver ' not supported... aborting.',
  257.                     IMAGE_TRANSFORM_ERROR_UNSUPPORTED
  258.                 );
  259.             }
  260.         }
  261.         $obj = new $classname();
  262.  
  263.         // Check startup error
  264.         if ($error =$obj->isError()) {
  265.             $obj =$error;
  266.         }
  267.         return $obj;
  268.     }
  269.  
  270.     /**
  271.      * Returns/sets an error when the instance couldn't initialize properly
  272.      *
  273.      * @param object $error PEAR_Error object when setting an error
  274.      *
  275.      * @return mixed FALSE or PEAR_Error object
  276.      * @access protected
  277.      */
  278.     function &isError($error = null)
  279.     {
  280.         if (!is_null($error)) {
  281.             $this->_error =$error;
  282.         }
  283.         return $this->_error;
  284.     }
  285.  
  286.     /**
  287.      * Resizes the image in the X and/or Y direction(s)
  288.      *
  289.      * If either is 0 it will keep the original size for that dimension
  290.      *
  291.      * @param mixed $new_x   (0, number, percentage 10% or 0.1)
  292.      * @param mixed $new_y   (0, number, percentage 10% or 0.1)
  293.      * @param array $options Options
  294.      *
  295.      * @return mixed TRUE or PEAR_Error object on error
  296.      * @access public
  297.      */
  298.     function resize($new_x = 0$new_y = 0$options = null)
  299.     {
  300.         // 0 means keep original size
  301.         $new_x (0 == $new_x)
  302.                  ? $this->img_x
  303.                  : $this->_parse_size($new_x$this->img_x);
  304.         $new_y (0 == $new_y)
  305.                  ? $this->img_y
  306.                  : $this->_parse_size($new_y$this->img_y);
  307.  
  308.         // Now do the library specific resizing.
  309.         return $this->_resize($new_x$new_y$options);
  310.     // End resize
  311.  
  312.     /**
  313.      * Scales the image to the specified width
  314.      *
  315.      * This method preserves the aspect ratio
  316.      *
  317.      * @param int $new_x Size to scale X-dimension to
  318.      *
  319.      * @return mixed TRUE or PEAR_Error object on error
  320.      * @access public
  321.      */
  322.     function scaleByX($new_x)
  323.     {
  324.         if ($new_x <= 0{
  325.             return PEAR::raiseError('New size must be strictly positive',
  326.                                         IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
  327.         }
  328.         $new_y round(($new_x $this->img_x$this->img_y0);
  329.         return $this->_resize(max(1$new_x)max(1$new_y));
  330.     // End scaleByX
  331.  
  332.     /**
  333.      * Alias for resize()
  334.      *
  335.      * @see resize()
  336.      */
  337.     function scaleByXY($new_x = 0$new_y = 0$options = null)
  338.     {
  339.         return $this->resize($new_x$new_y$options);
  340.     // End scaleByXY
  341.  
  342.     /**
  343.      * Scales the image to the specified height.
  344.      *
  345.      * This method preserves the aspect ratio
  346.      *
  347.      * @param int $new_y Size to scale Y-dimension to
  348.      *
  349.      * @return mixed TRUE or PEAR_Error object on error
  350.      * @access public
  351.      */
  352.     function scaleByY($new_y)
  353.     {
  354.         if ($new_y <= 0{
  355.             return PEAR::raiseError('New size must be strictly positive',
  356.                                         IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
  357.         }
  358.         $new_x round(($new_y $this->img_y$this->img_x0);
  359.         return $this->_resize(max(1$new_x)max(1$new_y));
  360.     // End scaleByY
  361.  
  362.     /**
  363.      * Scales an image by a percentage, factor or a given length
  364.      *
  365.      * This method preserves the aspect ratio
  366.      *
  367.      * @param mixed $size (number, percentage 10% or 0.1)
  368.      *
  369.      * @return mixed TRUE or PEAR_Error object on error
  370.      * @access public
  371.      * @see scaleByPercentage, scaleByFactor, scaleByLength
  372.      */
  373.     function scale($size)
  374.     {
  375.         if ((strlen($size> 1&& (substr($size-1== '%')) {
  376.             return $this->scaleByPercentage(substr($size0-1));
  377.         elseif ($size < 1{
  378.             return $this->scaleByFactor($size);
  379.         else {
  380.             return $this->scaleByLength($size);
  381.         }
  382.     // End scale
  383.  
  384.     /**
  385.      * Scales an image to a percentage of its original size.  For example, if
  386.      * my image was 640x480 and I called scaleByPercentage(10) then the image
  387.      * would be resized to 64x48
  388.      *
  389.      * @param int $size Percentage of original size to scale to
  390.      *
  391.      * @return mixed TRUE or PEAR_Error object on error
  392.      * @access public
  393.      */
  394.     function scaleByPercentage($size)
  395.     {
  396.         return $this->scaleByFactor($size / 100);
  397.     // End scaleByPercentage
  398.  
  399.     /**
  400.      * Scales an image to a factor of its original size.  For example, if
  401.      * my image was 640x480 and I called scaleByFactor(0.5) then the image
  402.      * would be resized to 320x240.
  403.      *
  404.      * @param float $size Factor of original size to scale to
  405.      *
  406.      * @return mixed TRUE or PEAR_Error object on error
  407.      * @access public
  408.      */
  409.     function scaleByFactor($size)
  410.     {
  411.         if ($size <= 0{
  412.             return PEAR::raiseError('New size must be strictly positive',
  413.                                         IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
  414.         }
  415.         $new_x round($size $this->img_x0);
  416.         $new_y round($size $this->img_y0);
  417.         return $this->_resize(max(1$new_x)max(1$new_y));
  418.     // End scaleByFactor
  419.  
  420.     /**
  421.      * Scales an image so that the longest side has the specified dimension.
  422.      *
  423.      * This method preserves the aspect ratio
  424.      *
  425.      * @param int $size Max dimension in pixels
  426.      *
  427.      * @return mixed TRUE or PEAR_Error object on error
  428.      * @access public
  429.      */
  430.     function scaleMaxLength($size)
  431.     {
  432.         if ($size <= 0{
  433.             return PEAR::raiseError('New size must be strictly positive',
  434.                                         IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
  435.         }
  436.         if ($this->img_x >= $this->img_y{
  437.             $new_x $size;
  438.             $new_y round(($new_x $this->img_x$this->img_y0);
  439.         else {
  440.             $new_y $size;
  441.             $new_x round(($new_y $this->img_y$this->img_x0);
  442.         }
  443.         return $this->_resize(max(1$new_x)max(1$new_y));
  444.     // End scaleMaxLength
  445.  
  446.     /**
  447.      * Alias for scaleMaxLength
  448.      *
  449.      * @param int $size Max dimension in pixels
  450.      *
  451.      * @return mixed TRUE or PEAR_Error object on error
  452.      * @access public
  453.      * @see scaleMaxLength()
  454.      */
  455.     function scaleByLength($size)
  456.     {
  457.         return $this->scaleMaxLength($size);
  458.     }
  459.  
  460.     /**
  461.      * Fits the image in the specified box size
  462.      *
  463.      * If the image is bigger than the box specified by $width and $height,
  464.      * it will be scaled down to fit inside of it.
  465.      * If the image is smaller, nothing is done.
  466.      *
  467.      * @param integer $width  Width of the box in pixels
  468.      * @param integer $height Height of the box in pixels
  469.      *
  470.      * @return bool|PEAR_ErrorTRUE or PEAR_Error object on error
  471.      * @access public
  472.      */
  473.     function fit($width$height)
  474.     {
  475.         if ($width <= 0 || $height <= 0{
  476.             return PEAR::raiseError("Invalid arguments.",
  477.                 IMAGE_TRANSFORM_ERROR_ARGUMENT);
  478.         }
  479.         $x $this->img_x / $width;
  480.         $y $this->img_y / $height;
  481.         if ($x <= 1 && $y <= 1{
  482.             return true;
  483.         elseif ($x $y{
  484.             return $this->scaleByX($width);
  485.         else {
  486.             return $this->scaleByY($height);
  487.         }
  488.     }
  489.  
  490.     /**
  491.      * This works as per fit, but creates the canvas of size $width x $height
  492.      * and positions the resized image on it, by default in the centre.
  493.      *
  494.      * @param unknown_type $width 
  495.      * @param unknown_type $height 
  496.      * @param unknown_type $posn 
  497.      *
  498.      * @return unknown 
  499.      */
  500.     function fitOnCanvas($width$height$posn='center')
  501.     {
  502.         return PEAR::raiseError('fitOnCanvas() method not supported by driver',
  503.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  504.     }
  505.  
  506.     /**
  507.      * Fits the image in the specified width
  508.      *
  509.      * If the image is wider than the width specified by $width,
  510.      * it will be scaled down to fit inside of it.
  511.      * If the image is smaller, nothing is done.
  512.      *
  513.      * @param integer $width Maximum width in pixels
  514.      *
  515.      * @return bool|PEAR_ErrorTRUE or PEAR_Error object on error
  516.      * @access public
  517.      */
  518.     function fitX($width)
  519.     {
  520.         return ($this->img_x <= $width? true : $this->scaleByX($width);
  521.     }
  522.  
  523.     /**
  524.      * Fits the image in the specified height
  525.      *
  526.      * If the image is taller than the height specified by $height,
  527.      * it will be scaled down to fit inside of it.
  528.      * If the image is smaller, nothing is done.
  529.      *
  530.      * @param integer $height Maximum height in pixels
  531.      *
  532.      * @return bool|PEAR_ErrorTRUE or PEAR_Error object on error
  533.      * @access public
  534.      */
  535.     function fitY($height)
  536.     {
  537.         return ($this->img_y <= $height? true : $this->scaleByY($height);
  538.     }
  539.  
  540.     /**
  541.      * Sets one options
  542.      *
  543.      * @param string $name  Name of option
  544.      * @param mixed  $value Value of option
  545.      *
  546.      * @return void 
  547.      * @access public
  548.      * @see setOptions()
  549.      */
  550.     function setOption($name$value)
  551.     {
  552.         $this->_options[$name$value;
  553.     }
  554.  
  555.     /**
  556.      * Sets multiple options at once
  557.      *
  558.      * Associative array of options:
  559.      *  - quality     (Integer: 0: poor - 100: best)
  560.      *  - scaleMethod ('smooth', 'pixel')
  561.      *
  562.      * @param array $options Array of options
  563.      *
  564.      * @return void 
  565.      * @access public
  566.      */
  567.     function setOptions($options)
  568.     {
  569.         $this->_options = array_merge($this->_options$options);
  570.     }
  571.  
  572.     /**
  573.      * Sets the image type (in lowercase letters), the image height and width.
  574.      *
  575.      * @param string $image Image filename
  576.      *
  577.      * @return mixed TRUE or PEAR_error
  578.      * @access protected
  579.      * @see PHP_Compat::image_type_to_mime_type()
  580.      * @link http://php.net/getimagesize
  581.      */
  582.     function _get_image_details($image)
  583.     {
  584.         $data @getimagesize($image);
  585.         //  1 = GIF,   2 = JPG,  3 = PNG,  4 = SWF,  5 = PSD,  6 = BMP,
  586.         //  7 = TIFF (intel byte order),   8 = TIFF (motorola byte order),
  587.         //  9 = JPC,  10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC, 14 = IFF,
  588.         // 15 = WBMP, 16 = XBM
  589.         if (!is_array($data)) {
  590.             return PEAR::raiseError("Cannot fetch image or images details."true);
  591.         }
  592.  
  593.         switch ($data[2]{
  594.             case IMAGETYPE_GIF:
  595.                 $type 'gif';
  596.                 break;
  597.             case IMAGETYPE_JPEG:
  598.                 $type 'jpeg';
  599.                 break;
  600.             case IMAGETYPE_PNG:
  601.                 $type 'png';
  602.                 break;
  603.             case IMAGETYPE_SWF:
  604.                 $type 'swf';
  605.                 break;
  606.             case IMAGETYPE_PSD:
  607.                 $type 'psd';
  608.                 break;
  609.             case IMAGETYPE_BMP:
  610.                 $type 'bmp';
  611.                 break;
  612.             case IMAGETYPE_TIFF_II:
  613.             case IMAGETYPE_TIFF_MM:
  614.                 $type 'tiff';
  615.                 break;
  616.             case IMAGETYPE_JPC:
  617.                 $type 'jpc';
  618.                 break;
  619.             case IMAGETYPE_JP2:
  620.                 $type 'jp2';
  621.                 break;
  622.             case IMAGETYPE_JPX:
  623.                 $type 'jpx';
  624.                 break;
  625.             case IMAGETYPE_JB2:
  626.                 $type 'jb2';
  627.                 break;
  628.             case IMAGETYPE_SWC:
  629.                 $type 'swc';
  630.                 break;
  631.             case IMAGETYPE_IFF:
  632.                 $type 'iff';
  633.                 break;
  634.             case IMAGETYPE_WBMP:
  635.                 $type 'wbmp';
  636.                 break;
  637.             case IMAGETYPE_XBM:
  638.                 $type 'xbm';
  639.                 break;
  640.             default:
  641.                 return PEAR::raiseError("Cannot recognize image format",
  642.                     IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  643.         }
  644.         $this->img_x = $this->new_x = $data[0];
  645.         $this->img_y = $this->new_y = $data[1];
  646.         $this->type  = $type;
  647.  
  648.         return true;
  649.     }
  650.  
  651.     /**
  652.      * Returns the matching IMAGETYPE_* constant for a given image type
  653.      *
  654.      * @param mixed $type String (GIF, JPG,...)
  655.      *
  656.      * @return mixed string or integer or input on error
  657.      * @access protected
  658.      * @see PHP_Compat::image_type_to_mime_type()
  659.      ***/
  660.     function _convert_image_type($type)
  661.     {
  662.         switch (strtolower($type)) {
  663.             case 'gif':
  664.                 return IMAGETYPE_GIF;
  665.             case 'jpeg':
  666.             case 'jpg':
  667.                 return IMAGETYPE_JPEG;
  668.             case 'png':
  669.                 return IMAGETYPE_PNG;
  670.             case 'swf':
  671.                 return IMAGETYPE_SWF;
  672.             case 'psd':
  673.                 return IMAGETYPE_PSD;
  674.             case 'bmp':
  675.                 return IMAGETYPE_BMP;
  676.             case 'tiff':
  677.                 return IMAGETYPE_TIFF_II;
  678.                 //IMAGETYPE_TIFF_MM;
  679.             case 'jpc':
  680.                 return IMAGETYPE_JPC;
  681.             case 'jp2':
  682.                 return IMAGETYPE_JP2;
  683.             case 'jpx':
  684.                 return IMAGETYPE_JPX;
  685.             case 'jb2':
  686.                 return IMAGETYPE_JB2;
  687.             case 'swc':
  688.                 return IMAGETYPE_SWC;
  689.             case 'iff':
  690.                 return IMAGETYPE_IFF;
  691.             case 'wbmp':
  692.                 return IMAGETYPE_WBMP;
  693.             case 'xbm':
  694.                 return IMAGETYPE_XBM;
  695.             default:
  696.                 return $type;
  697.         }
  698.  
  699.         return (isset($types[$t strtolower($type)])) $types[$t$type;
  700.     }
  701.  
  702.     /**
  703.      * Parses input for number format and convert
  704.      *
  705.      * If either parameter is 0 it will be scaled proportionally
  706.      *
  707.      * @param mixed $new_size (0, number, percentage 10% or 0.1)
  708.      * @param int   $old_size 
  709.      *
  710.      * @return mixed Integer or PEAR_error
  711.      * @access protected
  712.      */
  713.     function _parse_size($new_size$old_size)
  714.     {
  715.         if (substr($new_size-1== '%'{
  716.             $new_size substr($new_size0-1);
  717.             $new_size $new_size / 100;
  718.         }
  719.         if ($new_size > 1{
  720.             return (int) $new_size;
  721.         elseif ($new_size == 0{
  722.             return (int) $old_size;
  723.         else {
  724.             return (int) round($new_size $old_size0);
  725.         }
  726.     }
  727.  
  728.     /**
  729.      * Returns an angle between 0 and 360 from any angle value
  730.      *
  731.      * @param float $angle The angle to normalize
  732.      *
  733.      * @return float the angle
  734.      * @access protected
  735.      */
  736.     function _rotation_angle($angle)
  737.     {
  738.         $angle %= 360;
  739.         return ($angle < 0$angle + 360 : $angle;
  740.     }
  741.  
  742.     /**
  743.      * Returns the current value of $this->default_text_params.
  744.      *
  745.      * @return array $this->default_text_params The current text parameters
  746.      * @access protected
  747.      */
  748.     function _get_default_text_params()
  749.     {
  750.         return $this->default_text_params;
  751.     }
  752.  
  753.     /**
  754.      * Sets the image width
  755.      *
  756.      * @param int $size dimension to set
  757.      *
  758.      * @return void 
  759.      * @access protected
  760.      * @since 29/05/02 13:36:31
  761.      */
  762.     function _set_img_x($size)
  763.     {
  764.         $this->img_x = $size;
  765.     }
  766.  
  767.     /**
  768.      * Sets the image height
  769.      *
  770.      * @param int $size dimension to set
  771.      *
  772.      * @return void 
  773.      * @access protected
  774.      * @since 29/05/02 13:36:31
  775.      */
  776.     function _set_img_y($size)
  777.     {
  778.         $this->img_y = $size;
  779.     }
  780.  
  781.     /**
  782.      * Sets the new image width
  783.      *
  784.      * @param int $size dimension to set
  785.      *
  786.      * @return void 
  787.      * @access protected
  788.      * @since 29/05/02 13:36:31
  789.      */
  790.     function _set_new_x($size)
  791.     {
  792.         $this->new_x = $size;
  793.     }
  794.  
  795.     /**
  796.      * Sets the new image height
  797.      *
  798.      * @param int $size dimension to set
  799.      *
  800.      * @return void 
  801.      * @since 29/05/02 13:36:31
  802.      * @access protected
  803.      */
  804.     function _set_new_y($size)
  805.     {
  806.         $this->new_y = $size;
  807.     }
  808.  
  809.     /**
  810.      * Returns the image handle so that one can further try
  811.      * to manipulate the image
  812.      *
  813.      * @return resource 
  814.      *
  815.      * @access public
  816.      */
  817.     function getHandle()
  818.     {
  819.         return PEAR::raiseError('getHandle() method not supported by driver',
  820.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  821.     }//function getHandle()
  822.  
  823.     /**
  824.      * Returns the type of the image being manipulated
  825.      *
  826.      * @return string the image type
  827.      * @access public
  828.      */
  829.     function getImageType()
  830.     {
  831.         return $this->type;
  832.     }
  833.  
  834.     /**
  835.      * Returns the MIME type of the image being manipulated
  836.      *
  837.      * @param string $type Image type to get MIME type for
  838.      *
  839.      * @return string The MIME type if available, or an empty string
  840.      * @access public
  841.      * @see PHP_Compat::image_type_to_mime_type()
  842.      * @link http://php.net/image_type_to_mime_type
  843.      */
  844.     function getMimeType($type = null)
  845.     {
  846.         return image_type_to_mime_type($this->_convert_image_type(($type$type $this->type));
  847.     }
  848.  
  849.     /**
  850.      * Returns the new image width
  851.      *
  852.      * This function returns the width
  853.      * of the new image.
  854.      *
  855.      * @access public
  856.      * @return int  The width of the new image.
  857.      */
  858.     function getNewImageWidth()
  859.     {
  860.         if (isset($this->new_x)) {
  861.             return (int)$this->new_x;
  862.         }
  863.  
  864.         return false;
  865.     }
  866.  
  867.     /**
  868.      * Return new image Y
  869.      *
  870.      * This function will retrieve the
  871.      * new image 'Y' and return it's value
  872.      * if it's set.
  873.      *
  874.      * @access public
  875.      * @return int  The new height of the image.
  876.      */
  877.     function getNewImageHeight()
  878.     {
  879.         if (isset($this->new_y)) {
  880.             return (int)$this->new_y;
  881.         }
  882.  
  883.         return false;
  884.     }
  885.  
  886.     /**
  887.      * Returns the image width
  888.      *
  889.      * @return int the width of the image
  890.      * @access public
  891.      */
  892.     function getImageWidth()
  893.     {
  894.         return $this->img_x;
  895.     }
  896.  
  897.     /**
  898.       * Returns the image height
  899.       *
  900.       * @return int the width of the image
  901.       * @access public
  902.       */
  903.     function getImageHeight()
  904.     {
  905.         return $this->img_y;
  906.     }
  907.  
  908.     /**
  909.      * Returns the image size and extra format information
  910.      *
  911.      * @return array The width and height of the image
  912.      * @access public
  913.      * @see PHP::getimagesize()
  914.      */
  915.     function getImageSize()
  916.     {
  917.         return array(
  918.             $this->img_x,
  919.             $this->img_y,
  920.             $this->_convert_image_type($this->type),
  921.             'height="' $this->img_y . '" width="' $this->img_x . '"',
  922.             'mime' => $this->getMimeType());
  923.     }
  924.  
  925.     /**
  926.      * This looks at the current image type and attempts to determine which
  927.      * web-safe format will be most suited.  It does not work brilliantly with
  928.      * *.png images, because it is very difficult to know whether they are
  929.      * 8-bit or greater.  Guess I need to have fatter code here :-)
  930.      *
  931.      * @return string web-safe image type
  932.      * @access public
  933.      */
  934.     function getWebSafeFormat()
  935.     {
  936.         switch ($this->type){
  937.             case 'gif':
  938.             case 'png':
  939.                 return 'png';
  940.                 break;
  941.             default:
  942.                 return 'jpeg';
  943.         // switch
  944.     }
  945.  
  946.     /**
  947.      * Handles space in path and Windows/UNIX difference
  948.      *
  949.      * @param string $path    Base dir
  950.      * @param string $command Command to execute
  951.      * @param string $args    Arguments to pass to the command
  952.      *
  953.      * @return string A prepared string suitable for exec()
  954.      * @access protected
  955.      */
  956.     function _prepare_cmd($path$command$args '')
  957.     {
  958.         if (!OS_WINDOWS
  959.             || !preg_match('/\s/'$path)) {
  960.             return $path $command ' ' $args;
  961.         }
  962.         return 'start /D "' $path '" /B ' $command ' ' $args;
  963.     }
  964.  
  965.     /**
  966.      * Place holder for the real resize method
  967.      * used by extended methods to do the resizing
  968.      *
  969.      * @return PEAR_error 
  970.      * @access protected
  971.      */
  972.     function _resize()
  973.     {
  974.         return PEAR::raiseError('Resize method not supported by driver',
  975.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  976.     }
  977.  
  978.     /**
  979.      * Normalizes the colors, gamma and other properties of an image
  980.      * (this should give a result equivalent to a Photoshop autolevels)
  981.      *
  982.      * @return PEAR_error 
  983.      * @access public
  984.      */
  985.     function normalize()
  986.     {
  987.         return PEAR::raiseError('Normalize method not supported by driver',
  988.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  989.     }
  990.  
  991.     /**
  992.      * Loads an image file to work with
  993.      *
  994.      * Place holder for the real load method
  995.      * used by extended methods to do the resizing
  996.      *
  997.      * @param string $filename Full name of file
  998.      *
  999.      * @return PEAR_error 
  1000.      * @access public
  1001.      */
  1002.     function load($filename)
  1003.     {
  1004.         return PEAR::raiseError('load() method not supported by driver',
  1005.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1006.     }
  1007.  
  1008.     /**
  1009.      * Outputs the image to standard output
  1010.      *
  1011.      * Place holder for the real display method
  1012.      * used by extended methods to do the resizing
  1013.      *
  1014.      * @param string $type    Format of image to save as
  1015.      * @param mixed  $quality Format-dependent
  1016.      *
  1017.      * @return PEAR_error 
  1018.      * @access public
  1019.      */
  1020.     function display($type$quality = null)
  1021.     {
  1022.         return PEAR::raiseError('display() method not supported by driver',
  1023.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1024.     }
  1025.  
  1026.     /**
  1027.      * Returns if the driver supports a given image type
  1028.      *
  1029.      * @param string $type Image type (GIF, PNG, JPEG...)
  1030.      * @param string $mode 'r' for read, 'w' for write, 'rw' for both
  1031.      *
  1032.      * @return TRUE if type (and mode) is supported FALSE otherwise
  1033.      * @access public
  1034.      */
  1035.     function supportsType($type$mode 'rw')
  1036.     {
  1037.         return (strpos(@$this->_supported_image_types[strtolower($type)]$mode=== false? false : true;
  1038.     }
  1039.  
  1040.     /**
  1041.      * Saves image to file
  1042.      *
  1043.      * Place holder for the real save method
  1044.      * used by extended methods to do the resizing
  1045.      *
  1046.      * @param string $filename Filename to save image to
  1047.      * @param string $type     Format of image to save as
  1048.      * @param mixed  $quality  Format-dependent
  1049.      *
  1050.      * @return PEAR_error 
  1051.      * @access public
  1052.      */
  1053.     function save($filename$type$quality = null)
  1054.     {
  1055.         return PEAR::raiseError('save() method not supported by driver',
  1056.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1057.     }
  1058.  
  1059.     /**
  1060.      * Releases resource
  1061.      *
  1062.      * Place holder for the real free method
  1063.      * used by extended methods to do the resizing
  1064.      *
  1065.      * @return PEAR_error 
  1066.      * @access public
  1067.      */
  1068.     function free()
  1069.     {
  1070.         return PEAR::raiseError('free() method not supported by driver',
  1071.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1072.     }
  1073.  
  1074.     /**
  1075.      * Converts a color string into an array of RGB values
  1076.      *
  1077.      * @param string $colorhex A color following the #FFFFFF format
  1078.      *
  1079.      * @return array 3-element array with 0-255 values
  1080.      * @access public
  1081.      *
  1082.      * @see rgb2colorname
  1083.      * @see colorarray2colorhex
  1084.      */
  1085.     function colorhex2colorarray($colorhex)
  1086.     {
  1087.         $r hexdec(substr($colorhex12));
  1088.         $g hexdec(substr($colorhex32));
  1089.         $b hexdec(substr($colorhex52));
  1090.         return array($r$g$b'type' => 'RGB');
  1091.     }
  1092.  
  1093.     function _send_display_headers($type)
  1094.     {
  1095.         // Find the filename of the original image:
  1096.         $filename explode('.'basename($this->image));
  1097.         $filename $filename[0];
  1098.         header('Content-type: ' $this->getMimeType($type));
  1099.         header('Content-Disposition: inline; filename=' $filename '.' $type);
  1100.     }
  1101.  
  1102.     /**
  1103.      * Converts an array of RGB value into a #FFFFFF format color.
  1104.      *
  1105.      * @param array $color 3-element array with 0-255 values
  1106.      *
  1107.      * @return mixed A color following the #FFFFFF format or FALSE
  1108.      *                if the array couldn't be converted
  1109.      * @access public
  1110.      *
  1111.      * @see rgb2colorname
  1112.      * @see colorhex2colorarray
  1113.      */
  1114.     function colorarray2colorhex($color)
  1115.     {
  1116.         if (!is_array($color)) {
  1117.             return false;
  1118.         }
  1119.         $color sprintf('#%02X%02X%02X'@$color[0]@$color[1]@$color[2]);
  1120.         return (strlen($color!= 7? false : $color;
  1121.     }
  1122.  
  1123.     /**
  1124.      * Returns the temp directory according to either the TMP, TMPDIR, or TEMP env
  1125.      * variables. If these are not set it will also check for the existence of
  1126.      * /tmp, %WINDIR%\temp
  1127.      *
  1128.      * @access public
  1129.      * @return string The system tmp directory
  1130.      */
  1131.     function getTempDir()
  1132.     {
  1133.         include_once 'System.php';
  1134.         return System::tmpdir();
  1135.     }
  1136.  
  1137.     /**
  1138.      * Returns a temporary filename using tempnam() and the above getTmpDir() function.
  1139.      *
  1140.      * @param string $dirname Optional directory name for the tmp file
  1141.      *
  1142.      * @return string Filename and path of the tmp file
  1143.      * @access public
  1144.      */
  1145.     function getTempFile($dirname = null)
  1146.     {
  1147.         if (is_null($dirname)) {
  1148.             include_once 'System.php';
  1149.             $dirname = System::tmpdir();
  1150.         }
  1151.  
  1152.         return tempnam($dirname'temp.');
  1153.     }
  1154.  
  1155.     function keepSettingsOnSave($bool)
  1156.     {
  1157.         $this->keep_settings_on_save = $bool;
  1158.     }
  1159.  
  1160.     /**
  1161.      * Methods to add to the driver classes in the future
  1162.      *
  1163.      * @return void 
  1164.      */
  1165.     function addText()
  1166.     {
  1167.         return PEAR::raiseError('addText() method not supported by driver',
  1168.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1169.     }
  1170.  
  1171.     function addDropShadow()
  1172.     {
  1173.         return PEAR::raiseError('addDropShadow() method not supported by driver',
  1174.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1175.     }
  1176.  
  1177.     function addBorder()
  1178.     {
  1179.         return PEAR::raiseError('addBorder() method not supported by driver',
  1180.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1181.     }
  1182.  
  1183.     /**
  1184.      * Crops an image
  1185.      *
  1186.      * @param int $width  Cropped image width
  1187.      * @param int $height Cropped image height
  1188.      * @param int $x      X-coordinate to crop at
  1189.      * @param int $y      Y-coordinate to crop at
  1190.      *
  1191.      * @return mixed TRUE or a PEAR_Error object on error
  1192.      * @access public
  1193.      ***/
  1194.     function crop($width$height$x = 0$y = 0)
  1195.     {
  1196.         return PEAR::raiseError('crop() method not supported by driver',
  1197.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1198.     }
  1199.  
  1200.     function canvasResize()
  1201.     {
  1202.         return PEAR::raiseError('canvasResize() method not supported by driver',
  1203.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1204.     }
  1205.  
  1206.     /**
  1207.      * Corrects the gamma of an image
  1208.      *
  1209.      * @param float $outputgamma Gamma correction factor
  1210.      *
  1211.      * @return mixed TRUE or a PEAR_error object on error
  1212.      * @access public
  1213.      ***/
  1214.     function gamma($outputgamma = 1.0)
  1215.     {
  1216.         return PEAR::raiseError('gamma() method not supported by driver',
  1217.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1218.     }
  1219.  
  1220.     /**
  1221.      * Rotates the image clockwise
  1222.      *
  1223.      * @param float $angle   Angle of rotation in degres
  1224.      * @param mixed $options Rotation options
  1225.      *
  1226.      * @return bool|PEAR_ErrorTRUE on success, PEAR_Error object on error
  1227.      * @access public
  1228.      */
  1229.     function rotate($angle$options = null)
  1230.     {
  1231.         return PEAR::raiseError('rotate() method not supported by driver',
  1232.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1233.     }
  1234.  
  1235.     /**
  1236.      * Horizontal mirroring
  1237.      *
  1238.      * @return mixed TRUE or PEAR_Error object on error
  1239.      * @access public
  1240.      * @see flip()
  1241.      ***/
  1242.     function mirror()
  1243.     {
  1244.         return PEAR::raiseError('mirror() method not supported by driver',
  1245.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1246.     }
  1247.  
  1248.     /**
  1249.      * Vertical mirroring
  1250.      *
  1251.      * @return TRUE or PEAR Error object on error
  1252.      * @access public
  1253.      * @see mirror()
  1254.      ***/
  1255.     function flip()
  1256.     {
  1257.         return PEAR::raiseError('flip() method not supported by driver',
  1258.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1259.     }
  1260.  
  1261.     /**
  1262.      * Converts an image into greyscale colors
  1263.      *
  1264.      * @return mixed TRUE or a PEAR error object on error
  1265.      * @access public
  1266.      ***/
  1267.     function greyscale()
  1268.     {
  1269.         return PEAR::raiseError('greyscale() method not supported by driver',
  1270.             IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
  1271.     }
  1272.  
  1273.     /**
  1274.      * Converts an image into greyscale colors
  1275.      *
  1276.      * @return mixed TRUE or a PEAR error object on error
  1277.      * @see greyscale()
  1278.      ***/
  1279.     function grayscale()
  1280.     {
  1281.         return $this->greyscale();
  1282.     }
  1283.  
  1284.     /**
  1285.      * Returns a color option
  1286.      *
  1287.      * @param string $colorOf one of 'canvasColor', 'pencilColor', 'fontColor'
  1288.      * @param array  $options configuration options
  1289.      * @param array  $default default value to return if color not found
  1290.      *
  1291.      * @return array an RGB color array
  1292.      * @access protected
  1293.      */
  1294.     function _getColor($colorOf$options = array()$default = array(000))
  1295.     {
  1296.         $opt array_merge($this->_options(array) $options);
  1297.         if (isset($opt[$colorOf])) {
  1298.             $color $opt[$colorOf];
  1299.             if (is_array($color)) {
  1300.                 return $color;
  1301.             }
  1302.             if ($color{0== '#'{
  1303.                 return $this->colorhex2colorarray($color);
  1304.             }
  1305.             static $colornames = array();
  1306.             include_once 'Image/Transform/Driver/ColorsDefs.php';
  1307.             return (isset($colornames[$color])) $colornames[$color$default;
  1308.         }
  1309.         return $default;
  1310.     }
  1311.  
  1312.     /**
  1313.      * Returns an option
  1314.      *
  1315.      * @param string $name    name of option
  1316.      * @param array  $options local override option array
  1317.      * @param mixed  $default default value to return if option is not found
  1318.      *
  1319.      * @return mixed the option
  1320.      * @access protected
  1321.      */
  1322.     function _getOption($name$options = array()$default = null)
  1323.     {
  1324.         $opt array_merge($this->_options(array) $options);
  1325.         return (isset($opt[$name])) $opt[$name$default;
  1326.     }
  1327.  
  1328.     /**
  1329.      * Checks if the rectangle passed intersects with the current image
  1330.      *
  1331.      * @param int $width  Width of rectangle
  1332.      * @param int $height Height of rectangle
  1333.      * @param int $x      X-coordinate
  1334.      * @param int $y      Y-coordinate
  1335.      *
  1336.      * @return bool|PEAR_ErrorTRUE if intersects, FALSE if not,
  1337.      *                          and PEAR_Error on error
  1338.      * @access public
  1339.      */
  1340.     function intersects($width$height$x$y)
  1341.     {
  1342.         $left  $x;
  1343.         $right $x $width;
  1344.         if ($right $left{
  1345.             $left  $right;
  1346.             $right $x;
  1347.         }
  1348.         $top    $y;
  1349.         $bottom $y $height;
  1350.         if ($bottom $top{
  1351.             $top    $bottom;
  1352.             $bottom $y;
  1353.         }
  1354.         return (bool) ($left $this->new_x
  1355.                        && $right >= 0
  1356.                        && $top $this->new_y
  1357.                        && $bottom >= 0);
  1358.     }
  1359. }

Documentation generated on Wed, 04 Apr 2012 00:30:11 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.