Source for file image_functions.php

Documentation is available at image_functions.php

  1. <?php
  2. /**
  3.  * CodeIgniter
  4.  *
  5.  * An open source application development framework for PHP 4.3.2 or newer
  6.  *
  7.  * @package        CodeIgniter
  8.  * @subpackage     Helpers
  9.  * @author        ExpressionEngine Dev Team
  10.  * @copyright    Copyright (c) 2006, EllisLab, Inc.
  11.  * @license        http://codeigniter.com/user_guide/license.html
  12.  * @link        http://codeigniter.com
  13.  * @since        Version 1.0
  14.  * @filesource
  15.  */
  16.  
  17. // ------------------------------------------------------------------------
  18.  
  19. /**
  20.  * CodeIgniter Image Helpers
  21.  *
  22.  * @author        Estudio Quadra
  23.  * @link        http://codeigniter.com/user_guide/helpers/file_helpers.html
  24.  */
  25.  
  26. // ------------------------------------------------------------------------
  27.  
  28. if (function_exists('save_resampled')) {
  29.     /**
  30.      * Graba una imagen con un previo resampleo.
  31.      * El parametro $aImage es lo que viene por $_FILES.
  32.      * El parametro $cDestPath es el path de destino donde se quiere guardar la imagen.
  33.      * -- no debe terminar en barra.
  34.      * El parametro $aSizes son los tamanios de imagenes (para resamplear), EJ:
  35.      * -> 0: x => 120, y => 75, suf => 'thumb', q => 0 ~ 100
  36.      * -> 1: x => 240, y => 150, suf => 'crop1', q => 0 ~ 100
  37.      * $cPref es el prefijo del nombre de la imagen, a ese prefijo se le va a agregar un _INDICE
  38.      * donde INDICE es el numero de indice del tamanio que se uso para resamplear
  39.      * 
  40.      * Si $aSizes se deja en (0,0) no se resamplea la imagen
  41.      *
  42.      * @param array $aImage 
  43.      * @param string $cDestPath 
  44.      * @param array $aSizes 
  45.      * @param string $cName 
  46.      * @return bool 
  47.      */
  48.     function save_resampled($aImage$cDestPath$aSizes$cName false$cType='jpg'{
  49.         
  50.         // Obtiene las dimensiones de la imagen.
  51.         $aImageData getimagesize($aImage['tmp_name']);
  52.         
  53.         // Si no se especifico el nombre lo toma del archivo.
  54.         if ($cName === false{
  55.             $cName preg_replace('/\.[^\.]+$/'''$aImage['name']);
  56.         }
  57.         
  58.         switch ($aImageData[2]{
  59.             case 1:
  60.                 $sImage imagecreatefromgif($aImage['tmp_name']);
  61.                 break;
  62.             case 2:
  63.                 $sImage imagecreatefromjpeg($aImage['tmp_name']);
  64.                 break;
  65.             case 3:
  66.                 $sImage imagecreatefrompng($aImage['tmp_name']);
  67.                 break;
  68.         }
  69.         
  70.         // Si ocurrio algun error al abrir la imagen devuelve falso.
  71.         if (!$sImage{
  72.             return false;
  73.         }
  74.         
  75.         foreach ($aSizes as $aSize{
  76.             // Determina si hay sufijo.
  77.             $cSufijo $aSize['suf'"_{$aSize['suf']}'';
  78.             
  79.             if ($aSize['x'== && $aSize['y'== 0// deja la imagen como esta
  80.                 switch ($cType{
  81.                     case 'gif':
  82.                         imagegif($sImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  83.                         break;
  84.                         
  85.                     case 'png':
  86.                         imagesavealpha($sImagetrue);
  87.                         imagepng($sImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  88.                         break;
  89.                         
  90.                     case 'jpg':
  91.                     default:
  92.                         imagejpeg($sImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  93.                         break;
  94.                 }
  95.             }
  96.             else {
  97.                 
  98.                 // Calcula las proporciones a reducir de cada lado.
  99.                 $nIndiceX $aSize['x'$aImageData[0];
  100.                 $nIndiceY $aSize['y'$aImageData[1];
  101.                 
  102.                   // Calcula la proporcion minima segun las restricciones.
  103.                   // Si se omite algun parametro se toma solo el que se paso explicitamente.
  104.                   if ($nIndiceX == 0{
  105.                       $nIndice $nIndiceY;
  106.                   }
  107.                   elseif ($nIndiceY == 0{
  108.                       $nIndice $nIndiceX;
  109.                   }
  110.                   else {
  111.                       $nIndice min($nIndiceX$nIndiceY);
  112.                   }
  113.                 
  114.                   // Calcula el nuevo tamanio a partir del indice.
  115.                   $nNewWidth round($aImageData[0$nIndice);
  116.                   $nNewHeight round($aImageData[1$nIndice);
  117.                 
  118.                   // Crea la nueva imagen.
  119.                   $sDestImage imagecreatetruecolor($nNewWidth$nNewHeight);
  120.                   imagealphablending($sDestImagefalse);
  121.                   imagecopyresampled($sDestImage$sImage0000$nNewWidth$nNewHeight$aImageData[0]$aImageData[1]);
  122.                   imagesavealpha($sDestImagetrue);
  123.                   
  124.                   // Graba la imagen.
  125.                 switch ($cType{
  126.                     case 'gif':
  127.                         imagegif($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  128.                         break;
  129.                         
  130.                     case 'png':
  131.                         imagepng($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  132.                         break;
  133.                         
  134.                     case 'jpg':
  135.                     default:
  136.                         imagejpeg($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  137.                         break;
  138.                 }
  139.                 
  140.                 imagedestroy($sDestImage);
  141.             }
  142.         }
  143.         
  144.         imagedestroy($sImage);
  145.     }
  146. }
  147.     
  148. // ------------------------------------------------------------------------
  149.  
  150. if (function_exists('save_cropped')) {
  151.     /**
  152.      * Graba una imagen con un previo resampleo.
  153.      * El parametro $aImage es lo que viene por $_FILES.
  154.      * El parametro $cDestPath es el path de destino donde se quiere guardar la imagen.
  155.      * -- no debe terminar en barra.
  156.      * El parametro $aSizes son los tamanios de imagenes (para resamplear), EJ:
  157.      * -> 0: x => 120, y => 75, suf => 'thumb', q => 0 ~ 100
  158.      * -> 1: x => 240, y => 150, suf => 'crop1', q => 0 ~ 100
  159.      * $cPref es el prefijo del nombre de la imagen, a ese prefijo se le va a agregar un _INDICE
  160.      * donde INDICE es el numero de indice del tamanio que se uso para resamplear
  161.      * 
  162.      * Si $aSizes se deja en (0,0) no se resamplea la imagen
  163.      *
  164.      * @param array $aImage 
  165.      * @param string $cDestPath 
  166.      * @param array $aSizes 
  167.      * @param string $cName 
  168.      * @return bool 
  169.      */
  170.     function save_cropped($aImage$cDestPath$aSizes$cName false$cType='jpg'{
  171.         
  172.         // Obtiene las dimensiones de la imagen.
  173.         $aImageData getimagesize($aImage['tmp_name']);
  174.         
  175.         // Si no se especifico el nombre lo toma del archivo.
  176.         if ($cName === false{
  177.             $cName preg_replace('/\.[^\.]+$/'''$aImage['name']);
  178.         }
  179.         
  180.         switch ($aImageData[2]{
  181.             case 1:
  182.                 $sImage imagecreatefromgif($aImage['tmp_name']);
  183.                 break;
  184.             case 2:
  185.                 $sImage imagecreatefromjpeg($aImage['tmp_name']);
  186.                 break;
  187.             case 3:
  188.                 $sImage imagecreatefrompng($aImage['tmp_name']);
  189.                 break;
  190.         }
  191.         
  192.         // Si ocurrio algun error al abrir la imagen devuelve falso.
  193.         if (!$sImage{
  194.             return false;
  195.         }
  196.         
  197.         foreach ($aSizes as $aSize{
  198.             // Determina si hay sufijo.
  199.             $cSufijo $aSize['suf'"_{$aSize['suf']}'';
  200.             
  201.             if ($aSize['x'== && $aSize['y'== 0// deja la imagen como esta
  202.                 switch ($cType{
  203.                     case 'gif':
  204.                         imagegif($sImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  205.                         break;
  206.                         
  207.                     case 'png':
  208.                         imagesavealpha($sImagetrue);
  209.                         imagepng($sImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  210.                         break;
  211.                         
  212.                     case 'jpg':
  213.                     default:
  214.                         imagejpeg($sImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  215.                         break;
  216.                 }
  217.             }
  218.             else {
  219.                 // Calcula las proporciones a reducir de cada lado.
  220.                 $nIndiceX $aSize['x'$aImageData[0];
  221.                 $nIndiceY $aSize['y'$aImageData[1];
  222.                 
  223.                   // Calcula la proporcion maxima segun las restricciones.
  224.                   $nIndice max($nIndiceX$nIndiceY);
  225.                 
  226.                   // Calcula el nuevo tama�o a partir del indice.
  227.                   $nNewWidth round($aImageData[0$nIndice);
  228.                   $nNewHeight round($aImageData[1$nIndice);
  229.                 
  230.                   $aDiff['x'$nNewWidth $aSize['x'];
  231.                   $aDiff['y'$nNewHeight $aSize['y'];
  232.                   
  233.                   $nSrcX ($aImageData[0$aImageData[1]2;
  234.                   $nSrcY ($aImageData[1$aImageData[0]2;
  235.                   
  236.                   if ($nSrcX 0{
  237.                       $nSrcX 0;
  238.                   }
  239.                   
  240.                   if ($nSrcY 0{
  241.                       $nSrcY 0;
  242.                   }
  243.                   
  244.                   $nSrcW $aImageData[0$nSrcX;
  245.                   $nSrcH $aImageData[1$nSrcY;
  246.                   
  247.                   // Crea la nueva imagen.
  248.                   $sDestImage imagecreatetruecolor($aSize['x']$aSize['y']);
  249.                 imagealphablending($sDestImagefalse);
  250.                   imagecopyresampled($sDestImage$sImage0000$nNewWidth$nNewHeight$aImageData[0]$aImageData[1]);
  251.                   imagesavealpha($sDestImagetrue);
  252.                   //imagecopyresampled($sDestImage, $sImage, 0, 0, $nSrcX, $nSrcY, $aSize['x'], $aSize['y'], $aImageData[0], $aImageData[1]);
  253.                   
  254.                   // Graba la imagen.
  255.                 switch ($cType{
  256.                     case 'gif':
  257.                         imagegif($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  258.                         break;
  259.                         
  260.                     case 'png':
  261.                         imagepng($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  262.                         break;
  263.                         
  264.                     case 'jpg':
  265.                     default:
  266.                         imagejpeg($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  267.                         break;
  268.                 }
  269.                 
  270.                 imagedestroy($sDestImage);
  271.             }
  272.         }
  273.         
  274.         imagedestroy($sImage);
  275.     }
  276. }
  277.  
  278. if (function_exists('save_center_crop')) {
  279.     /**
  280.      * Esta funcion es muy similar a save_resampled pero el area cuadrada lo calcula de otra forma.
  281.      * Si las proporciones de la imagen de origen y destino centra la imagen de origen en la de
  282.      * destino para copiar solo una parte de la imagen, esto es para lograr una imagen de destino
  283.      * de dimensiones fijas sin alterar la imagen.
  284.      *
  285.      * @param array $aImage 
  286.      * @param string $cDestPath 
  287.      * @param array $aSizes 
  288.      * @param string $cName 
  289.      */
  290.     function save_center_crop($aImage$cDestPath$aSizes$cName false$cType='jpg'{
  291.         
  292.         // Obtiene las dimensiones de la imagen.
  293.         $aImageData @getimagesize($aImage['tmp_name']);
  294.         
  295.         // Si no se especifico el nombre lo toma del archivo.
  296.         if ($cName === false{
  297.             $cName preg_replace('/\.[^\.]+$/'''$aImage['name']);
  298.         }
  299.         
  300.         switch ($aImageData[2]{
  301.             case 1:
  302.                 $sImage @imagecreatefromgif($aImage['tmp_name']);
  303.                 break;
  304.             case 2:
  305.                 $sImage @imagecreatefromjpeg($aImage['tmp_name']);
  306.                 break;
  307.             case 3:
  308.                 $sImage @imagecreatefrompng($aImage['tmp_name']);
  309.                 break;
  310.         }
  311.         
  312.         // Si ocurrio algun error al abrir la imagen devuelve falso.
  313.         if (!$sImage{
  314.             return false;
  315.         }
  316.         
  317.         foreach ($aSizes as $aSize{
  318.             // Determina si hay sufijo.
  319.             $cSufijo $aSize['suf'"_{$aSize['suf']}'';
  320.             
  321.             if ($aSize['x'== && $aSize['y'== 0// deja la imagen como esta
  322.                 switch ($cType{
  323.                     case 'gif':
  324.                         imagegif($sImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  325.                         break;
  326.                         
  327.                     case 'png':
  328.                         imagesavealpha($sImagetrue);
  329.                         imagepng($sImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  330.                         break;
  331.                         
  332.                     case 'jpg':
  333.                     default:
  334.                         imagejpeg($sImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  335.                         break;
  336.                 }
  337.             }
  338.             else {
  339.                 // Calcula el area maxima de origen.
  340.                 $nIndiceX $aImageData[0$aSize['x'];
  341.                 $nIndiceY $aImageData[1$aSize['y'];
  342.                 $nIndice min($nIndiceX$nIndiceY);
  343.                 
  344.                 // Estas son las dimensiones definitivas de origen.
  345.                 $nAnchoOrigen $nIndice $aSize['x'];
  346.                 $nAltoOrigen $nIndice $aSize['y'];
  347.                 
  348.                 // Encuentra el centro de la imagen de origen.
  349.                 $nDiffX $aImageData[0$nAnchoOrigen;
  350.                 $nDiffY $aImageData[1$nAltoOrigen;
  351.                 $nOrigenX $nDiffX 2;
  352.                 $nOrigenY $nDiffY 2;
  353.                 
  354.                   // Crea la nueva imagen.
  355.                   $sDestImage imagecreatetruecolor($aSize['x']$aSize['y']);
  356.                   
  357.                   imagealphablending($sDestImagefalse);
  358.                   // Efectua el copiado de la imagen de origen a la imagen de destino.
  359.                   imagecopyresampled($sDestImage$sImage00$nOrigenX$nOrigenY$aSize['x']$aSize['y']$nAnchoOrigen$nAltoOrigen);
  360.                   imagesavealpha($sDestImagetrue);
  361.                   
  362.                   // Graba la imagen.
  363.                 switch ($cType{
  364.                     case 'gif':
  365.                         imagegif($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  366.                         break;
  367.                         
  368.                     case 'png':
  369.                         imagepng($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  370.                         break;
  371.                         
  372.                     case 'jpg':
  373.                     default:
  374.                         imagejpeg($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  375.                         break;
  376.                 }
  377.                 
  378.                 imagedestroy($sDestImage);
  379.             }
  380.         }
  381.         
  382.         imagedestroy($sImage);
  383.     }
  384. }
  385.  
  386. if (function_exists('save_resized')) {
  387.     /**
  388.      * Esta funcion fuerza el tamaño especificado.
  389.      *
  390.      * @param array $aImage 
  391.      * @param string $cDestPath 
  392.      * @param array $aSizes 
  393.      * @param string $cName 
  394.      */
  395.     function save_resized($aImage$cDestPath$aSizes$cName false$cType='jpg'{
  396.         
  397.         // Obtiene las dimensiones de la imagen.
  398.         $aImageData @getimagesize($aImage['tmp_name']);
  399.         
  400.         // Si no se especifico el nombre lo toma del archivo.
  401.         if ($cName === false{
  402.             $cName preg_replace('/\.[^\.]+$/'''$aImage['name']);
  403.         }
  404.         
  405.         switch ($aImageData[2]{
  406.             case 1:
  407.                 $sImage @imagecreatefromgif($aImage['tmp_name']);
  408.                 break;
  409.             case 2:
  410.                 $sImage @imagecreatefromjpeg($aImage['tmp_name']);
  411.                 break;
  412.             case 3:
  413.                 $sImage @imagecreatefrompng($aImage['tmp_name']);
  414.                 break;
  415.         }
  416.         
  417.         // Si ocurrio algun error al abrir la imagen devuelve falso.
  418.         if (!$sImage{
  419.             return false;
  420.         }
  421.         
  422.         foreach ($aSizes as $aSize{
  423.             // Determina si hay sufijo.
  424.             $cSufijo $aSize['suf'"_{$aSize['suf']}'';
  425.             
  426.             if ($aSize['x'== && $aSize['y'== 0// deja la imagen como esta
  427.                 switch ($cType{
  428.                     case 'gif':
  429.                         imagegif($sImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  430.                         break;
  431.                         
  432.                     case 'png':
  433.                         imagesavealpha($sImagetrue);
  434.                         imagepng($sImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  435.                         break;
  436.                         
  437.                     case 'jpg':
  438.                     default:
  439.                         imagejpeg($sImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  440.                         break;
  441.                 }
  442.             }
  443.             else {
  444.                 // Calcula el area maxima de origen.
  445.                 $nIndiceX $aImageData[0$aSize['x'];
  446.                 $nIndiceY $aImageData[1$aSize['y'];
  447.                 $nIndice min($nIndiceX$nIndiceY);
  448.                 
  449.                 // Estas son las dimensiones definitivas de origen.
  450.                 $nAnchoOrigen $nIndice $aSize['x'];
  451.                 $nAltoOrigen $nIndice $aSize['y'];
  452.                 
  453.                 // Encuentra el centro de la imagen de origen.
  454.                 $nDiffX $aImageData[0$nAnchoOrigen;
  455.                 $nDiffY $aImageData[1$nAltoOrigen;
  456.                 $nOrigenX $nDiffX 2;
  457.                 $nOrigenY $nDiffY 2;
  458.                 
  459.                   // Crea la nueva imagen.
  460.                   $sDestImage imagecreatetruecolor($aSize['x']$aSize['y']);
  461.                   
  462.                   imagealphablending($sDestImagefalse);
  463.                   // Efectua el copiado de la imagen de origen a la imagen de destino.
  464.                   imagecopyresampled($sDestImage$sImage0000$aSize['x']$aSize['y']$aImageData[0]$aImageData[1]);
  465.                   imagesavealpha($sDestImagetrue);
  466.                   
  467.                   // Graba la imagen.
  468.                 switch ($cType{
  469.                     case 'gif':
  470.                         imagegif($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.gif");
  471.                         break;
  472.                         
  473.                     case 'png':
  474.                         imagepng($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.png");
  475.                         break;
  476.                         
  477.                     case 'jpg':
  478.                     default:
  479.                         imagejpeg($sDestImage"{$cDestPath}/{$cName}{$cSufijo}.jpg"$aSize['q']);
  480.                         break;
  481.                 }
  482.                 
  483.                 imagedestroy($sDestImage);
  484.             }
  485.         }
  486.         
  487.         imagedestroy($sImage);
  488.     }
  489. }
  490. ?>

Documentation generated on Tue, 22 Nov 2011 13:28:57 -0200 by phpDocumentor 1.4.3