Este documento describe cómo leer, redimensionar y recortar imágenes externas en PHP. Explica cómo determinar el tamaño y formato de una imagen, crear una nueva imagen para el redimensionado, y usar funciones como imagecopyresampled() para copiar y redimensionar la imagen original en la nueva. También cubre cómo establecer encabezados, fondos y márgenes para la imagen resultante.

1. Encuadre y redimensionado de imágenes
Lectura de
imágenes externas
Lectura de imágenes externas
La visualización de imágenes no Uno de los problemas que puede presentarse es la forma de indicar dónde están la imagen a
presenta ningún problema –lo visualizar. En Windows es necesario utilizar la "" mientras que para Linux hay que usar "/".
hacemos habitualmente mediante
etiquetas HTML– cuando se Al utilizar "" en Windows puede plantearse el problema de que vaya precedida por algún
encuentran en el espacio del caracter que pueda tener una significación especial como por ejemplo n. Una solución para
servidor, bien sea propio o ajeno. evitar esos eventuales problemas es escribir "" como separador de niveles de directorio. De
esta forma el primer "" indica que lo que le precede ha de interpretarse sin ninguna
El problema puede surgir cuando significación especial.
tratemos de almacenar esas
imágenes fuera del root del
servidor (una forma de impedir la <?
accesibilidad desde otras webs) y # indicar la ruta de la imagen
eso puede conseguirse mediante $original="C:ApachehtdocscursoPHPimagescaballos.jpg";
las funciones que veremos en este
capítulo. # extraer el tipo de imagen según su la extension del fichero
for($i=strlen($original)-1;$i>0;$i--){
El primer paso será establecer la
if (substr($original,$i,1)=="."){
ruta y el nombre de la imagen. Al
margen tienes comentados $tipo=substr($original,$i+1);
algunos detalles al respecto. break;
}
El paso siguiente será extraer el }
formato de la imagen. Lo hice # las diferentes opciones dependiendo del formato de la imagen
leyendo la parte de la cadena switch($tipo){
comprendida entre el último punto case "jpg":
(.) y el final de la cadena que Header("Content-type:image/jpeg");
contiene el nombre de la imagen.
$nueva=imagecreatefromjpeg($original);
Mediante el switch elijo las imagejpeg($nueva);
instrucciones para cada tipo de break;
imagen que son similares pero con
matices según del formato. case "png":
Header("Content-type:image/png");
La visualización de la imagen $nueva=imagecreatefrompng($original);
contiene tres instrucciones:
imagepng($nueva);
Header, imagecreatefrom e
break;
imageXXX.
En Header hay que incluir un case "gif":
Content - type acorde con el tipo Header("Content-type:image/gif");
de imagen. Puede ser, entre otros $nueva=imagecreatefromgif($original);
valores: image/jpeg, image/ imagegif($nueva);
png ó image/gif según la imagen break;
tenga formato: jpg, png ó gif. }
Con idéntico criterio, la función ImageDestroy();
que crea la imagen ha de ser una ?>
de estas:
$f=imagecreatefromjpeg($i) Ver ejemplo .jpg Ver ejemplo .png Ver ejemplo .gif
ó
$f=imagecreatefrompng($i)
ó ¡Cuidado!
$f=imagecreatefromgif($i)
Observa que en las imágenes en formato png se visualizan con deficiencias en los bordes de las
siendo $i la variable que recoge el áreas transparentes.
nombre y el path de la imagen
original y $f la variable que Con el método que vemos a continuación ese problema se reduce considerablemente.
contiene el resultado de la
ejecución de esta función.
La función image (la que permite
visualizar la nueva imagen) Lectura y redimensionado de imágenes externas
también puede tener una de las
tres variantes que ya conocemos
de ejemplos anteriores. Pueden
ser: <?
imagejpeg($f), imagepng($f) ó
# indicar la ruta de la imagen
imagegif($f), donde $f es la
variable que recoge el resultado de $original="C:ApachehtdocscursoPHPimagescaballos.jpg";
la función anterior. for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
Redimensionado de break;
imágenes externas }
}
Tampoco parece ninguna utilidad. # dimesiones del original
¿Verdad? A fin de cuentas con $tamano=getimagesize($original);
etiquetas HTML podemos asignar $orig_Ancho = $tamano[0];
el ancho y el alto de una imagen. $orig_Alto =$tamano[1];
Pero... ya verás como no es tan # factores de ampliación, distintos para provocar una distorsión
trivial esta opción.
# en la imagen resultante
El proceso es el siguiente: $ampliacion_X=2;
$ampliacion_Y=1.5;
1º.- Determinamos cuales son las # dimesiones de la imagen resultante. Vamos a dejarla a sangre
dimensiones de la imagen externa # (sin márgenes en blanco) y vamos a reproducir el original
que vamos a utilizar. Para ello, # sin reencuadrar así que las esquinas superiores izquierdas de
usaremos de la función: # ambas imágenes estarán en 0,0.
$dim=getimagesize($r)
$resultado_Ancho=$orig_Ancho*$ampliacion_X;
$resultado_Alto= $orig_Alto*$ampliacion_Y;
donde $r es la variable que #creamos una imagen a partir de la original. Debemos elegir

