sábado, 28 de febrero de 2009

Reseña publicada en el Ciberpaís

Aunque con bastante retraso, ha sido publicado el día 6 de Noviembre del 2008, acabo de descubrir que en la página 2 del suplemento ciberpaís del diario "El País"-publicado junto con el diario todos los Jueves- publicaron el enlace a este blog en la sección de sugerencias de los lectores (a falta de otras, la sugerencia fue mía).

Además de mi alegría por la publicación, vaya desde aquí mi agradecimiento por su publicación.

Traductor Gallego Castellano y viceversa



Ayer me preguntaban por un buen traductor galego/castelán o castellano/gallego; la verdad es que a pesar de hacer bastante uso de ellos -tenéis un ejemplo en el icono que traduce esta página al gallego- no había creado ningún artículo sobre el tema, con lo que cada vez que me vuelven a preguntar sobre el tema -como ayer- tengo que recurrir de nuevo a google para buscar las páginas que más me gustan.

Como podéis ver en el título, el traductor que me pidieron ayer es el de castellano a gallego. Supongo que a muchos bilingües como yo, les sucede que suelen emplear prioritariamente una lengua, en la que nos sentimos más cómodos y metemos menos veces la pata. La consecuencia de sólo hablar y leer textos en el otro idioma es que a la hora de escribirlo tenemos bastantes problemas para hacerlo de acuerdo con la normativa vigente. Una solución para ello son los traductores automáticos.

En este caso os detallo los traductores gratuitos y online que empleo habitualmente yo y para qué:
  • Traductor gallego/castellano y castellano/gallego del Seminario de Lingüística Informática de la universidad de Vigo: http://sli.uvigo.es/tradutor/ basado en opentrad apertium. Es el que empleo habitualmente para traducir textos al gallego y portugués. Permite subir textos en formato html o rtf.
  • Vocabulario ortográfico da lingua galega: Real Academia Galega diccionario de la Real Academia de la Lengua Gallega incluye además sinónimos para las palabras buscadas.
  • Traductor castellano/catalán: http://www.opentrad.com/ al igual que el anterior basado en la tecnología opentrad apertium, también tiene la posibilidad de traducir textos al gallego ( de hecho es el que empleo en mi página para la traducción automática al gallego que podéis ver en el icono de la bander gallega). Las diferencias con respecto al anterior se reducen a los diccionarios que emplean cada una, ya que también permite subir textos html y rtf.
  • Traductor multilingüe: http://www.google.es/language_tools?hl=es si necesitáis un traductor desde/hacia casi cualquier lengua (incluídas las nacionales: gallego, euskera, catalán), desde luego esta es una opción muy cómoda ya que incluye una gran cantidad de idiomas empleados por todo el mundo.

jueves, 26 de febrero de 2009

Nubes de Palabras


En ocasiones necesitamos crear nubes de palabras como la de la imagen, ya sea para cartelería, camisetas,....Existen numerosos programas que nos permitirán crearlas de modo más o menos sencillo.

La de la imagen ha sido creada desde la página http://www.wordle.net/ que os permite, a partir de un texto que se debe teclear o copiar en un cuadro de texto, o de la dirección de una página web, crear una nube de textos, permitiéndonos modificar tipos de letra colores, orientaciones dominantes de las palabras,....

Al finalizar podremos generar un pdf de la imagen o salvarlo en la propia página del proyecto, en cuyo caso os dará unos enlaces que podréis pegar en vuestra página para crear un efecto como este:

Wordle: tecnoloxiaxa 2


*Un bico para la que me pasó la página.

Enlaces:
Página del proyecto: http://www.wordle.net/

miércoles, 25 de febrero de 2009

Marvell's SheevaPlug


Hoy en día mucha gente dispone de equipos domésticos que emplean como servidores ya sea para albergar su página web, centralizar la información compartida -NAS-, fotos, backups,... o incluso para mantener en funcionamiento sus programas de P2P.

Bajo esta perspectiva algunas compañías comienzan a apostar por lo que dominan "plug computers" , algo así como equipos conectables. Básicamente ordenadores pequeños y potentes que se conectan a la red empleando redes Ethernet Gigabit. Este tipo de dispositivos eliminan la necesidad de tener un PC siempre encendido (con su consumo energético) en un nuestro hogar para tener acceso a este tipo de servicios. Además proporcionan un considerable ahorro de energía, el dispositivo de la imagen consume 5W frente a los entre, al menos, 25 y 100W de cualquier servidor para hogares.



Siguiendo esta perspectiva os copio el texto que acaban de publicar en engadget: "El SheevaPlug es un ordenador para desarrolladores, y en su interior tiene un procesador Kirkwook de 1,2GHz, 512MB de almacenamiento flash, 512MB de DRAM, Gigabit Ethernet, y USB 2.0. Usa la plataforma PogoPlug, y ofrece soporte para varias distribuciones de Linux con el kernet 2.6. Una vez conectado, utiliza "menos de una décima parte de la energía eléctrica de un PC común". Se vende por 99 dólares, aunque aseguran que el precio bajará a 49 dólares "en un futuro cercano".

Enlaces:
Información del fabricante: http://www.marvell.com/featured/plugcomputing.jsp
engadget: http://www.engadget.com/2009/02/24/marvells-sheevaplug-linux-pc-fits-in-its-power-adapter/

Manual de PHP 56. Superponer, rotar y dar transparencia a imágenes

Colores transparentes

PHP permite crear colores con determinado color de transparencia. Para ello se utiliza la función:

ImageColorAllocateAlpha()
que debe contener dentro del paréntesis los siguientes parámetros (separados por comas):

$im que es el identificador de la imagen que ha sido creada previamente.

R,G,B que son valores numéricos (o variables) que contienen -en una escala de 0 a 255- los la intensidad luminosa de cada uno de los tres colores primarios (rojo, verde y azul).

trans es un valor numérico (comprendido entre 0 y 127) que indica el grado de transparencia de la tinta. El valor 0 indica opacidad total, mientras que 127 establece la transparencia total de ese color.

En el ejemplo que tienes a continuación hemos incluido dos escalas de transparencias superpuestas a intervalos del 10% (desde 0 hasta 100%) transformados a la escala 0-127.

El orden de superposición –similar a las capas de otros programas gráficos– se corresponde con el orden de las instrucciones de creación. Los resultados de las últimas funciones se superponen siempre a los obtenidos como consecuencia de la ejecución de las anteriores.


Superposición de áreas transparentes

<?
/* Creamos una imagen en color verdadero, le aplicamos un color
de fondo (para evitar el negro por defecto) y creamos un nuevo
color que utilizaremos para los bordes de rectangulos posteriores*/
Header("Content-type:image/jpeg");
$im_base=imagecreatetruecolor(610,140);
$fondo=imagecolorAllocate($im_base,255,255,200);
$negro=imagecolorAllocate($im_base,0,0,0);
imagefill($im_base,0,0,$fondo);

