coge la información y corre

Guia básica para editar imágenes en PHP con GD

14 de octubre del 2008 Escrito por Alex Barros

Crear y editar imágenes con PHP puede ser muy fácil si tienes instalada la biblioteca GD en tu servidor.

Aunque las opciones que ofrece GD son muy básicas, son suficientes para desarrollar scripts con capacidades muy superiores. Ahora voy a presentaros estas funciones básicas con ejemplos, para que puedas crear aplicaciones más complejas.

Crear la imagen de cero o desde un archivo

Para tratar imágenes en GD trabajamos con recursos o variables tipo resource de imágenes. Esto es una varible que representa a la imagen.

Para crear un nuevo recurso de imagen podemos usar la función imagecreate() aúnque es más recomendable usar la función imagecreatetruecolor()

  1. $im = imagecreatetruecolor(300, 200); //a partir de aqui trabajo con una imagen de 300×200
  2. $im2 = imagecreatetruecolor(100, 100); //he creado otra imagen distinta con dimensiones 100×100

Si queremos partir de una imagen ya existente, para convertirla en recurso tendremos que usar la función adecuada dependiendo del formato de la imagen. Los principales formatos son JPEG, PNG y GIF; con las funciones imagecreatefromjpeg(), imagecreatefrompng() y imagecreatefromgif() respectivamente.

  1. $miJpeg =imagecreatefromjpeg(‘miimagen.jpg’); //he creado un recurso a partir del archivo miimagen.jpg