2. contiene el path y nombre del #la funcion adecuada al tipo de imagen original
fichero que contiene la imagen y switch($tipo){
$dim es un array escalar que
case "jpg":
contiene las dimensiones de la
$importada=imagecreatefromjpeg($original);
imagen analizada.
break;
El elemento del array $dim[0] case "png":
contiene el ancho y $dim[1] el $importada=imagecreatefrompng($original);
alto, ambos expresados en pixels. break;
case "gif":
¡Cuidado...! $importada=imagecreatefromgif($original);
Esta función solo funciona cuando
break;
se trata de imágenes externas.
Para determinar las dimensiones }
de imágenes generadas por PHP # insertamos la cabecera de la nueva imagen
tendrás que utilizar otra distinta. Header("Content-type:image/jpeg");
De nada ;-) #creamos una imagen nueva en color verdadero
$im_base=imagecreatetruecolor($resultado_Ancho,$resultado_Alto);
2º.- Creamos una copia de la #aplicamos un color de fondo a la nueva imagen
imagen original por medio de la #para poder visualizar que incluye la transparencia del png o del
función imagecreate adecuada al gif
tipo de imagen que deseamos
if($tipo=="png" OR $tipo=="gif"){
importar. Es exactamente lo que
hemos visto en el párrafo anterior.
$fondo=imagecolorAllocate($im_base,255,255,200);
imagefill($im_base,0,0,$fondo);
3º.- Creamos una nueva imagen }
-podemos trabajar con varias #superponemos la imagen importada sobre la que acabamos de crear
imágenes, en eso no hay imagecopyresampled($im_base,$importada,0,0,0,0,
problema– mediante la función: $resultado_Ancho, $resultado_Alto,
$orig_Ancho,$orig_Alto);
$d=imagecreatetruecolor(x,y)
# visualizamos la imagen resultante
dónde $d es el identificador de la imagejpeg($im_base);
imagen, y x e y son las ImageDestroy();
dimensiones de esta nueva imagen. ?>
Dado que esta imagen va a ser el
soporte –una imagen en color Ver ejemplo .jpg Ver ejemplo .png Ver ejemplo .gif
verdadero (de ahí lo de truecolor)
con fondo negro, algo muy similar
al papel fotográfico que se usa en Observa que –tanto en el ejemplo anterior como en el siguiente– solo hemos utilizado la
los laboratorios– sobre el que se extensión de la imagen original para elegir la función imagecreatefrom.... En el Header hemos
va a impresionar esa especie de
puesto image/jpeg y, como es obvio, hemos utilizado la función asociada a este formato
negativo que es la imagen original
es necesario que sus dimensiones (imagejpeg). Si sustituimos ambos valores por los correspondientes a otro formato (gif, png)
sean las deseadas para la imagen obtendríamos resultados similares.
resultante.
4º.-Ahora toca positivar la nueva
foto. Para hacerlo disponemos de Recortar imágenes externas
la función
imagecopyresampled() que
debe incluir –dentro del
<?
paréntesis– un montón de
parámetros que son (por este
# obtener la imagen
orden): $original="C:ApachehtdocscursoPHPimagesaviones4.jpg";
for($i=strlen($original)-1;$i>0;$i--){
$d que es el identificador de la if (substr($original,$i,1)=="."){
imagen destino, es decir el papel $tipo=substr($original,$i+1);
fotográfico que hemos creado en el break;
paso anterior. }
$f que es el identificador de la
}
imagen original (negativo) # tamaño del original
obtenido en el punto 2º. $tamano=getimagesize($original);
$orig_Ancho = $tamano[0];
Xd e Yd son las coordenadas de un $orig_Alto =$tamano[1];
punto situado en la esquina # estableceremos un margen en blanco alrededor de la imagen de 5 pixels
superior izquierda del papel a # igual por los cuatro lados
partir del que queremos que se $margen=10;
impresione la fotografía. Si # establecemos rocortes para reencuadrar la imagen
queremos una foto a sangre $recorte_izq=50;
pondremos 0,0 y, si quieres dejar
$recorte_sup=80;
márgenes en blanco, habrá que
$recorte_der=40;
poner los anchos de esos
márgenes (izquierdo y superior) $recorte_inf=60;
respectivamente. # calculamos las dimensiones para utilizar como parámetros
# en la funcion imagecopyresampled
Xf e Yf nos servirán para # ancho y alto original recortado
reencuadrar la foto original $Ancho_recortado=$orig_Ancho-$recorte_izq-$recorte_der;
recortando por la izquierda y por $Alto_recortado=$orig_Alto-$recorte_sup-$recorte_inf;
arriba, respectivamente, los # factores de ampliación en este caso iguales
anchos que se indiquen aquí en # sin distorsión de imagen
pixels. $ampliacion_X=1;
Dx e Dy indican el ancho y el alto $ampliacion_Y=1;
# dimensiones del soporte
(por este orden) que va a tener la
mancha de imagen en el positivo. $papel_Ancho=$Ancho_recortado*$ampliacion_X+ 2*$margen;
Ten en cuenta que no puedes $papel_Alto=$Alto_recortado*$ampliacion_Y+2*$margen;
salirte del papel así que esos # dimensiones de la mancha de imagen al positivar
valores sumados con los márgenes # hay que quitar los márgenes
(izquierdo y superior) no podrán $resultado_Ancho=$papel_Ancho -2*$margen;
ser mayores que las dimensiones $resultado_Alto=$papel_Alto -2*$margen;
que has elegido para el papel switch($tipo){
fotográfico en el punto 2º. case "jpg":
$importada=imagecreatefromjpeg($original);
Fx e Fy indican el ancho y el alto
break;
de la porción del original que
case "png":
tratamos de reproducir. Sumados
con Xf e Yf no pueden exceder el
$importada=imagecreatefrompng($original);
break;
tamaño del negativo.
case "gif":

3. Con estos parámetros la función ya $importada=imagecreatefromgif($original);
se encarga de redimensionar la break;
imagen (incluso distorsionarla si }
no hay proporcionalidad entre los
Header("Content-type:image/jpeg");
anchos y altos del original y del
soporte.
$im_base=imagecreatetruecolor($papel_Ancho,$papel_Alto);
$fondo=imagecolorAllocate($im_base,255,255,200);
imagefill($im_base,0,0,$fondo);
imagecopyresampled($im_base,$importada,$margen,$margen,
$recorte_izq,$recorte_sup,
$resultado_Ancho,$resultado_Alto,
$Ancho_recortado,$Alto_recortado);
imagejpeg($im_base);
ImageDestroy();
?>
Ver imágenes original y
resultante
Anterior Indice Siguiente