# definimos las componentes de un nuevo color
$R=255; $G=00; $B=00;
/* vamos a construir una escala de transparencias
de 0 a 10 que correspondería con valores de transparencia
de 0% al 100%.
Crearemos un bucle que dibuje rectangulos rellenos
con el color definido en la variable trans que irá aplicando
al color básico los diferentes grados de transparencia
y le pondremos un contorno negro para encuadrarlos*/

for($i=0;$i<=10;$i++){ $trans=ImageColorAllocateAlpha($im_base,$R,$G,$B,(int)($i*127/10));
imagefilledrectangle($im_base, 10+55*$i, 20, 50+55*$i, 80, $trans);
imagerectangle($im_base, 10+55*$i, 20, 50+55*$i, 80, $negro);
}

#creamos un nuevo color y repetimos el proceso con nuevos rectangulos
#superpuestos a los anteriores y con las transparencias en sentido opuesto
# es decir, de 100 a 0%
$R=0; $G=0; $B=255;
for($i=0;$i<=10;$i++){ $trans=ImageColorAllocateAlpha($im_base,$R,$G,$B,127-(int)($i*127/10)); imagefilledrectangle($im_base, 10+55*$i, 60, 50+55*$i, 120, $trans); imagerectangle($im_base, 10+55*$i, 60, 50+55*$i, 120, $negro); }

# visualizamos el resultado
imagejpeg($im_base);
ImageDestroy();

?>



Transparencia en imágenes externas

Mediante la utilización de la función imagecopymerge es posible ajustar el grado de transparencia de una imagen externa.

La función imagecopymerge() requiere que se incluyan (dentro del paréntesis y separados por comas y por el orden en el que los incluimos) los siguientes parámetros:

$destino que es el identificador de la imagen sobre la que se va a colocar la transparencia. Como es lógico, deberá haber sido creada antes de incluir la función.

$origen es el identificador de la imagen que pretendemos incluir con un determinado grado de transparencia.

Xd e Yd son las coordenadas de un punto situado en la esquina superior izquierda de la imagen destino a partir del que queremos que se impresione la nueva imagen. Si queremos una imagen a sangre pondremos 0,0 y, si quieres dejar márgenes, habrá que poner los anchos de esos márgenes (izquierdo y superior) respectivamente.

Xf e Yf nos servirán para reencuadrar la foto original recortando por la izquiera y por arriba, respectivamente, los anchos que se indiquen aquí en pixels.

Dx e Dy indican el ancho y el alto (por este orden) que va a tener la mancha de imagen en el positivo. Ten en cuenta que no puedes salirte del papel así que esos valores sumados con los márgenes (izquierdo y superior) no podrán ser mayores que las dimensiones que has elegido para la imagen destino

opacidad es el último de los parámetros de la función al que puede asignársele un valor comprendido entre 0 y 100.

Representa el porcentaje de opacidad de la imagen superpuesta. Con un valor 100 sería totalmente opaca y con 0 la transparencia sería total.

La función imagecopy

Mediante esta función se puede copiar sobre una imagen una parte de otra. Permite extraer porciones de imágenes con su tamaño original sin que permita ampliarlas ni reducirlas. Su sintaxis es la siguiente:

imagecopy($d,$o,$x,$y,$X,$Y,$A,$H) donde:

$d el identificador de la imagen destino, $o el identificador de la imagen original, $x y $y las coordenadas donde se posicionará –en la imagen destino– la esquina superior izquierda de la porción copiada.
$X y $Y son los anchos de los recortes izquierdo y superior de la imagen a copiar y $A y $H el ancho y el alto del área de imagen que pretendemos copiar.

Rotación de imágenes

Mediante la funcion:
imagerotate($im,ang,$fondo) es posible presentar imágenes rotadas.

El parámetro $im es el identificador de la imagen a rotar, ang es el ángulo de rotación (expresado en grados y tomado en sentido trigonométrico) y $fondo es un color de fondo asociado a la imagen a rotar que puede ser definido mediante la función imagecolorallocate u otra función que permita asociar colores a imágenes.

Transparencia en la rotación de imágenes

Hemos intentado explorar la posibilidad de lograr imágenes rotadas con fondo transparente. Y la cosa resulta, cuando menos complicada. Cuando se trata de insertarlas sobre un fondo plano la situación puede emularse fácilmente sin más que asignar como color de fondo de la rotación uno idéntico al del fondo plano sobre el que ha de situarse la imagen.

Otra de las alternativas probadas fué tratar de usar imagecolortransparent en el color de fondo de rotación de la imagen. Es evidente que ese grado de transparencia solo lo lograríamos con un formato png ó jpg. Pero... no funciona.

La alternativa siguiente fué tratar de crear una imagen con fondo transparente e insertar en ella la imagen rotada asignándole transparencia a la capa que contiene la imagen rotada. Ahí nos encontramos con algunas dificultades.

La primera de ellas es que fondo transparente sólo lo permiten las imágenes que son creadas mediante la función imagecreate. Si se crean mediante la función imagecreatetruecolor esa opción no funciona.

Otra diferencia entre ambas funciones tiene también relación con los colores de fondo. Mientras que en el caso de imagecreate se asigna como color de fondo el que se haya definido inmediatamente después de crear la imagen, cuando se trata de imagecreatetruecolor se asignará siempre un fondo negro y para cambiar ese color será necesario recurrir a la función imagefill.

Pero la felicidad completa parece que no existe. Al intentar explorar la primera de estas opciones hemos podido observar que el precio a pagar por la dichosa transparencia es obtener una imagen final de no demasiado buena calidad.

Mejor lo compruebas tu mismo en el ejemplo..

Transparencia en capas rotadas

Cuando trabajamos con una imagen truecolor en la que vamos incluyendo en diferentes capas (mediante copy ó copymerge) otras imágenes –recortadas, rotadas, creadas a partir de otra imagen, etc.– la transparencia de los colores de los fondos de rotación no plantea ningún problema.
Es suficiente usar la función imagecolortransparent, eso sí, aplicándola a la imagen correspondiente antes de insertarla mediante la opción copy en la imagen final.



Transparencia de imágenes externas


<?
# obtener la imagen
$original="c:\\apache\\htdocs\\cursoPHP\\images\\aviones4.jpg";
# buscar el formato de la imagen mediante su extensión
for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}

# tamaño del original extraido del array devuelto por getimagesize
$tamano=getimagesize($original);
$orig_Ancho = $tamano[0];
$orig_Alto =$tamano[1];

# estableceremos un margen en blanco alrededor de la imagen de 10 pixels
# igual por los cuatro lados
$borde=10;
$Ancho=$orig_Ancho+2*$borde;
$Alto=$orig_Alto+2*$borde;

# creamos la imagen segun el formato original
switch($tipo){
case "jpg":
$importada=imagecreatefromjpeg($original);
break;
case "png":
$importada=imagecreatefrompng($original);
break;
case "gif":
$importada=imagecreatefromgif($original);
break;
}