Si quieres ahorrarte el pensar a la hora de crear un recurso a partir de imagen, o desconoces el formato de entrada de la imagen (y quieres que lo haga automáticamente) puedes usar esta función para crear cualquier tipo de imagen.

  1. function newimage($src) {
  2.     $im = false;
  3.     switch(true) {
  4.         case eregi(‘http://’, $src):
  5.             $im = imagecreatefromstring( getUrlData($src) );
  6.             imagealphablending($im, true);
  7.             imagesavealpha($im, true);
  8.         break;
  9.         case eregi(\.jpg’, $src):
  10.             $im = imagecreatefromjpeg($src);    
  11.         break;
  12.         case eregi(\.gif’, $src):
  13.             $imp = imagecreatefromgif($src);
  14.  
  15.             $x = imagesx($imp);
  16.             $y = imagesy($imp);
  17.             $im = imagecreatetruecolor($x, $y);
  18.             imagefilledrectangle( $im, 0, 0, $x, $y, imagecolorallocate($im, 255, 255, 255) );
  19.             imagecopy($im, $imp, 0, 0, 0, 0, $x, $y);
  20.         break;
  21.         case eregi(\.png’, $src):
  22.             $im = imagecreatefrompng($src);    
  23.  
  24.             imagealphablending($im, true);
  25.             imagesavealpha($im, true);
  26.         break;
  27.     }
  28.     return $im;
  29. }
  30. function getUrlData($url){
  31.     $ch = curl_init($url);
  32.     curl_setopt($ch, CURLOPT_FAILONERROR, 1);
  33.     curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
  34.     curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  35.     $get = curl_exec($ch);
  36.     curl_close($ch);
  37.     return $get;
  38. }

[descargar código]

Esta función puede crear una imagen a partir de JPEG, PNG, GIF o URL (requiere CURL)

Si queremos saber las dimensiones de un recurso de imagen, usaremos las funciones imagesx($im) e imagesy($im) que devuelven el ancho y alto del recurso, en píxeles, respectivamente.

Copiar, recortar y redimensionar

La modificación más básica que podemos hacer a una imagen es recortarla y redimensionarla.

En ambos casos la forma de trabajar es, en primer lugar crear un nuevo recurso con las dimensiones apropiadas, y en segundo lugar copiar de la imagen origen a la imagen destino aplicando el cambio deseado.

Recortar una imagen

Para recortar una imagen de, por ejemplo, 500 x 400 en 50px por la derecha y por abajo, haremos lo siguiente:

  1. Creamos un nuevo recurso de 500 – 50 = 450 por 400 – 50 = 350px
  2. Usamos la función imagecopy para copiar de la imagen origen, en nuestra nueva imagen

    bool imagecopy ( resource $im_destino , resource $im_origen , int $pos_x_destino , int $pos_y_destino , int $pos_x_origen , int $pos_y_origen , int $ancho_origen , int $alto_origen )

  3. Los dos primeros parámetros son los recursos destino y origen
  4. Los dos siguientes son la posición en eje x e y de la imagen destino, donde queremos comenzar a copiar (en nuestro caso 0,0; porque el eje está arriba y a la izquierda)
  5. Los dos siguientes son el ancho y el alto de la imagen que queremos recortar del aimagen original. En nuestro caso 450 y 350.
  1. $im_origen = imagecreatefromjpeg(‘mi_imagen.jpg’); //sabemos que mide 500 x 400
  2. $im_destino = imagecreatetruecolor(450, 350); //im_destino contendrá la nueva imagen recortada
  3.  
  4. imagecopy($im_destino, $im_origen, 0, 0, 0, 0, 450, 350);
  5. // Ahora im_destino es im_origen recortada por abajo y por la derecha 50px

[descargar código] Ejemplo: [original] [recortada dinámicamente]

Redimensionar una imagen

En este ejemplo vamos a redimensionar a la mitad la imagen origen, sea cual sea su tamaño.

Crearemos primero un nuevo recurso con las dimexiones x/2 e y/2, y usaremos la función imagecopyresampled() (también podríamos usar imagecopyresized(), pero la que vamos a usar suaviza los píxeles interpolándolos – tiene mejor calidad)

  1. $im_origen = imagecreatefrompng(‘foo.png’);
  2. $ancho = imagesx($im_origen);
  3. $alto = imagesy($im_origen);
  4.  
  5. $nuevo_ancho = round($ancho / 2);
  6. $nuevo_alto = round($alto / 2);
  7.  
  8. $im_destino = imagecreatetruecolor($nuevo_ancho, $nuevo_alto);
  9. imagecopyresampled($im_destino, $im_origen, 0, 0, 0, 0, $nuevo_ancho, $nuevo_alto, $ancho, $alto);
  10. // ahora im_destino es la mitad de grande que im_origen

Dibujar figuras y texto

Las figuras que GD nos deja pintar son muy básicas, parecidas a las que ofrece el programa Paint

En este punto lo más importante es crear colores para una imagen. Los colores se deben crear y asociar a una imagen mediante la función imagecolorallocate(). El color lo indicamos mediante parámetros RGB (Red Green Blue) que podemos extraer fácilmente de cualquier paleta, como la del Photoshop o el Gimp

Dibujar un rectángulo

Quizás la figura más simple. Podemos dibujar sólo el borde del rectángulo con la función imagerectangle() o el rectangulo relleno de color, con la función imagefilledrectangle()

bool imagerectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

bool imagefilledrectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

  1. $imagen = imagecreatefromjpeg(‘mi_imagen.jpg’);
  2. $negro = imagecolorallocate($imagen, 0, 0, 0);
  3. //voy a dibujar un rectangulo negro entre las coordenadas (5,5) y (25,15), recuerda que el eje está arriba a la izquierda
  4. imagefilledrectangle($imagen, 5, 5, 25, 15, $negro);

Otras figuras

Existen muchas figuras que puedes dibujar con GD, desde una línea hasta un polígono, pasando por la elipse o el píxel. Sólo busca la que más te conviene en la documentación, o combina varias para obtener la figura deseada.

Escribir texto

Es realmente sencillo. Si no te quieres complicar la vida, puedes usar la función imagestring() que te da la opción de elegir entre 5 fuentes internas indicando sólo el número de referencia…

  1. $im = imagecreate(100, 30); //creo una nueva imagen de 100×30
  2. $fondo = imagecolorallocate($im, 255, 255, 255); //blanco. El primer color creado, se utiliza como fondo automaticamente para esa imagen
  3. $color_texto = imagecolorallocate($im, 0, 0, 255); //azul
  4. // escribo la cadena arriba a la izquierda con la fuente #5
  5. imagestring($im, 5, 0, 0, "¡Hola mundo!", $color_texto);

… o si quieres tener más control sobre el estilo, puedes usar fuentes TrueType con la función imagettftext() (en la web DaFont tienes miles de fuentes TrueType gratuitas)

  1. $im = imagecreatetruecolor(400, 30); //creo una nueva imagen de 400×30
  2. // creo algunos colores
  3. $blanco = imagecolorallocate($im, 255, 255, 255);
  4. $gris   = imagecolorallocate($im, 128, 128, 128);
  5. $negro  = imagecolorallocate($im, 0, 0, 0);
  6. imagefilledrectangle($im, 0, 0, 399, 29, $blanco); //relleno el fondo
  7.  
  8. // El texto a pintar
  9. $texto = "Boozox.net";
  10. // El archivo ttf, escribe la ruta correctamente!!
  11. $fuente = ‘fuente.ttf’;
  12.  
  13. // Agrego una sombra al texto
  14. imagettftext($im, 20, 0, 11, 21, $gris, $fuente, $texto);
  15.  
  16. // Escribo el texto
  17. imagettftext($im, 20, 0, 10, 20, $negro, $fuente, $texto);

[descargar código]
Demo:

Tratar bien la transparencia en PNG

Las imágenes PNG admiten un canal Alpha que indica la opacidad en cada punto de la imagen, para crear efectos semitransparentes. Si te interesa que esta transparencia se muestre correctamente, deberás calentarte un poco más la cabeza, y tener el canal Alpha siempre en cuenta. Te aconsejo que incluyas estas dos líneas después de crear una nueva imagen con transparencia (aunque tendrás que estar siempre atento de que el canal alpha no se pierda!)

  1. $im = imagecreatefrompng(‘mi_transparencia.png’);    
  2. //conservar transparencia
  3. imagealphablending($im, true);
  4. imagesavealpha($im, true);

Recuerda también que puedes crear colores con canal de transparencia usando imagecolorallocatealpha() en lugar de imagecolorallocate()

Exportar la imagen para visualizarla

Después de haber modificado nuestra imagen tal como deseamos, tendremos que exportarla. Existe una función para cada formato de salida (imagejpeg(), imagepng(), imagegif(), etc…). Personalmente te recomiendo siempre exportar en PNG porque se conserva la calidad y la nitidez mucho mejor.

En todos los casos tendremos la opción de generar el código de la imagen, si queremos que el archivo PHP simule ser la propia imagen, o indicarle dónde queremos que almacene la imagen resultado.

Para el primer caso, tendremos que indicar mediante las cabeceras que lo que estamos a punto de mostrar es una imagen. Para esto usamos la función header() indicando el tipo de archivo en concreto de que se trata (image/jpeg, image/png o image/gif).

  1. //este codigo se incluiria al final del proceso de edicion, suponiendo que $im es el recurso de la imagen que queremos mostrar
  2. header("Content-type: image/png");
  3. imagepng($im);

Una vez creado este archivo, podemos mostrar el resultado en una página HTML simplemente creando una etiqueta de imagen que referencie a ese archivo .php

  1. <img src="imagen.php" />

Si queremos almacenar en nuestro disco la imagen resultante, tendremos que pasar como segundo parámetro a la función el nombre del archivo que queremos generar.

  1. imagepng($im,‘ruta/miarchivo.png’);

Recuerda que me interesa mucho tu opinión. Crees que falta algo? tienes dudas? vas a trabajar con la librería GD ahora que sabes cómo funciona? has hecho experimentos curiosos con imágenes dinámicas? …

Categorias: Código, Imagen Digital, PHP, Ubuntu | 53 comentarios »

Redimensionar en PHP a tamaño fijo

20 de septiembre del 2008 Escrito por Alex Barros

Ver también Guía básica para editar imágenes en php con GD

Esta es una técnica para redimensionar imágenes a un tamaño fijo (aunque no guarde proporción), sin distorsionar la imágen.

No, no se trata del escalado líquido. Esa técnica es demasiado compleja. Se trata de recortar la imágen para adaptarla a la nueva resolución, perdiendo el mínimo espacio posible.

Foto de Basajaun en Flickr Licencia CC(by-nc-sa)

Para hacer esto, he desarrollado este algoritmo, que paso a compartir con todos para que lo uséis como os de la gana (requiere Biblioteca GD)

  1. function resizeFit($im,$width,$height) {
  2.     //Original sizes
  3.     $ow = imagesx($im); $oh = imagesy($im);
  4.    
  5.     //To fit the image in the new box by cropping data from the image, i have to check the biggest prop. in height and width
  6.     if($width/$ow > $height/$oh) {
  7.         $nw = $width;
  8.         $nh = ($oh * $nw) / $ow;
  9.         $px = 0;
  10.         $py = ($height$nh) / 2;
  11.     } else {
  12.         $nh = $height;
  13.         $nw = ($ow * $nh) / $oh;
  14.         $py = 0;
  15.         $px = ($width$nw) / 2;
  16.     }
  17.    
  18.     //Create a new image width requested size
  19.     $new = imagecreatetruecolor($width,$height);
  20.    
  21.     //Copy the image loosing the least space
  22.     imagecopyresampled($new, $im, $px, $py, 0, 0, $nw, $nh, $ow, $oh);
  23.    
  24.     return $new;
  25. }

[Descargar código]

Cómo utilizar

Si no estás familiarizado con la edición de imágenes en PHP, no te preocupes. Para utilizar la función de arriba, tenemos que pasarle como parámetro una imágen tipo resource de GD y dos números indicando el ancho y alto que queréis forzar a la foto.

Para que se vea, hay que editar las cabeceras HTTP indicando que el contenido es una imágen. Y a este archivo de imágen (aunque sea un PHP) se le puede llamar desde la etiqueta img de HTML. Dejemos que hable el código:

imagen.php

  1. //Primero creo el resource de la imagen desde el original en JPEG
  2. $im = imagecreatefromjpeg(‘original.jpg’);
  3.  
  4. //Ahora uso la función antes definida, con unos parámetros de ancho y alto que yo quiera
  5. $resized = resizeFit($im, 100, 150);
  6.  
  7. //Indico en la cabecera HTTP que es una imagen
  8. header("Content-type: image/png");
  9.  
  10. //Por último exporto la nueva imagen
  11. imagepng($resized);

miPagina.html

  1. <p>Esta es mi foto redimensionada a 100 x 150:</p>
  2. <img src="imagen.php">

Puedes ver un ejemplo en …

Esta técnica la uso en Gpsia para mostrar las imágenes al tamaño que yo le diga, sin que se vean distorsionadas. Échale un ojo, y de paso ves las rutas tan increíbles que está subiendo la gente.

Categorias: Código, Diseño, Imagen Digital, PHP | 5 comentarios »

Parsear un archivo XML con PHP y DOM.XML

6 de agosto del 2008 Escrito por Alex Barros

Brevemente voy a introducir el uso de la extensión DOM.XML de PHP

Podemos leer un archivo XML a partir de una cadena de texto (con domxml_open_mem) o diciendo dónde está el archivo XML ( con domxml_open_file)

Como ejemplo usaremos el archivo XML que proporciona el API Google Weather (no documentada) para hacer predicciones meteorológicas en determinado lugar.

  1. $xml = domxml_open_file(‘http://www.google.com/ig/api?hl=es&weather=Madrid’); //En este caso la prediccion para madrid

El método más importante es get_elements_by_tagname, que nos devuelve los tags que tienen ese nombre, en forma de array.

En nuestro caso, vamos a hacer una comprobación por si el documento XML nos informa de que ha habido un error, con el tag problem_cause ver ejemplo

  1. $problem = $xml->get_elements_by_tagname(‘problem_cause’);
  2. if($problem) {
  3.         $problem_cause = $problem[0]->get_attribute_node(‘data’);
  4.         die($problem_cause);
  5. } else {
  6. }

Para obtener la descripción, tendremos que usar el método get_attribute_node que nos dice el valor del atributo que queramos, para un elemento [nombreTag atributo="valor"].

Y ahora, vamos a ir directos al ajo. Echad un vistazo a la estructura del API Google Weather, y al siguiente código, después lo explico.

  1. //Esta funcion nos ayuda a sacar el atributo "data" del "tag" de un nodo dado
  2. function getTagDataFromNode($tag,$node){
  3.         $child = $node->get_elements_by_tagname($tag);
  4.         $data = $child[0]->get_attribute_node(‘data’);
  5.         return $data->value();
  6. }
  7.  
  8. //Extraigo la informacion de la prediccion
  9. $infoTag = $xml->get_elements_by_tagname(‘forecast_information’);
  10. $city = getTagDataFromNode(‘city’,$infoTag[0]); //La ciudad
  11. $date = getTagDataFromNode(‘forecast_date’,$infoTag[0]); //La fecha de la prediccion
  12.  
  13. echo "<h1>Prediccion en $city ($date)</h1>";
  14.  
  15. //Prediccion para los proximos dias
  16. $items = $xml->get_elements_by_tagname(‘forecast_conditions’);
  17.  
  18. foreach($items as $item){
  19.         echo "<p><strong>".getTagDataFromNode(‘day_of_week’,$item)."</strong> <br>";
  20.         echo "<img src=\"http://google.com".getTagDataFromNode(‘icon’,$item)."\"><br>".getTagDataFromNode(‘condition’,$item).".<br>";
  21.         echo "Temperaturas entre ".getTagDataFromNode(‘low’,$item)." &deg;C y ".getTagDataFromNode(‘high’,$item)." &deg;C</p>";
  22. }

[Ver resultado]

La función que se define al comienzo sirve para ahorrarnos código al extraer el atributo “data” de los nodos, porque todos los tags tienen lo importante ahí.

El resto del código creo que está bastante claro. Puedes ver una [Demo] y el [código fuente].

Si te ha gustado el post, te parece interesante, o tienes dudas escríbeme un comentario, tengo ganas de leerte!

Nota: Si no tienes esta extensión instalada en tu host, pregunta al servicio técnico para que te lo instalen, o mira esta página para hacerlo tú mismo.

Categorias: Aplicaciones, Código, PHP | 18 comentarios »

Geolocalizar usuarios con su IP

5 de agosto del 2008 Escrito por Alex Barros

estoy-aquiOs quiero comentar brevemente cómo saber el País del que provienen vuestros visitantes, usando su IP, y la base de datos de MaxMind

Para tener esta feature, descargamos la última versión de GeoLite Country (es la versión gratuita de la base de datos).

Esto es un archivo comprimido, que contiene un archivo tipo DAT. Lo descomprimimos en nuestro directorio, y nos olvidamos de él.

Si vais a programar en PHP aquí hay algunos archivos de muestra. También hay soporte para otros lenguajes.

El que más nos importa es el archivo geoip.inc que contiene la librería para gestionar la base de datos en PHP. Guardamos el archivo en el mismo directorio que la base de datos.

Ahora, sólo nos queda un poco de código:

  1. <?php
  2. // Este codigo muestra como usar la API de GeoIP
  3.  
  4. include("geoip.inc");
  5. $gi = geoip_open("GeoIP.dat",GEOIP_STANDARD);
  6. $cc = geoip_country_code_by_addr($gi, $_SERVER[‘REMOTE_ADDR’]);
  7. geoip_close($gi);
  8.  
  9. echo "El codigo de tu pais es: $cc";
  10. ?>

Ver ejemplo

Esto mostrará por pantalla algo como

El codigo de tu pais es: ES

Si queremos usar el nombre del país en Español, podéis descargaros este archivo que he preparado. Contiene un array asociativo con las claves de los paises, y sus valores, usadlo así:

  1. <?php
  2. // Este codigo muestra como usar la API de GeoIP
  3.  
  4. include("geoip.inc");
  5. include("paises.inc");
  6. $gi = geoip_open("GeoIP.dat",GEOIP_STANDARD);
  7. $cc = geoip_country_code_by_addr($gi, $_SERVER[‘REMOTE_ADDR’]);
  8. geoip_close($gi);
  9.  
  10. echo "Tu vienes de ".utf8_decode($PAISES[$cc]);
  11. ?>

Ver ejemplo

Debería aparecer algo similar a:

Tu vienes de España

Nota1: Recomiendo tener todos los archivos en el mismo directorio, si no lo hacéis así, tened cuidado con poner bien la ruta a cada archivo!

Nota2: Si algún código que has copiado de esta web no te funciona, comprueba que las comillas sean correctas (reescríbelas con tu teclado) WordPress traduce las comillas simples y dobles que se usan en código, por otras raras que se usan en textos.

Categorias: Código, PHP, Review | No hay comentarios »

Apoyemos al PHP!

11 de abril del 2008 Escrito por Alex Barros

A raíz del post anterior haciendo mimetismos entre lenguajes de programación y embarcaciones, nos encontramos con que al lenguaje de programación PHP se le asignaba una triste balsa de bambú.

PHP is a bamboo raft. A series of hacks held together by string. Still keeps afloat though.

PHP es una balsa de bambú. Unos cuantos apaños unidos con una cuerda. Aún así consigue ir a flote

Me parece un juicio muy injusto, y a los comentaristas de Boozox también!

  • Memiux: [...] un poco exagerado lo de PHP xD
  • daniel: El que diga eso de php, es que no tiene ni idea [...]
  • Jose D: [...] yo también defiendo a php que está que se sale por todos lados [...]

Coincido con todos ellos, PHP no es una triste balsa da bambú! PHP es un lenguaje muy potente sobretodo para lo que está enfocado (desarrollo de webs dinámicas). Cuenta con infinidad de funciones y bibliotecas útiles para cualquier cosa que se te pase por la mente, y de hecho un porcentaje muy elevado (la mayor parte) de las webs en internet están respaldadas por este lenguaje.

No en vano, webs como Youtube, yahoo, wikipedia, facebook, digg, flickr…. han elejido como lenguaje idóneo el PHP.

Se le acusa de provocar desorden en el código y en la estructura de los programas, pero esto es un hecho que se desprende de la habilidad y la experiencia de quien programa.

Es posible que el hecho de que la versatilidad y facilidad de PHP permita su uso a personas inexpertas, de como resultado la proliferación de código de mala calidad, pero no se puede generalizar, y declarar que en PHP se programan apaños y chapuzas.

He programado toda mi vida en PHP y jamás me ha presentado una frontera, el límite ha sido siempre mi imaginación.

Por ello quiero defender el papel de PHP, y promover su uso para cualquier tipo de tarea en internet.


Larga vida a PHP !!!!

Categorias: Aplicaciones, Código, Opinión, PHP | 10 comentarios »

Desenfoque gaussiano: cómo funciona + filtro para Imaset

18 de diciembre del 2007 Escrito por Alex Barros

Me he propuesto realizar el filtro de Desenfoque Gaussiano, y lo he conseguido. A continuación os muestro el algoritmo, y la descarga del filtro para quienes usen Imaset 2.1

El algoritmo

El filtro gaussiano consiste en la mezcla de los colores de una imágen para conseguir un efecto de desenfoque. Esta es una explicación muy general, y por supuesto el algoritmo es más complejo que esto.

En primer lugar, consideraremos la imágen como una matriz de puntos (pixeles), con unos valores determinados de rojo, verde y azul. A partir de aquí, los valores de cada punto de la nueva imágen, serán una combinación de los puntos cercanos. De esta forma, si un punto es de color rojo, y cercano a él hay puntos negros, este rojo se oscurecerá (y los negros se enrojecerán).

Intercambio de color entre pixeles cercanos

Pero para determinar cuáles son los pixeles que son cercanos, y los que no, se debe especificar al filtro un radio de acción. Con esto, si por ejemplo indicamos un radio de 10 pixeles, cada píxel de la nueva imágen se verá modificado por los todos los pixeles a menos de 10 unidades de distancia. Pero no todos los pixeles modifican con la misma “fuerza”, cuanto más cerca estén del pixel que se está modificando, más valor tendrán en el cálculo del nuevo color. Es aquí donde aparece nuestro simpático amigo Gauss.

La función de la distribución Gaussiana va a ayudarnos a adjudicar cuánto aporta cada pixel, en función de lo cerca o lejos que se encuentre. Esta función tiene la forma distribucion_gaussiana.png donde (x-b) es la distancia entre el pixel que está siendo modificado y el píxel del que se está tomando el valor, a y c valen 1, y f(x) resulta un número Real entre 0 y 1 que representa el porcentaje de influencia.

Resumiendo

Lo que está claro es que hay que mezclar los píxeles entre sí, y que usaremos un radio de influencia en que cuanto más lejos está un píxel de otro, menos le afecta.

Después de analizar el problema, y aplicar una fórmula estadística, podemos concluir que el valor de cada pixel es:

La suma de todos los píxeles dentro del radio R, multiplicados cada uno por distribucion_gaussiana.png (tal y como se ha descrito antes), y todo esto, dividido entre la suma de todos los valores de la fórmula distribucion_gaussiana.png en los puntos que intervienen.

Y todo eso es sólo para calcular uno de los tres componentes (Rojo, Verde o Azul) de un sólo pixel.

De modo que, a falta de una fórmula mágica de optimización, el efecto de desenfoque Gaussiano no es ninguna broma, realiza una cantidad muy elevada de cálculos (que aumenta junto al Radio y al tamaño de la imágen).

El archivo de descarga

Aquí os dejo el código fuente y la descarga del filtro Desenfoque Gaussiano para Imaset 2.1
Tened en cuenta que, como he dicho, es un filtro muy costoso, y aplicarlo puede llevar bastantes segundos.

La forma de poder usarlo es: descargar el archivo ZIP, descomprimir su contenido, y subir el archivo gaussian.xml al directorio “/filters” y el archivo es_ES.php al directorio “/lang

Ejemplo del filtro Gaussiano en Imaset

GaussGauss Desenfocado
Como se puede apreciar, realiza un toque de suavizado, si se aplica poco desenfoque (poco radio).

Código fuente

Os dejo como siempre el código fuente de este filtro.

  1. <filter>
  2.         <name>gaussian_blur</name>
  3.         <category>effect</category>
  4.         <parameters>
  5.                 <pa>$rad=5</pa>
  6.         </parameters>
  7.         <function>
  8.                 if(!$rad) $rad = 5;
  9.                
  10.                 $sx = imagesx($im);
  11.  
  12.                 $sy = imagesy($im);
  13.  
  14.                
  15.  
  16.                 for($x=-$rad;$x<$sx+$dar;$x++) // meto en una matriz los valores de colores
  17.  
  18.                 {
  19.  
  20.                         for($y=-$rad;$y<$sy+$rad;$y++)
  21.  
  22.                         {
  23.                                 if($x<0 || $y<0 || $x>$sx || $y>$sy)
  24.                                         $imatrix[$x][$y] = array($imaset->Red,$imaset->Green,$imaset->Blue);
  25.                                 else {
  26.  
  27.                                         $rgb = ImageColorAt($im, $x, $y);
  28.  
  29.                                         $r = ($rgb >> 16) & 0xFF;
  30.  
  31.                                         $g = ($rgb >> 8) & 0xFF;
  32.  
  33.                                         $b = $rgb & 0xFF;
  34.                                         $imatrix[$x][$y] = array($r,$g,$b);
  35.                                 }
  36.  
  37.                         }
  38.  
  39.                 }
  40.  
  41.                
  42.                 // Ahora voy a poner valores (calculandolos previamente)
  43.                 for($x=0; $x<$sx; $x++) { // recorro el array antes construido, pixel a pixel
  44.                         for($y=0; $y<$sy; $y++) {
  45.                                 unset($su1R,$su1G,$su1B,$su2,$sue); // inicializo
  46.                                 for($i=$x-$rad; $i<$x+$rad; $i++) { // circundantes en eje x
  47.                                         for($j=$y-$rad; $j<$y+$rad; $j++) { // circundantes en eje y
  48.                                                 $sue = round(pow(2.7,-(pow(($i-$x),2) + pow(($j-$y),2)))*100,4); //valor gaussiano de peso
  49.                                                 $su1R += $sue * $imatrix[$i][$j][0]; //Sumando de rojos
  50.                                                 $su1G += $sue * $imatrix[$i][$j][1]; //Sumando de verdes
  51.                                                 $su1B += $sue * $imatrix[$i][$j][2]; //Sumando de azules
  52.                                                 $su2 += $sue;
  53.                                         }
  54.                                 }
  55.  
  56.                                 imagesetpixel($im,$x,$y,imagecolorallocate($im,round($su1R/$su2),round($su1G/$su2),round($su1B/$su2)));
  57.                         }
  58.                 }
  59.  
  60.                 return $im;
  61.         </function>
  62. </filter>

Categorias: Código, Imagen Digital, PHP, Plugins | 4 comentarios »

Solucionado problema del plugin Imaset 2.1

7 de diciembre del 2007 Escrito por Alex Barros

Tienes problemas para que funcione Imaset?
Hasta ahora algunas personas tenían problemas para que el plugin Imaset en la versión 2.1 les reconociera las imágenes.

Ya he conseguido dar con el problema, y he cambiado el archivo de descarga para que sustituyáis los archivos en el plugin.

El problema que ocasionaba esto es bastante complejo de explicar, pero está relacionado con la yuxtaposición de arrays. En el código de Imaset yo había optado por usar la función array_merge(), la cual une los arrays que le pases como parámetro, pero esta función no mantiene los índices numéricos, y para la aplicación era importante que los mantuviera.

La solución es usar el concatenador básico de arrays, es decir, el operador suma.

  1. $a1 = array(5=>"ABC",12=>"DEF");
  2. $a2 = array(30=>"PPP",50=>"UIO");
  3.  
  4. $a3 = $a1 + $a2;
  5.  
  6. /*  Ahora $a3 es:
  7. a3[5] = "ABC"
  8. a3[12] = "DEF"
  9. a3[30] = "PPP"
  10. a3[50] = "UIO"  */

Categorias: Aplicaciones, Boozox, Código, PHP, Plugins | 11 comentarios »

Manual completo y sencillo de Expresiones Regulares en PHP

4 de diciembre del 2007 Escrito por Alex Barros

Las expresiones regulares son una potente herramienta que nos permite contrastar un texto con un patrón de búsqueda. Esta tarea resulta fundamental en algunos programas, y en otros puede facilitarnos increíblemente el trabajo.

Regex

PHP permite dos tipos principales de funciones para expresiones regulares: las de tipo ereg (Expresiones regulares POSIX) y las de tipo preg (Compatibles con Perl). Son muy similares, aúnque las segundas llegan a ser algo más potentes.

Una expresión regular, consiste en comparar un patrón frente a un texto, para comprobar si el texto contiene lo especificado en el patrón.

Por poner un par de ejemplos:

Patrón: in
Coindicen:

  • intensidad
  • cinta
  • interior

Patrón: [mp]adre
Coindicen:

  • Mi madre se llama Luisa
  • Tu padre es jardinero

A continuación voy a repasar la sintaxis básica de una expresión regular
Sigue leyendo esta entrada »

Categorias: Código, HOWTO/CóMO, PHP | 39 comentarios »

Formas de ejecutar funciones en PHP

11 de noviembre del 2007 Escrito por Alex Barros

Aúnque a algunos les parezca extraño, existen tres formas distintas de ejecutar una función en PHP (por lo menos que yo conozca). Cada una puede venir bien en situaciones distintas.

Lo primero de todo, crearemos un par de funciones.

  1. function menor($a,$b){ return $a<$b ? $a : $b; }
  2. function mayor($a,$b){ return $a>$b ? $a : $b; }

La función menor() devuelve el menor de los dos números pasados como parámetros. La función mayor() hará lo contrario.

La forma clásica

La forma más típica de ejecutar una función, es símplemente escribiendo su nombre, seguido de unos paréntesis, con los parámetros separados por comas. De esta forma, al escribir:

  1. $a = 12;
  2. $b = 5;
  3.  
  4. echo "Entre $a y $b, el menor es ",menor($a,$b);

Nos devolvería el siguiente texto:

Entre 12 y 5, el menor es 5

Con la función call_user_func(_array)

Las función call_user_func nos permite ejecutar una función, dado el nombre en cadena alfanumérica.

La diferencia con call_user_fucn_array, es que en esta última los parámetros son pasados en un array.

  1. if($_GET[‘comparacion’] == ‘menor’) $func = ‘menor’;
  2. else $func = ‘mayor’;
  3.  
  4. $a = 17;
  5. $b = 32;
  6.  
  7. echo call_user_func($func,$a,$b);

Dependiendo de la variable GET comparación, se ejecutará una función u otra. La alternativa con call_user_func_array es:

  1. if($_GET[‘comparacion’] == ‘menor’) $func = ‘menor’;
  2. else $func = ‘mayor’;
  3.  
  4. $a = 17;
  5. $b = 32;
  6.  
  7. echo call_user_func_array($func,array($a,$b)); //parametros en forma de array

Directamente de una cadena

Esta es una forma sorprendente de ejecutar funciones. Parte de lo mismo que la anterior, el nombre de la función en una variable alfanumérica. Pero en este caso puede ser tratada directamente como función, así por la cara.

  1. $funcion = ‘menor’;
  2. echo $funcion(2,5); //Devuelve 2
  3. echo $funcion(8,-12); //Devuelve -12

Esta libertad recuerda a JavaScript, donde pueden igualarse variables a funciones de forma muy sencilla.

Conocéis alguna forma más? Os parece útil disponer de diferentes métodos para llamar a funciones?

Categorias: Código, Comparativa, Curioso, HOWTO/CóMO, PHP | 4 comentarios »

Leer y escribir Zip en PHP sin complicarse la vida

2 de noviembre del 2007 Escrito por Alex Barros

Lo que hoy quiero mostraros es una genial librería, que facilita increíblemente el manejo de archivos zip con PHP; únicamente habrá que incluir un archivo a nuestro código, para gozar de toda su funcionalidad para abrir, explorar y crear archivos de tipo Zip.

Instanciación

El primer paso para usar esta librería es siempre el mismo, independientemente de lo que queramos hacer:

  1. require_once("pclzip.lib.php");
  2. $archivo = new PclZip("archivo.zip");

Como se observa, hemos incluido el fichero de la librería, y hemos instanciado la clase PclZip, con un nombre de archivo.
Este nombre de archivo puede ser uno existente, que queremos manipular, o uno inexistente, que queremos crear a continuación. Será más adelante cuando le indicamos lo que queremos hacer con archivo.zip (leer o escribir), hasta aquí únicamente lo hemos referenciado.

Sigue leyendo esta entrada »

Categorias: Aplicaciones, Código, HOWTO/CóMO, PHP | 19 comentarios »

« Entradas Anteriores

del.icio.us meneame.net RSS

Search:

Bicivalencia Localiza las estaciones de Valenbisi, servicio público de bicicletas en Valencia, España. Ver más Gpsia Descubre y comparte rutas por todo el mundo, tomadas con GPS. Ver más Imaset Edita tus imágenes de Wordpress con este sencillo plugin. Ver más

¡Mi música es tuya!

Digo yo que...

Mis fotos de Flickr

Entradas recientes

Meta:

Respeta el copyleft

,