RedVodkaJelly Logo

PHP Image Resize Class

POSTED AT 15:39 on 23rd May 2008

This is a PHP class that deals with resizing jpg, png and gif images. You just pass it the image you want to resize, a location to save the new image to and instructions on how to you want it resized and the class will do the rest.

Please note that your version of PHP must be compiled with the GD library in order for this class to work.

Source Code

  1. <?php
     
  2. /*
     
  3. * PHP Image Resize Class
     
  4. *
     
  5. * Class to deal with resizing images using PHP.
     
  6. * Will resize any JPG, GIF or PNG file.
     
  7. *
     
  8. * Written By Jacob Wyke - jacob@redvodkajelly.com - www.redvodkajelly.com
     
  9. *
     
  10. * LICENSE

     

  11. * ——-
     
  12. * Feel free to use this as you wish, just give me credit where credits due and drop me an email telling me what your using it for so I can check out all the cool ways its been used.
     
  13. *
     
  14. * USAGE
     
  15. * —–
     
  16. * To use this class simply call it with the following details:
     
  17. *
     
  18. *       Path to original image,
     
  19. *       Path to save new image,
     
  20. *       Resize type,
     
  21. *       Resize Data
     
  22. *    

     

  23. * The resize type can be one of four:
     
  24. *
     
  25. *       W   =   Width
     
  26. *       H   =   Height
     
  27. *       P   =   Percentage
     
  28. *       C   =   Custom

     

  29. *
     
  30. * All of these take integers except Custom that takes an array of two integers - for width and height.
     
  31. *
     
  32. *       $objResize = new RVJ_ImageResize(’myImage.png’, ‘myThumb.png’, ‘W’, ‘400′);
     
  33. *       $objResize = new RVJ_ImageResize(’myImage.jpg’, ‘myThumb.jpg’, ‘H’, ‘150′);
     
  34. *       $objResize = new RVJ_ImageResize(’myImage.gif’, ‘myThumb.gif’, ‘P’, ‘50′);
     
  35. *       $objResize = new RVJ_ImageResize(’myImage.png’, ‘myThumb.png’, ‘C’, array(’400′, ‘300′));
     
  36. *
     
  37. * When resizing by width, height and percentage, the image will keep its original ratio. Custom will simply resizes the image to whatever values you want - without keeping the original ratio.
     
  38. *
     
  39. * The class can handle jpg, png and gif images.
     
  40. *
     
  41. * The class will always save the image that it resizes, however you can also have it display the image:

     

  42. *
     
  43. *       $objResize->showImage($resize->im2);
     
  44. *
     
  45. * The class holds the original image in the variable ‘im’ and the new image in ‘im2′. Therefore the code above will show the newly created image.
     
  46. *
     
  47. * You can get information about the image by doing the following:
     
  48. *
     
  49. *       print_r($objResize->findResourceDetails($objResize->resOriginalImage));
     
  50. *       print_r($objResize->findResourceDetails($objResize->resResizedImage));

     

  51. *
     
  52. * This will be useful if you wish to retrieve any details about the images.
     
  53. * 
  54. * By default the class will stop you from enlarging your images (or else they will look grainy) and if you want to do this you must turn off the protection mode by passing a 5th parameter 
  55. * 
  56. *      $objResize = new RVJ_ImageResize(’myImage.gif’, ‘myEnlargedImage.gif’, ‘P’, ‘200′, false); 
  57. *
     
  58. */
     
  59.  
  60. class RVJ_ImageResize {
     
  61.  
  62.    var $strOriginalImagePath;
     
  63.    var $strResizedImagePath;
     
  64.    var $arrOriginalDetails;
     
  65.    var $arrResizedDetails;
     
  66.    var $resOriginalImage;

     

  67.    var $resResizedImage;
     
  68.    var $boolProtect = true; 
  69.  
  70.    /* 
  71.    * 
  72.    *   @Method:      __constructor 
  73.    *   @Parameters:   5
     
  74.    *   @Param-1:      strPath - String - The path to the image
     
  75.    *   @Param-2:      strSavePath - String - The path to save the new image to

     

  76.    *   @Param-3:      strType - String - The type of resize you want to perform
     
  77.    *   @Param-4:      value - Number/Array - The resize dimensions 
  78.    *   @Param-5:      boolProect - Boolen - Protects the image so that it doesnt resize an image if its already smaller 
  79.    *   @Description:   Calls the RVJ_Pagination method so its php 4 compatible 
  80.    * 
  81.    */
     
  82.    function __constructor($strPath, $strSavePath, $strType = ‘W’, $value = ‘150′, $boolProtect = true){
     
  83.       $this->RVJ_ImageResize($strPath, $strSavePath, $strType, $value);

     

  84.    }
     
  85.    
     
  86.    /* 
  87.    * 
  88.    *   @Method:      RVJ_ImageResize 
  89.    *   @Parameters:   5
     
  90.    *   @Param-1:      strPath - String - The path to the image
     
  91.    *   @Param-2:      strSavePath - String - The path to save the new image to
     
  92.    *   @Param-3:      strType - String - The type of resize you want to perform

     

  93.    *   @Param-4:      value - Number/Array - The resize dimensions 
  94.    *   @Param-5:      boolProect - Boolen - Protects the image so that it doesnt resize an image if its already smaller 
  95.    *   @Description:   Calls the RVJ_Pagination method so its php 4 compatible 
  96.    * 
  97.    */
     
  98.    function RVJ_ImageResize($strPath, $strSavePath, $strType = ‘W’, $value = ‘150′, $boolProtect = true){
     
  99.       //save the image/path details
     
  100.       $this->strOriginalImagePath = $strPath;
     
  101.       $this->strResizedImagePath = $strSavePath;

     

  102.       $this->boolProtect = $boolProtect; 
  103.       
     
  104.       //get the image dimensions
     
  105.       $this->arrOriginalDetails = getimagesize($this->strOriginalImagePath);
     
  106.       $this->arrResizedDetails = $this->arrOriginalDetails;
     
  107.       
     
  108.       //create an image resouce to work with
     
  109.       $this->resOriginalImage = $this->createImage($this->strOriginalImagePath);
     
  110.                                           

     

  111.       //select the image resize type
     
  112.       switch(strtoupper($strType)){
     
  113.          case ‘P’:
     
  114.             $this->resizeToPercent($value);
     
  115.             break;
     
  116.          case ‘H’:
     
  117.             $this->resizeToHeight($value);
     
  118.             break;
     
  119.          case ‘C’:
     
  120.             $this->resizeToCustom($value);
     
  121.             break;
     
  122.          case ‘W’:
     
  123.          default:
     
  124.             $this->resizeToWidth($value);

     

  125.             break;
     
  126.       } 
  127.    }
     
  128.  
  129.    /* 
  130.    * 
  131.    *   @Method:      findResourceDetails 
  132.    *   @Parameters:   1 
  133.    *   @Param-1:      resImage - Resource - The image resource you want details on 
  134.    *   @Description:   Returns an array of details about the resource identifier that you pass it 
  135.    * 
  136.    */

     

  137.    function findResourceDetails($resImage){
     
  138.       //check to see what image is being requested
     
  139.       if($resImage==$this->resResizedImage){                              
     
  140.          //return new image details
     
  141.          return $this->arrResizedDetails;
     
  142.       }else{
     
  143.          //return original image details
     
  144.          return $this->arrOriginalDetails;
     
  145.       }
     
  146.    }
     
  147.  
  148.    /* 
  149.    * 
  150.    *   @Method:      updateNewDetails    
  151.    *   @Parameters:   0 
  152.    *   @Description:   Updates the width and height values of the resized details array 
  153.    * 
  154.    */

     

  155.    function updateNewDetails(){
     
  156.       $this->arrResizedDetails[0] = imagesx($this->resResizedImage);
     
  157.       $this->arrResizedDetails[1] = imagesy($this->resResizedImage);
     
  158.    }
     
  159.       
     
  160.    /* 
  161.    * 
  162.    *   @Method:      createImage 
  163.    *   @Parameters:   1 
  164.    *   @Param-1:      strImagePath - String - The path to the image 
  165.    *   @Description:   Created an image resource of the image path passed to it 
  166.    * 
  167.    */

     

  168.    function createImage($strImagePath){
     
  169.       //get the image details
     
  170.       $arrDetails = $this->findResourceDetails($strImagePath);
     
  171.        
  172.       //choose the correct function for the image type 
  173.       switch($arrDetails['mime']){
     
  174.          case ‘image/jpeg’:
     
  175.             return imagecreatefromjpeg($strImagePath);
     
  176.             break;
     
  177.          case ‘image/png’:
     
  178.             return imagecreatefrompng($strImagePath);
     
  179.             break;
     
  180.          case ‘image/gif’:
     
  181.             return imagecreatefromgif($strImagePath);
     
  182.             break;
     
  183.       }
     
  184.    }

     

  185.       
     
  186.    /* 
  187.    * 
  188.    *   @Method:      saveImage 
  189.    *   @Parameters:   1 
  190.    *   @Param-1:      numQuality - Number - The quality to save the image at 
  191.    *   @Description:   Saves the resize image 
  192.    * 
  193.    */

     

  194.    function saveImage($numQuality = 85){
     
  195.       switch($this->arrResizedDetails['mime']){
     
  196.          case ‘image/jpeg’:
     
  197.             imagejpeg($this->resResizedImage, $this->strResizedImagePath, $numQuality);
     
  198.             break;
     
  199.          case ‘image/png’:
     
  200.             // imagepng = [0-9] (not [0-100])          
  201.             imagepng($this->resResizedImage, $this->strResizedImagePath, 7);
     
  202.             break;
     
  203.          case ‘image/gif’:
     
  204.             imagegif($this->resResizedImage, $this->strResizedImagePath, $numQuality);

     

  205.             break;
     
  206.       }
     
  207.    }
     
  208.    
     
  209.    /* 
  210.    * 
  211.    *   @Method:      showImage 
  212.    *   @Parameters:   1 
  213.    *   @Param-1:      resImage - Resource - The resource of the image you want to display 
  214.    *   @Description:   Displays the image resouce on the screen 
  215.    * 
  216.    */

     

  217.    function showImage($resImage){
     
  218.       //get the image details
     
  219.       $arrDetails = $this->findResourceDetails($resImage);
     
  220.        
  221.       //set the correct header for the image we are displaying 
  222.       header("Content-type: ".$arrDetails['mime']);
     
  223.        
  224.       switch($arrDetails['mime']){
     
  225.          case ‘image/jpeg’:
     
  226.             return imagejpeg($resImage);
     
  227.             break;
     
  228.          case ‘image/png’:
     
  229.             return imagepng($resImage);
     
  230.             break;
     
  231.          case ‘image/gif’:
     
  232.             return imagegif($resImage);

     

  233.             break;
     
  234.       }
     
  235.    }
     
  236.    
     
  237.    /* 
  238.    * 
  239.    *   @Method:      destroyImage 
  240.    *   @Parameters:   1 
  241.    *   @Param-1:      resImage - Resource - The image resource you want to destroy 
  242.    *   @Description:   Destroys the image resource and so cleans things up 
  243.    * 
  244.    */

     

  245.    function destroyImage($resImage){
     
  246.       imagedestroy($resImage);
     
  247.    }
     
  248.    
     
  249.    /* 
  250.    * 
  251.    *   @Method:      _resize 
  252.    *   @Parameters:   2 
  253.    *   @Param-1:      numWidth - Number - The width of the image in pixels 
  254.    *   @Param-2:      numHeight - Number - The height of the image in pixes 
  255.    *   @Description:   Resizes the image by creatin a new canvas and copying the image over onto it. DONT CALL THIS METHOD DIRECTLY - USE THE METHODS BELOW 
  256.    * 
  257.    */

     

  258.    function _resize($numWidth, $numHeight){
     
  259.       //check for image protection 
  260.       if($this->_imageProtect($numWidth, $numHeight)){    
  261.          if($this->arrOriginalDetails['mime']==’image/gif’){
     
  262.             //GIF image
     
  263.             $this->resResizedImage = imagecreate($numWidth, $numHeight);
     
  264.          }else if($this->arrOriginalDetails['mime']==’image/jpeg’){
     
  265.             //JPG image
     
  266.             $this->resResizedImage = imagecreatetruecolor($numWidth, $numHeight);
     
  267.          }else if($this->arrOriginalDetails['mime']==’image/png’){ 
  268.             //PNG image 
  269.             $this->resResizedImage = imagecreatetruecolor($numWidth, $numHeight); 
  270.             imagecolortransparent($this->resResizedImage, imagecolorallocate($this->resResizedImage, 0, 0, 0)); 
  271.             imagealphablending($this->resResizedImage, false); 
  272.             imagesavealpha($this->resResizedImage, true); 
  273.          } 
  274.     
  275.          //update the image size details 
  276.          $this->updateNewDetails(); 
  277.        
  278.          //do the actual image resize 
  279.          imagecopyresized($this->resResizedImage, $this->resOriginalImage, 0, 0, 0, 0, $numWidth, $numHeight, $this->arrOriginalDetails[0], $this->arrOriginalDetails[1]);

     

  280.  
  281.          //saves the image 
  282.          $this->saveImage(); 
  283.       } 
  284.    }
     
  285.  
  286.    /* 
  287.    * 
  288.    *   @Method:      _imageProtect 
  289.    *   @Parameters:   2 
  290.    *   @Param-1:      numWidth - Number - The width of the image in pixels 
  291.    *   @Param-2:      numHeight - Number - The height of the image in pixes 
  292.    *   @Description:   Checks to see if we should allow the resize to take place or not depending on the size the image will be resized to 
  293.    * 
  294.    */    
  295.    function _imageProtect($numWidth, $numHeight){ 
  296.       if($this->boolProtect AND ($numWidth > $this->arrOriginalDetails[0] OR $numHeight > $this->arrOriginalDetails[1])){ 
  297.          return 0; 
  298.       } 
  299.        
  300.       return 1; 
  301.    } 
  302.    

     

  303.    /* 
  304.    * 
  305.    *   @Method:      resizeToWidth 
  306.    *   @Parameters:   1 
  307.    *   @Param-1:      numWidth - Number - The width to resize to in pixels 
  308.    *   @Description:   Works out the height value to go with the width value passed, then calls the resize method. 
  309.    * 
  310.    */
     
  311.    function resizeToWidth($numWidth){

     

  312.       $numHeight=(int)(($numWidth*$this->arrOriginalDetails[1])/$this->arrOriginalDetails[0]);
     
  313.       $this->_resize($numWidth, $numHeight);   
     
  314.    }
     
  315.  
  316.    /* 
  317.    * 
  318.    *   @Method:      resizeToHeight 
  319.    *   @Parameters:   1 
  320.    *   @Param-1:      numHeight - Number - The height to resize to in pixels 
  321.    *   @Description:   Works out the width value to go with the height value passed, then calls the resize method. 
  322.    * 
  323.    */

     

  324.    function resizeToHeight($numHeight){
     
  325.       $numWidth=(int)(($numHeight*$this->arrOriginalDetails[0])/$this->arrOriginalDetails[1]);
     
  326.       $this->_resize($numWidth, $numHeight);   
     
  327.    }
     
  328.    
     
  329.    /* 
  330.    * 
  331.    *   @Method:      resizeToPercent 
  332.    *   @Parameters:   1 
  333.    *   @Param-1:      numPercent - Number - The percentage you want to resize to 
  334.    *   @Description:   Works out the width and height value to go with the percent value passed, then calls the resize method. 
  335.    * 
  336.    */

     

  337.    function resizeToPercent($numPercent){
     
  338.       $numWidth = (int)(($this->arrOriginalDetails[0]/100)*$numPercent);
     
  339.       $numHeight = (int)(($this->arrOriginalDetails[1]/100)*$numPercent);
     
  340.       $this->_resize($numWidth, $numHeight);   
     
  341.    }
     
  342.  
  343.    /* 
  344.    * 
  345.    *   @Method:      resizeToCustom 
  346.    *   @Parameters:   1 
  347.    *   @Param-1:      size - Number/Array - Either a number of array of numbers for the width and height in pixels 
  348.    *   @Description:   Checks to see if array was passed and calls the resize method with the correct values. 
  349.    * 
  350.    */

     

  351.    function resizeToCustom($size){
     
  352.       if(!is_array($size)){
     
  353.          $this->_resize((int)$size, (int)$size);
     
  354.       }else{
     
  355.          $this->_resize((int)$size[0], (int)$size[1]);
     
  356.       }
     
  357.    }
     
  358.    
     
  359. }
     
  360.  
  361. ?>