Header("Content-type:image/jpeg");
# creamos una imagen nueva, un color de fondo y la rellenamos con él
$im_base=imagecreatetruecolor($Ancho,$Alto);
$fondo=imagecolorAllocate($im_base,255,255,200);
imagefill($im_base,0,0,$fondo);

# superponemos la imagen importada posicionandola y aplicandole
# una trasmparencia de 50
imagecopymerge( $im_base, $importada, $borde, $borde ,
0, 0, $orig_Ancho, $orig_Alto ,50 );


imagejpeg($im_base);
ImageDestroy();
?>





Si observas los resultados obtenidos en el ejemplo en el que intentamos dar transparencia a una imagen en formato png podrás observar que deja bastante que desear y produce un efecto indeseado por el recorte de las zonas presuntamente transparentes.


Esta situación nos obliga a replantear la situación para prever esta circunstancia y recurrir a un truco que parece solventar ese problema. La modificación del código fuente es la incluimos aquí debajo.


Header("Content-type:image/jpeg");
$im_base=imagecreatetruecolor($Ancho,$Alto);
$fondo=imagecolorAllocate($im_base,255,255,200);
imagefill($im_base,0,0,$fondo);

/* el truco consiste en crear una segunda imagen (im_truco)cuyas
dimensiones coincidan con las de la imagen transparente
que pretendemos colocar. Le asignamos como color el fondo el mismo
de la imagen destino y hacemos transparente ese color en esa imagen.
Después hacemos una copia de la imagen original sobre la imagen
im_truco y sustituimos en la función imagecopymerge la
imagen original por la obtenida mediante esta chapucilla */
$im_truco=imagecreatetruecolor($orig_Ancho, $orig_Alto);
$fondo1=imagecolorAllocate($im_truco,255,0,200);
imagefill($im_truco,0,0,$fondo1);
imagecolortransparent ($im_truco,$fondo1);
imagecopy($im_truco, $importada, 0, 0, 0, 0, $orig_Ancho, $orig_Alto);

imagecopymerge( $im_base , $im_truco, $borde , $borde ,
0 , 0 ,$orig_Ancho, $orig_Alto ,60 );
imagejpeg($im_base);
ImageDestroy();



Ver el nuevo resultado



La función imagecolortransparent ($imagen,$color) permite hacer transparente –en la imagen indicada mediante la variable $imagen– el color señalado en la variable $color.


La variable $color deberá estar definida previamente mediante la función imagecolorAllocate u alguna otra que permita identificar un color determinado.


Rotación de imágenes



<?
# obtener la imagen
$original="c:\\apache\\htdocs\\cursoPHP\\images\\aviones3.jpg";
for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}
switch($tipo){
case "jpg":
$importada=imagecreatefromjpeg($original);
break;
case "png":
$importada=imagecreatefrompng($original);
break;
case "gif":
$importada=imagecreatefromgif($original);
break;
}
Header("Content-type:image/jpeg");
$fondo=imagecolorallocatealpha($importada,255,255,0,40);
$im_base=imagerotate($importada,30,$fondo);

imagejpeg($im_base);
ImageDestroy();
?>



Ver ejemplo

Diferencias entre imagecreate e imagecreatetruecolor


Este es el código fuente de un script que lee una imagen externa y la copia íntegra sobre otra imagen creada mediante PHP. Si visualizas el ejemplo podrás observar las diferencias entre usar la función imagecreate o utilizar imagecreatetruecolor.

<?
$original="c:\\apache\\htdocs\cursoPHP\\images\\aviones3.jpg";

for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}
switch($tipo){
case "jpg":
$importada=imagecreatefromjpeg($original);
break;
case "png":
$importada=imagecreatefrompng($original);
break;
case "gif":
$importada=imagecreatefromgif($original);
break;
}
$dimensiones=getimagesize($original);
$Ancho_original=$dimensiones[0];
$Alto_original=$dimensiones[1];
Header("Content-type:image/png");
$im_base=imagecreate($Ancho_original+20,$Alto_original+20);
$fondo=imagecolorallocate($im_base,255,0,0);
imagecolortransparent($im_base,$fondo);
imagecopy($im_base,$importada,10,10,0,0,$Ancho_original,$Alto_original);
imagepng($im_base);
ImageDestroy();

?>

Ver ejemplo

Ejemplo resumen


Aquí tienes un ejemplo en el que hemos utilizado superposiciones de imágenes, con giros, recortes y diferentes grados de transparencia.








Manual de PHP 55. Encuadrar y redimensionar imágenes.

Lectura de imágenes externas

La visualización de imágenes no presenta ningún problema –lo hacemos habitualmente mediante etiquetas HTML– cuando se encuentran en el espacio del servidor, bien sea propio o ajeno.

El problema puede surgir cuando tratemos de almacenar esas imágenes fuera del root del servidor (una forma de impedir la accesibilidad desde otras webs) y eso puede conseguirse mediante las funciones que veremos en este capítulo.

El primer paso será establecer la ruta y el nombre de la imagen. Uno de los problemas que puede presentarse es la forma de indicar dónde están la imagen a visualizar. En Windows es necesario utilizar la "\" mientras que para Linux hay que usar "/".

Al utilizar "\" en Windows puede plantearse el problema de que vaya precedida por algún caracter que pueda tener una significación especial como por ejemplo \n. Una solución para 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 significación especial.


El paso siguiente será extraer el formato de la imagen. Se puede hacer leyendo la parte de la cadena comprendida entre el último punto (.) y el final de la cadena que contiene el nombre de la imagen.

Mediante el switch elijo las instrucciones para cada tipo de imagen que son similares pero con matices según del formato.

La visualización de la imagen contiene tres instrucciones: Header, imagecreatefrom e imageXXX.

En Header hay que incluir un Content - type acorde con el tipo de imagen. Puede ser, entre otros valores: image/jpeg, image/png ó image/gif según la imagen tenga formato: jpg, png ó gif.

Con idéntico criterio, la función que crea la imagen ha de ser una de estas:

$f=imagecreatefromjpeg($i)
ó
$f=imagecreatefrompng($i)
ó
$f=imagecreatefromgif($i)

siendo $i la variable que recoge el nombre y el path de la imagen original y $f la variable que contiene el resultado de la ejecución de esta función.

La función image (la que permite visualizar la nueva imagen) también puede tener una de las tres variantes que ya conocemos de ejemplos anteriores. Pueden ser:
imagejpeg($f), imagepng($f) ó imagegif($f), donde $f es la variable que recoge el resultado de la función anterior.

<?
# indicar la ruta de la imagen
$original="C:\\Apache\\htdocs\\cursoPHP\\images\\caballos.jpg";

# extraer el tipo de imagen según su la extension del fichero
for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}

# las diferentes opciones dependiendo del formato de la imagen
switch($tipo){
case "jpg":
Header("Content-type:image/jpeg");
$nueva=imagecreatefromjpeg($original);
imagejpeg($nueva);

break;

case "png":
Header("Content-type:image/png");
$nueva=imagecreatefrompng($original);
imagepng($nueva);

break;

case "gif":
Header("Content-type:image/gif");
$nueva=imagecreatefromgif($original);
imagegif($nueva);

break;
}

ImageDestroy();
?>

Ver ejemplo .jpg Ver ejemplo .png Ver ejemplo .gif

Observa que en las imágenes en formato png se visualizan con deficiencias en los bordes de las áreas transparentes.

Con el método que vemos a continuación ese problema se reduce considerablemente.


Redimensionado de imágenes externas

Tampoco parece ninguna utilidad. ¿Verdad? A fin de cuentas con etiquetas HTML podemos asignar el ancho y el alto de una imagen. Pero... ya verás como no es tan trivial esta opción.

El proceso es el siguiente:

1º.- Determinamos cuales son las dimensiones de la imagen externa que vamos a utilizar. Para ello, usaremos de la función:

$dim=getimagesize($r)

donde $r es la variable que contiene el path y nombre del fichero que contiene la imagen y $dim es un array escalar que contiene las dimensiones de la imagen analizada.

El elemento del array $dim[0] contiene el ancho y $dim[1] el alto, ambos expresados en pixels.

¡Cuidado...!
Esta función solo funciona cuando se trata de imágenes externas. Para determinar las dimensiones de imágenes generadas por PHP tendrás que utilizar otra distinta.

2º.- Creamos una copia de la imagen original por medio de la función imagecreate adecuada al tipo de imagen que deseamos importar. Es exactamente lo que hemos visto en el párrafo anterior.

3º.- Creamos una nueva imagen -podemos trabajar con varias imágenes, en eso no hay problema– mediante la función:

$d=imagecreatetruecolor(x,y)

dónde $d es el identificador de la imagen, y x e y son las dimensiones de esta nueva imagen.

Dado que esta imagen va a ser el soporte –una imagen en color verdadero (de ahí lo de truecolor) con fondo negro, algo muy similar al papel fotográfico que se usa en los laboratorios– sobre el que se va a impresionar esa especie de negativo que es la imagen original es necesario que sus dimensiones sean las deseadas para la imagen resultante.

4º.-Ahora toca positivar la nueva foto. Para hacerlo disponemos de la función

imagecopyresampled() que debe incluir –dentro del paréntesis– un montón de parámetros que son (por este orden):

$d que es el identificador de la imagen destino, es decir el papel fotográfico que hemos creado en el paso anterior.

$f que es el identificador de la imagen original (negativo) obtenido en el punto 2º.

Xd e Yd son las coordenadas de un punto situado en la esquina superior izquierda del papel a partir del que queremos que se impresione la fotografía. Si queremos una foto a sangre pondremos 0,0 y, si quieres dejar márgenes en blanco, habrá que poner los anchos de esos márgenes (izquierdo y superior) respectivamente.

Xf e Yf nos servirán para reencuadrar la foto original recortando por la izquierda y por arriba, respectivamente, los anchos que se indiquen aquí en pixels.

Dx e Dy indican el ancho y el alto (por este orden) que va a tener la mancha de imagen en el positivo. Ten en cuenta que no puedes salirte del papel así que esos valores sumados con los márgenes (izquierdo y superior) no podrán ser mayores que las dimensiones que has elegido para el papel fotográfico en el punto .

Fx e Fy indican el ancho y el alto de la porción del original que tratamos de reproducir. Sumados con Xf e Yf no pueden exceder el tamaño del negativo.

Con estos parámetros la función ya se encarga de redimensionar la imagen (incluso distorsionarla si no hay proporcionalidad entre los anchos y altos del original y del soporte.




Lectura y redimensionado de imágenes externas



<?
# indicar la ruta de la imagen
$original="C:\\Apache\\htdocs\\cursoPHP\\images\\caballos.jpg";
for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}

# dimesiones del original
$tamano=getimagesize($original);
$orig_Ancho = $tamano[0];
$orig_Alto =$tamano[1];

# factores de ampliación, distintos para provocar una distorsión
# en la imagen resultante
$ampliacion_X=2;
$ampliacion_Y=1.5;

# dimesiones de la imagen resultante. Vamos a dejarla a sangre
# (sin márgenes en blanco) y vamos a reproducir el original
# sin reencuadrar así que las esquinas superiores izquierdas de
# ambas imágenes estarán en 0,0.
$resultado_Ancho=$orig_Ancho*$ampliacion_X;
$resultado_Alto= $orig_Alto*$ampliacion_Y;

#creamos una imagen a partir de la original. Debemos elegir
#la funcion adecuada al tipo de imagen original
switch($tipo){
case "jpg":
$importada=imagecreatefromjpeg($original);
break;
case "png":
$importada=imagecreatefrompng($original);
break;
case "gif":
$importada=imagecreatefromgif($original);
break;
}

# insertamos la cabecera de la nueva imagen
Header("Content-type:image/jpeg");
#creamos una imagen nueva en color verdadero
$im_base=imagecreatetruecolor($resultado_Ancho,$resultado_Alto);
#aplicamos un color de fondo a la nueva imagen
#para poder visualizar que incluye la transparencia del png o del gif
if($tipo=="png" OR $tipo=="gif"){
$fondo=imagecolorAllocate($im_base,255,255,200);
imagefill($im_base,0,0,$fondo);
}

#superponemos la imagen importada sobre la que acabamos de crear
imagecopyresampled($im_base,$importada,0,0,0,0,
$resultado_Ancho, $resultado_Alto,
$orig_Ancho,$orig_Alto);

# visualizamos la imagen resultante
imagejpeg($im_base);
ImageDestroy();
?>

Ver ejemplo .jpg Ver ejemplo .png Ver ejemplo .gif



Observa que –tanto en el ejemplo anterior como en el siguiente– solo hemos utilizado la extensión de la imagen original para elegir la función imagecreatefrom.... En el Header hemos puesto image/jpeg y, como es obvio, hemos utilizado la función asociada a este formato (imagejpeg). Si sustituimos ambos valores por los correspondientes a otro formato (gif, png) obtendríamos resultados similares.


Recortar imágenes externas



<?
# obtener la imagen
$original="C:\\Apache\\htdocs\\cursoPHP\\images\\aviones4.jpg";
for($i=strlen($original)-1;$i>0;$i--){
if (substr($original,$i,1)=="."){
$tipo=substr($original,$i+1);
break;
}
}

# tamaño del original
$tamano=getimagesize($original);
$orig_Ancho = $tamano[0];
$orig_Alto =$tamano[1];

# estableceremos un margen en blanco alrededor de la imagen de 5 pixels
# igual por los cuatro lados
$margen=10;
# establecemos rocortes para reencuadrar la imagen
$recorte_izq=50;
$recorte_sup=80;
$recorte_der=40;
$recorte_inf=60;

# calculamos las dimensiones para utilizar como parámetros
# en la funcion imagecopyresampled
# ancho y alto original recortado
$Ancho_recortado=$orig_Ancho-$recorte_izq-$recorte_der;
$Alto_recortado=$orig_Alto-$recorte_sup-$recorte_inf;

# factores de ampliación en este caso iguales
# sin distorsión de imagen
$ampliacion_X=1;
$ampliacion_Y=1;

# dimensiones del soporte
$papel_Ancho=$Ancho_recortado*$ampliacion_X+ 2*$margen;
$papel_Alto=$Alto_recortado*$ampliacion_Y+2*$margen;

# dimensiones de la mancha de imagen al positivar
# hay que quitar los márgenes
$resultado_Ancho=$papel_Ancho -2*$margen;
$resultado_Alto=$papel_Alto -2*$margen;
switch($tipo){
case "jpg":
$importada=imagecreatefromjpeg($original);
break;
case "png":
$importada=imagecreatefrompng($original);
break;
case "gif":
$importada=imagecreatefromgif($original);
break;
}

Header("Content-type:image/jpeg");
$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





Manual de PHP 54. Imágenes: Diagramas de sectores

Diagramas de sectores

Esta posibilidad gráfica de tratamiento de información estadística la proporciona la función imagefilledarc() que requiere -por el orden que se indica- los parámetros:

Xc y Yc que son las coordenadas del centro de la elipse cuyo arco (o porción) tratamos de representar.

A y B que son las longitudes (expresadas en pixels) de los ejes horizontal y vertical de la elipse. Si ambos fueran iguales el resultado sería circular.

Pi y Pf son las posiciones (en grados sexagesimales) de los radios (inicial y final) que delimitan el sector que se trata de representar.

Los cero grados coinciden con el semieje horizontal positivo y el sentido del recorrido angular es el de las agujas del reloj.

$color es la variable -ha de ser definida previamente mediante imagecolorallocate- que indica el color que ha de utilizarse en el gráfico.

El último parámetro es un constante PHP que puede tomar uno de los siguientes valores:

IMG_ARC_PIE
IMG_ARC_NOFILL
IMG_ARC_EDGED
IMG_ARC_CHORD

Con la primera de las constantes dibuja el sector de elipse delimitado por los radios indicados relleno con el color especificado.

El segundo (IM_ARC_NOFILL) únicamente dibuja la porción de arco, pero no incluye los radios en el dibujo.

La opcion IMG_ARC_EDGED se comporta de forma idéntica a IMG_ARC_PIE cuando se utiliza de forma aislada aunque tiene una opción muy interesante que veremos un poco más abajo.

Con IMG_ARC_CHORD el resultado es un triángulo -relleno con el color indicado-formado por los dos radios y la cuerda correspondiente al arco que delimitan.

Combinar dos constantes

Cuando utilizamos como último parámetro de la función imagefilledarc() una expresión del tipo:
IMG_ARC_NOFILL|IMG_ARC_EDGED (fíjate en el signo | que separa ambas constantes) lo que obtenemos es la representación gráfica del contorno del sector (incluye los radios que lo delimitan). Mediante esta opción -con dos llamadas a la función- tenemos la posibilidad de representar el sector con un color de relleno (usando IMG_ARC_PIE) y, luego, superponerle un contorno de distinto color. Puedes verlo en los ejemplos.

Efecto tridimensional

Tal como puedes ver en los ejemplos, resulta fácil lograr un efecto tridimensional en el dibujo de los sectores. Basta con crear un bucle que dibuje arcos sucesivos (separados verticalmente por un pixel) y posteriormente superponer un sector relleno con un color distinto.

Diagramas de sectores

<?
$im = imagecreate (400, 400);
$fondo = imagecolorallocate($im, 226, 226, 226);
$col1=imagecolorallocate($im,255,255,0);
$col2=imagecolorallocate($im,255,0,0);
imagefilledarc($im, 200, 200, 350, 300, 20, 240, $col1, IMG_ARC_PIE);
imagefilledarc($im, 200, 200, 350, 300, 10, 150, $col2, IMG_ARC_NOFILL)
;
header('Content-type: image/png');
imagepng($im);
imagedestroy($im);
?>


<?
$im = imagecreate (400, 400);
$fondo = imagecolorallocate($im, 226, 226, 226);
$col1=imagecolorallocate($im,255,255,0);
$col2=imagecolorallocate($im,255,0,0);
imagefilledarc($im, 200, 200, 350, 300, 20, 240, $col1, IMG_ARC_EDGED);
imagefilledarc($im, 200, 200, 350, 300, 10, 150, $col2, IMG_ARC_NOFILL)
;
header('Content-type: image/png');
imagepng($im);
imagedestroy($im);
?>


<?
$im = imagecreate (400, 400);
$fondo = imagecolorallocate($im, 226, 226, 226);
$color1=imagecolorallocate($im,255,0,0);
imagefilledarc ($im, 200, 200, 350, 300, 20, 240, $color1,
IMG_ARC_NOFILL|IMG_ARC_EDGED)
;
header('Content-type: image/gif');
imagegif($im);
imagedestroy($im);
?>



<?
$im = imagecreate (400, 400);
$fondo = imagecolorallocate($im, 226, 226, 226);
$color1=imagecolorallocate($im,255,0,0);
imagefilledarc ($im, 200, 200, 350, 300, 50, 200, $color1, IMG_ARC_CHORD);
header('Content-type: image/gif');
imagegif($im);
imagedestroy($im);
?>



<?
$im = imagecreate (400, 400);
$fondo = imagecolorallocate($im, 226, 226, 226);
$color1=imagecolorallocate($im,200,0,0);
$color2=imagecolorallocate($im,255,0,0);
$color3=imagecolorallocate($im,255,255,255);
for($i=200;$i<225;$i++){
imagefilledarc($im, 200, $i, 370, 270, 50, 330, $color1,
IMG_ARC_NOFILL|IMG_ARC_EDGED);

}

imagefilledarc($im, 200, 200, 370, 270, 50, 330, $color2, IMG_ARC_EDGED);
imagefilledarc($im, 200,200, 370, 270, 50, 330, $color3,
IMG_ARC_NOFILL|IMG_ARC_EDGED);


header('Content-type: image/gif');
imagegif($im);
imagedestroy($im);
?>



domingo, 22 de febrero de 2009

Software gratuito: opendisc

Cuando muchos concluyan la lectura de este artículo se llevarán las manos a la cabeza aduciendo, con toda razón, que open hace referencia a abierto o libre y que no tiene "nada que ver" con gratuito. Sin dejar de ser cierto, no lo es menos que la traducción que le interesa al noventa por ciento de los usuarios de programas no tiene, objetivamente, mucho que ver con la posibilidad de revisar o modificar el código del mismo, si no que liga su empleo al tipo de licencia y al costo de uso del mismo.

Bajo esta perspectiva, cuando hace unos años alguien le pedía a un "informático" - término súmamente devaluado que suele hacer referencia a alguien que es capaz de bajarse un programa y su respectivo crack de Internet para posteriormente instalarlo en cualquier equipo- que le instalase software en su ordenador, lo que "indirectamente" le estaba diciendo era algo como "traeme un Windows pirata y todos los cd´s que tengas con software en su versión "emule".

En la actualidad, cada vez somos más los que abogamos por la utilización de software libre -que además suele ser gratuito- por varias razones: la primera y evidente es la gratuidad del mismo, en segundo lugar suelen tener las mismas funciones que los productos comerciales, al menos aquellas que usamos en un 99,9999% de los casos, en tercer lugar porque la usabilidad (facilidad de manejo/aprendizaje) es casi idéntico al resto de programas y por último porque nos negamos a formar a futuros profesionales en un único software propietario (que además hemos tenido que pagar a precio de oro para publicitarlo a nuestros alumnos) que posteriormente ser verán abocados a comprar en su empresa. Por si esto fuera poco nos podremos olvidar de las llamadas de nuestro "amigo" de turno, avisándonos de que "el ordenador" ha actualizado el software que les instalamos y que ahora le saca una advertencia de que no tiene licencia y, por tanto, no lo puede ejecutar.

El siguiente paso, evidentemente consistirá en sustituir el sistema operativo dominante en nuestros hogares (léase la última versión del sistema operativo de Microsoft) por otro basado en Linux con los mismos elementos.

Para facilitar el uso de software libre y el "salto" de sistema operativo existen numerosos proyectos el que os presento hoy me parece muy interesante porque, precisamente, sigue el esquema comentado anteriormente. Se trata de una recopilación de software libre capaz de sustituir al comercial y agrupado igualmente por categorías para su instalación totalmente libre en nuestro sistema Windows. Como añadido han buscado software que también está disponible, de modo mayoritario, en entornos Linux, con lo cual la portabilidad de nuestros equipos de Windows a Linux, una vez conozcamos los programas a emplear, se verá tremendamente facilitada en lo que respecta a la pregunta básica a la hora de cambiarnos: ¿qué pasa con este programa X que empleaba para hacer Y, existe alguna versión para Linux?. La respuesta será no sólo existe sino que es exactamente igual.

El proyecto en cuestión que os presentof se llama OpenDisc y está disponible en dos versiones una "normal" y otra destinada a educación. A continuación os presento una relación del software disponible y las categorías en las que se encuentra agrupado (tan sólo he resumido en castellano las características de los empleados en Internet). Básicamente se trata de una imagen iso que os podréis descargar mediante Internet para después grabar en un cd, de modo que tengáis disponibles todos los programas que necesitéis una vez ya hayáis instalado el sistema operativo.

Finalmente sólo decir que bajo mi punto de vista , en la versión de educación le falta algún software libre para administración y control de aulas tipo italc.


Internet

  • Azureus
  • Filezilla
  • Firefox
  • HTTrack: para descargarse una página a tu disco duro y navegar por él, sin conexión.
  • Pidgin: cliente de mensajería, chat,...
  • RSSOwl: cliente rss
  • SeaMonkey: cliente irc, news, editor HTML....
  • Thunderbird: cliente email
  • TightVNC: cliente ligero para manejar escritorios remotos
  • WinSCP: cliente para conexión a servidores SSH, SFTP y SCP remotos.

Programas Incluidos en la versión Educación:
Office and Design
  • OpenOffice.org - Fully compatible office software for your school work
  • Dia - Make technical diagrams and flowcharts
  • Scribus - Create professional looking posters and magazines
  • GanttProject - Plan your school projects with this project management software
  • FreeMind - Collect your ideas with this mind mapping Software
  • PDF Creator - Make PDF documents from any program
  • Sumatra PDF - Read PDF files quickly and easily
Internet
  • Firefox - A safe, secure and fast web browser
  • Thunderbird - Manage your emails better than ever - Reclaim your inbox!
  • Pidgin - Talk to your friends whatever instant message client they use
  • Kompozer - Create web pages easily, without having to code
  • RSSOwl - Keep up with your favourite internet news feeds on your desktop
Art and Graphics
  • GIMP - Edit digital photos and create graphics
  • GIMP animation - Create animations
  • Inkscape - Make professional looking vector graphics
  • Blender - 3D graphic modeling, animation, rendering and playback
  • Tuxpaint - Drawing program for children ages 3 to 12
Mulitmedia Science and Mathematics Games Utilities Enlaces:
Página del proyecto: http://www.theopendisc.com

sábado, 21 de febrero de 2009

Jugar empleando Linux: Playonlinux


Una de las principales carencias que presentan los sistemas basados en linux frente a los sistemas operativos más empleados de Microsoft es la práctica inexistencia de juegos nativos para esta plataforma.

Es por ello, que la mayoría de usuarios que quieren emplear sus equipos para algo más que para trabajar -léase jugar- deben instalar wine (ya sabéis ese conjunto de librerías que sustituyen, NO EMULAN las empleadas por microsoft).

El principal inconveniente de esta solución es la complejidad de instalación de la misma para numerosos programas. Para salvar este inconveniente existe un programa "playonlinux" que basado en las librerías de wine nos permite ejecutar numerosos juegos de Windows, pero que también nos permite continuar empleando algunos de nuestros viejos programas de nuestro windows; todo ello desde un interfaz muy sencillo que facilita sobremanera la instalación de dichos programas. Además para instalar scripts no oficiales, tan sólo debemos ir a Herramientas-->ejecutar scripts no oficiales

Para instalar playonlinux en Ubuntu:

Hardy


sudo wget http://deb.mulx.net/playonlinux_hardy.list -O /etc/apt/sources.list.d/playonlinux.list
wget -q http://deb.mulx.net/pol.gpg -O- | sudo apt-key add -
sudo apt-get update
sudo apt-get install playonlinux



Gutsy

sudo wget http://deb.mulx.net/playonlinux_gutsy.list -O /etc/apt/sources.list.d/playonlinux.list
wget -q http://deb.mulx.net/pol.gpg -O- | sudo apt-key add -
sudo apt-get update
sudo apt-get install playonlinux





Página de playonlinux en castellano: http://www.playonlinux.com/es
Página de descarga: http://www.playonlinux.com/es/download.html

Manual de PHP 53. Imágenes: Manejando Fuentes

Utilizando fuentes TrueType

Si has leído los comentarios de la página anterior recordarás que para usar estas funciones es preciso que estén instaladas las librerías FreeType y que, además, conozcamos el path de directorio que contiene las fuentes TrueType.

Instalación de fuentes

Hemos creado un subdirectorio llamado fuentes y lo hemos incluido en directorio donde están alojadas estas páginas.

En ese subdirectorio hemos incluido dos fuentes TrueType manteniendo en una de ellas el nombre original (arial.ttf) y renombrado la otra como fuente2.ttf.

Como podrás comprobar en los ejemplos, no hay problema alguno por el hecho de renombrar las fuentes.

Escribiendo con fuentes TrueType

La función PHP que nos permite insertar este tipo de textos en imágenes dinámicas es la siguiente:

Imagettftext($nom, tam, ang, x, y, $col, $fuente, $txt)

donde:

$nom es, como siempre, el nombre de la imagen.

tam es un número entero que indica el el tamaño de la fuente.

ang es el giro expresado en grados sexagesimales que pretendemos que tenga la cadena de texto. Si ang=0 el texto aparecerá escrito en horizontal.

x e y son las coordenadas del punto de inicio de la inserción del texto. Ese punto coincide con la esquina inferior izquierda del rectángulo imaginario que contiene el texto.

$col es el color a utilizar en el texto.

$fuente es una cadena de texto que contiene el path y el nombre de la fuente. Observa los ejemplos.

$txt es el nombre de la variable que contiene el texto a insertar.

Colocando textos

PHP dispone de una función que permite determinar las dimensiones de una caja de texto (el rectángulo imaginario que rodea el texto).

$rec= ImageTTFBBox (tam, ang, $fuente, $txt)

donde: tam es el tamaño de la fuente a utilizar.

ang es el ángulo de rotación del texto que tendría valor cero en el caso de orientación horizontal.

$fuente es el path y nombre de la fuente a a utilizar.

$txt es el nombre de la variable que contiene el texto a incluir.

La variable $rec recoge un array escalar cuyos valores son las coordenadas de las cuatro esquinas de la caja de texto.

Los índices correspondientes a cada uno de los elementos de ese array son los siguientes:
  • Inferior izquierdo
    Sus coordenadas son:
    $rec[0],$rec[1]

  • Inferior derecho
    Sus coordenadas son:
    $rec[2],$rec[3]

  • Superior derecho
    Sus coordenadas son:
    $rec[4],$rec[5]

  • Superior izquierdo
    Sus coordenadas son:
    $rec[6],$rec[7]
Respecto a estas coordenadas, habremos de tener en cuenta lo siguiente:
  • Las correspondientes al vértice inferior izquierdo son siempre (0,0).

  • Los puntos situados por encima del (0,0) tienen ordenada negativa.

  • Las abscisas de los puntos situados a la izquierda del (0,0) son negativas.

Dibujando segmentos


Aunque presentaremos únicamente el código fuente de una de las imágenes, para hacer la comprobación de las funciones y las diferencias de visualización insertaremos dos ejemplos.
Uno en formato PGN y otro en JPG.


Recuerda que las únicas diferencias entre ambos radican en utilizar: Header("Content-type: image/png") o Header("Content-type: image/jpeg") y en las funciones Imagepng ó Imagejpeg.


Texto TrueType horizontal

<?
Header("Content-type: image/png");
$im = imagecreate(400,300);
$fondo=imagecolorallocate ($im, 255, 255, 210);
$rojo=imagecolorallocate ($im, 255, 0, 0);

$texto="PHP";

Imagettftext($im, 40, 0, 100, 270, $rojo,
"./fuentes/fuente2.ttf", $texto)
;

Imagepng($im);
imagedestroy($im);

?>



Ver img25.php
Formato PNG
Ver img26.php
Formato JPG



Texto TrueType girado

<?
Header("Content-type: image/png");
$im = imagecreate(400,300);
$fondo=imagecolorallocate ($im, 255, 255, 210);
$rojo=imagecolorallocate ($im, 255, 0, 0);

$texto="Me gusta PHP";

Imagettftext($im, 40, 30, 100, 270, $rojo,
"./fuentes/fuente2.ttf", $texto)
;

Imagepng($im);
imagedestroy($im);

?>



Ver img27.php
Formato PNG
Ver img28.php
Formato JPG



Centrando textos


Aquí tienes un ejemplo donde utilizando ImageTTFBox e ImageTTFText se puede centrar un texto -tanto si es horizontal como si está girado- con relación a un punto.


En este ejemplo, el punto de referencia para el centrado es (200,150) que es el centro de la imagen.


Las coordenadas de ImageTTFText, como puedes ver, están calculadas usando las coordenadas de ese punto de referencia y los valores del array generado por ImageTTFBox

.
Si la variable que contiene el array generado por ImageTTFBox se llama $pepa, las coordenadas del centro del rectángulo imaginario son $pepa[4]/2 y $pepa[5]/2


Partiendo de esos valores, si queremos centrar el texto sobre un punto de la imagen cuyas coordenadas son (X,Y) nos basta con escribir como parámetros de la función ImageTTFText los siguientes:

  • Abscisa= X - $pepa[4]/2


  • Abscisa= Y - $pepa[5]/2



Este procedimiento es válido tanto para textos horizontales como para textos girados.


Aquí lo tienes:


&lt?
Header("Content-type: image/png");

$im = imagecreate(400,300);
$fondo=imagecolorallocate ($im, 255, 255, 210);
$gris=imagecolorallocate ($im, 160, 160,160);
$rojo=imagecolorallocate ($im, 255, 0, 0);

$texto="El mundo del PHP";
$texto1="lleno de posibilidades";


$marco= ImageTTFBBox (40, 0, "./fuentes/arial.ttf", $texto);

Imagettftext($im, 40, 0, 200-$marco[4]/2, 150-$marco[5]/2, $gris,
"./fuentes/arial.ttf", $texto);


$marco1= ImageTTFBBox (30, 30, "./fuentes/fuente2.ttf", $texto1);

Imagettftext($im, 30, 30, 200-$marco1[4]/2, 150-$marco1[5]/2, $rojo,
"./fuentes/fuente2.ttf", $texto1);


Imagepng($im);
imagedestroy($im);

?>

Ver img29.php
Formato PNG
Ver img30.php
Formato JPG



Un ejemplo resumen


Aquí tienes un ejemplo bastante completo de generación de imágenes dinámicas.


Ver ejemplo105.php Ver código fuente

En servidores UNIX y LINUX la forma en la que indicamos el path del directorio que contiene las fuentes varía sustancialmente respecto a la que hemos utilizado en estos ejemplos.

En aquellos, además de invertir los separadores, se requiere indicar siempre rutas absolutas, con lo cual habría que hacer las modificaciones oportunas si se tratara de publicar en un hosting que utilice alguno de estos sistemas operativos.




Manual de PHP 52. Imágenes con líneas y textos.

Trazando segmentos

La función PHP que permite dibujar segmentos rectilíneos es la siguiente:

imageline($nom,x0, y0,x1,y1,$col)

donde: $nom es el nombre de la variable definida mediante imagecreate, x0 e y0 son las coordenadas de uno de los extremos; x1 e y1 son las coordenadas del otro extremo y $col es la variable de color con el que será dibujada la línea.

Colores de fondo

Tal como puedes observar en los primeros ejemplos de esta página, PHP utiliza como fondo de la imagen el primer color definido por la función:

ImageColorAllocate.

Esta opción de PHP nos obliga a definir dos colores distintos para conseguir la visibilidad de las líneas.

Crear transparencias

Si deseamos que un color determinado se comporte como si fuera transparente debemos utilizar la función:

imagecolortransparent ($nom ,$col).

donde: $nom es el nombre de la variable definida mediante imagecreate, y $color es el color que pretendemos hacer transparente.

No olvides estos dos pequeños detalles:

• Si pretendes lograr un fondo transparente debes hacer transparente el primero de los colores definidos.
• Esta función sólo tiene sentido en imágenes PNG que son las únicas que permiten zonas transparentes. Recuerda que JPG no las permite.

Insertando textos

Para insertar textos dentro de una imagen hemos de recurrir a una de estas funciones:

imagechar ($im, n, x, y, $txt, $col)

Requiere que la variable $txt contenga una cadena definida con anterioridad. Mediante esta función se inserta el primer carácter de la cadena con orientación horizontal.

Los parámetros de la función son los siguientes:

$im el nombre de la variable con la que fue definida por imagecreate

n es un número comprendido entre UNO y CINCO que asigna el tamaño de la letra de menor a mayor.

x e y son las coordenadas del punto donde se colocará la esquina superior izquierda del carácter a representar.

$txt es la cadena de texto de la que se extraerá el primer carácter, el único que se verá en la imagen.

$col es el color del carácter a representar.

imagecharup ($im, n, x, y, $txt, $col)

Su funcionamiento es similar al de la función anterior, con la única diferencia de que inserta el carácter con orientación vertical.

Las coordenadas de inserción también se corresponden con las de la esquina superior izquierda del carácter pero, recuerda que ahora estará girado y que, por lo tanto, ese punto coincidirá con parte inferior izquierda de la imagen del carácter.

imagestring ($im, n, x, y, $txt, $col)

Esta función se comporta de forma similar a imagechar. La única diferencia entre ambas es que mientras imagechar inserta sólo el primer carácter, en el caso de imagestring se inserta la cadena completa.

Los parámetros de ambas funciones son los mismos.

Si la cadena desborda los límites de la imagen sólo se visualizará la parte de la misma contenida dentro de éstos.

imagestringup ($im, n, x, y, $txt, $col)

Inserta una cadena completa con orientación vertical y sus parámetros son idénticos a los comentados cuando nos hemos referido a imagecharup.

Tipos de letra

Todas las funciones anteriores utilizan siempre la fuente predefinida por PHP y sólo permiten los cinco tamaños que hemos podido ver en los ejemplos.

Afortunadamente –lo veremos en la página siguiente– PHP también permite usar fuentes TrueType y aplicarlas en la creación de imágenes.


Dibujando segmentos


Aunque presentaremos únicamente el código fuente de una de las imágenes, para hacer la comprobación de las funciones y las diferencias de visualización insertaremos dos ejemplos,
uno en formato PGN y otro en JPG.


Recuerda que las únicas diferencias entre ambos radican en utilizar: Header("Content-type: image/png") o Header("Content-type: image/jpeg") y en las funciones Imagepng ó Imagejpeg.

<?
Header("Content-type: image/png");
$im = imagecreate(200,200);
$fondo=ImageColorAllocate ($im,0,0,255);
$linea=ImageColorAllocate ($im,255,255,255);

imageline($im,0,0,200,200,$linea);

Imagepng($im);
Imagedestroy($im);
?>

Ver img_a1.php
Formato PNG
Ver img_a2.php
Formato JPG


Fondos transparentes


<?
Header("Content-type: image/png");
$im = imagecreate(200,200);
$fondo=ImageColorAllocate ($im,0,0,255);
$linea=ImageColorAllocate ($im,255,0,0);
imagecolortransparent ($im ,$fondo);
imageline($im,0,0,200,200,$linea);
Imagepng($im);
Imagedestroy($im);
?>

Ver img_a3.php
Formato PNG
Ver img_a4.php
Formato JPG



Aquí tienes una página -con un color de fondo- en la que puedes visualizar las diferencias entre los dos formatos.




Insertando caracteres


<?
Header("Content-type: image/png");
$im = imagecreate(150,150);
$t1="Tamaño 1";
$t2="Tamaño 2";
$t3="Tamaño 3";
$t4="Tamaño 4";
$t5="Tamaño 5";
$fondo=imagecolorallocate ($im, 0, 0, 200);
$amarillo=imagecolorallocate ($im, 255, 255,0);
imagechar ($im, 1, 0, 0, $t1, $amarillo);
imagechar ($im, 2, 20, 20, $t2, $amarillo);
imagechar ($im, 3, 40, 40, $t2, $amarillo);
imagechar ($im, 4, 60, 60, $t2, $amarillo);
imagechar ($im, 5, 80, 80, $t2, $amarillo);
Imagepng($im);
imagedestroy($im);
?>

Ver img17.php
Formato PNG
Ver img18.php
Formato JPG

<?
Header("Content-type: image/png");
$im = imagecreate(150,150);
$t1="Tamaño 1";
$t2="Tamaño 2";
$t3="Tamaño 3";
$t4="Tamaño 4";
$t5="Tamaño 5";
$fondo=imagecolorallocate ($im, 0, 0, 200);
$amarillo=imagecolorallocate ($im, 255, 255,0);
imagecharup ($im, 1, 10, 10, $t1, $amarillo);
imagecharup ($im, 2, 20, 20, $t2, $amarillo);
imagecharup ($im, 3, 40, 40, $t2, $amarillo);
imagecharup ($im, 4, 60, 60, $t2, $amarillo);
imagecharup ($im, 5, 80, 80, $t2, $amarillo);
Imagepng($im);
imagedestroy($im);

?>

Ver img19.php
Formato PNG
Ver img20.php
Formato JPG

<?
Header("Content-type: image/png");
$im = imagecreate(150,150);
$t1="Tamaño 1";
$t2="Tamaño 2";
$t3="Tamaño 3";
$t4="Tamaño 4";
$t5="Tamaño 5";
$fondo=imagecolorallocate ($im, 0, 0, 200);
$amarillo=imagecolorallocate ($im, 255, 255,0);
imagestring ($im, 1, 10, 20, $t1, $amarillo);
imagestring ($im, 2, 10, 40, $t2, $amarillo);
imagestring ($im, 3, 10, 60, $t3, $amarillo);
imagestring ($im, 4, 10, 80, $t4, $amarillo);
imagestring ($im, 5, 10, 100, $t5, $amarillo);
Imagepng($im);
imagedestroy($im);
?>



img21.php
Ver img21.php
Formato PNG
Ver img22.php
Formato JPG

<?
Header("Content-type: image/png");
$im = imagecreate(150,150);
$t1="Tamaño 1";
$t2="Tamaño 2";
$t3="Tamaño 3";
$t4="Tamaño 4";
$t5="Tamaño 5";
$fondo=imagecolorallocate ($im, 0, 0, 200);
$amarillo=imagecolorallocate ($im, 255, 255,0);
imagestringup ($im, 1, 10, 100, $t1, $amarillo);
imagestringup ($im, 2, 20, 100, $t2, $amarillo);
imagestringup ($im, 3, 40, 100, $t3, $amarillo);
imagestringup ($im, 4, 60, 100, $t4, $amarillo);
imagestringup ($im, 5, 80, 100, $t5, $amarillo);
Imagepng($im);
imagedestroy($im);
?>

Ver img23.php
Formato PNG
Ver img24.php
Formato JPG