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 | 7 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 | 3 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 | 15 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: Comparativa, Curioso, Código, HOWTO/CóMO, PHP | No hay 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 | 4 comentarios »

Trabajar con conexiones socket en PHP

31 de Octubre del 2007 Escrito por Alex Barros

Para aquellos que cuenten con CURL en su servidor, sabrán que esta biblioteca ofrece increíbles ventajas. Sin embargo en ocasiones no contamos con esta herramienta en el servidor, o necesitamos trabajar a un nivel más bajo; es decir, sin que CURL nos lo de todo masticadito.

Este nivel es el de interactuación entre máquinas a través de un protocolo (usualmente HTTP).

Voy a centrarme en el uso de la función fsockopen() y en las cabeceras HTTP. Aúnque estas conexiones abarcan más materia, estos puntos resultan más útiles y sencillos de entender.

Para iniciar una conexión con otro dominio de internet, crearemos un puntero mediante fsockopen. Este puntero referencia a la conexión que hemos establecido con el archivo de ese otro dominio, y podremos usar las funciones típicas de un puntero de archivo (fgets() y fputs() principalmente)

La función requiere de un parámetro obligatorio (el archivo remoto) y otros opcionales, que son:

  • Puerto: Cualquier máquina consta de diversos puertos. El 80 (ó 8080 en ocasiones) es el de HTTP (transferencia de documentos web), el que más nos interesa.
  • Error numérico: Número entero que identifica un error ocurrido. 0 si ha habido éxito
  • Error descriptivo: Define en lenguaje natural el error.
  • Tiempo de espera: Puedes indicarle el tiempo para que la conexión expire. Para tener mayor control de este tiempo, puedes usar también stream_set_timeout()

Un ejemplo de conexión usando esta técnica puede ser este:

  1. $da = fsockopen("www.example.com", 80, $errno, $errstr, 30);
  2. if (!$da) {
  3.     echo "$errstr ($errno)
  4. \n"; //ha ocurrido un error …
  5. } else {
  6.     $salida = "GET / HTTP/1.1\r\n"; //conexión usando HTTP1.1 y el metodo GET
  7.     $salida .= "Host: www.example.com\r\n"; //indico el host con el que quiero conectarme, disponible con parse_url()
  8.     $salida .= "Connection: Close\r\n\r\n"; //Cierro la conexion para no seguir gastando recursos
  9.  
  10.     fwrite($da, $salida); //le escribo las ordenes que acabo de generar
  11.     while (!feof($da)) { //recorro fila a fila el archivo
  12.         echo fgets($da, 128); //imprimo esta linea
  13.     }
  14.     fclose($da); //cierro el puntero
  15. }
  16.  

Como podemos observar, nos permite enviar las cabeceras HTTP que creamos oportunas, aúnque para hacer una conexión simple basta con las tres instrucciones indicadas en el ejemplo.

Para chequear el contenido de cualquier URL, sin pararse a personalizar cabeceras se puede emplear este simple script:

  1. function urlContent($host) {
  2.         $da = fsockopen($host, 80);
  3.         if (!$da) {
  4.                 return false;
  5.         } else {
  6.                 $salida = "GET / HTTP/1.1\r\n"; //conexión usando HTTP1.1 y el metodo GET
  7.                 $salida .= "Host: $host\r\n"; //indico el host con el que quiero conectarme, disponible con parse_url()
  8.                 $salida .= "Connection: Close\r\n\r\n"; //Cierro la conexion para no seguir gastando recursos
  9.  
  10.                 fwrite($da, $salida); //le escribo las ordenes que acabo de generar
  11.                 while (!feof($da)) { //recorro fila a fila el archivo
  12.                 $data .= @fgets($da, 128); //imprimo esta linea
  13.                 }
  14.                 fclose($da); //cierro el puntero
  15.                 return $data;
  16.         }
  17. }
  18.  
  19. //Ejemplo de uso
  20. $contenido = urlContent(‘codis.boozox.net’);
  21. echo nl2br(htmlentities($contenido)); //doy formato para leer el codigo

Ver en ejecución | Descargar:

urlContent.function.zip

El funcionamiento básico de los sockets es algo más complejo que CURL, pero si nuestro servidor no admite esta librería, este script nos vendrá de perlas en más de una ocasión.

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

Conseguir comentarios en nuestro Blog

17 de Octubre del 2007 Escrito por Alex Barros

Todos los que tenemos un blog sabemos lo importante que son los comentarios. Te ayudan a continuar con tu labor, a corregir errores, a completar información, a conocer a tus lectrores, y sobre todo pasar un buen rato.

Por eso es muy importante potenciar los comentarios, y darles el valor que se merecen. Voy a explicar una serie de estrategias que pueden hacer que se comente más en tu blog, o por lo menos que sea más agradable hacerlo.

Sigue leyendo esta entrada »

Categorias: Código, Diseño, HOWTO/CóMO, PHP, Plugins, Web, Wordpress | 2 comentarios »

Sencillo sistema AntiBot en PHP con preguntas

1 de Octubre del 2007 Escrito por Alex Barros

Seguramente ya conoceréis el clásico sistema Anti Robots que consiste en hacer una pregunta que requiera del “razonamiento humano“. Este sistema puede ser construido de una forma sencillísima con PHP, y os muestro cómo:

Nuestra base de datos de preguntas y respuestas será un simple array. Además usaremos las sesiones, para verificar la respuesta en el archivo de chequeo.

El array de preguntas y respuestas contendrá una pregunta clara y legible para los humanos, y una respuesta a modo de expresión regular, para considerar las variantes de respuesta. Por ejemplo:

Pregunta: ¿Cuántos dedos tiene una mano?
Respuesta: (5|cinco) // acepta mayúsculas y minúsculas

Una vez declarado esto, seleccionaremos una pregunta al azar, con la función rand(). La parte de pregunta la imprimiremos por pantalla en el lugar adecuado junto a un campo de texto.

Lo siguiente es guardar la expresión regular que contiene la respuesta en una variable de sesión, para que quede accesible en el chequeo a continuación.

Por último, en el archivo de chequeo usaremos la función de que evalua expresiones regulares eregi(), sometiendo la respuesta del campo de texto a la expresión regular almacenada en sesión.

El concepto ya está definido, y es tan simple como eso. Ahora plasmémoslo en esas bonitas letras de colores que son el código:

En el archivo del formulario:

  1. session_start(); //Al principio del todo!!!
  2. $preguntas = array();
  3. $preguntas[] = array(‘Cuantos dedos tiene una mano?’,‘(5|cinco)’);
  4. $preguntas[] = array(‘Resultado de sumar 2 y 4?’,‘(6|seis)’);
  5. $preguntas[] = array(‘Cuantas ruedas tiene un coche?’,‘(4|cuatro)’);
  6. $preguntas[] = array(‘Que animal es mas grande: elefante o caracol?’,‘(primero|elefante)’);
  7. $preguntas[] = array(‘Cual es el color mas oscuro de todos?’,‘negro’);
  8. $preguntas[] = array(‘Por favor, contesta: eres humano?’,‘(si|claro)’);
  9. $preguntas[] = array(‘Con que mano escribe un zurdo?’,‘(izquierda)’);
  10. $preguntas[] = array(‘Escribe pan dos veces.’,‘^pan ?pan$’);
  11. // puedes escribir todas las que quieras
  12.  
  13. $pregn = rand(0,(count($preguntas)-1)); // numero al azar
  14. $_SESSION[‘pregregex’] = $preguntas[$pregn][1]; // Lo guardo en sesion
  15. echo ‘</p>’.$preguntas[$pregn][0].‘</p><br><input type="text" name="respuesta" />’;

Y en el archivo de chequeo:

  1.  
  2. if($_SESSION[‘pregregex’] AND $_GET[‘respuesta’])
  3. {
  4.         if(eregi($_SESSION[‘pregregex’],$_GET[‘respuesta’]))
  5.         echo "De acuerdo, no eres un robot…";
  6.         else
  7.         echo "Solo Bender puede superarte a robot !";
  8.         unset($_SESSION[‘pregregex’]);
  9. }

Inconvenientes:

  • El idioma importa (a no ser que sean preguntas aritmeticas)
  • Puedes toparte con una mente brillante, que le de por contestarte lo que no es
  • …ninguno más, que yo sepa… pregúntale a un robot.

Podéis probar su funcionamiento en directo desde este ejemplo.

Descargar ejemplo:
anti-bot.zip

Categorias: Aplicaciones, Código, HOWTO/CóMO, PHP, Seguridad, Software libre | 4 comentarios »

Matrices para desenfocar

20 de Septiembre del 2007 Escrito por Alex Barros

tallo.jpgEfectivamente. Desarrollando la versión 2.0 estable del plugin Imaset, y en busca de filtros para imágenes, me he encontrado un tipo de retoque fotográfico muy utilizado por editores gráficos, llamado “matriz de convolución

Consiste en el tratamiento de una matriz por otra llamada “kernel“. La matriz original es la propia imagen en este caso (un conjunto de píxeles bidimensional), y la matriz denominada kernel varía dependiendo del efecto deseado.

El proceso del algoritmo es algo complejo. Consiste en recorrer la imágen píxel a píxel, obtener los valores de los 8 píxeles más cercanos, y aplicar la matriz kernel. El valor resultante se adjudica al píxel, y continúa haciendo lo mismo con el resto.

Lo que deducimos de esto es que la matriz de convolución readjudica el color a cada fragmento (píxel), en función de sus píxeles vecinos, dada una norma de actuación mediante el kernel, que suele consistir en una matriz de 3×3 (aúnque las hay más grandes)

Llegados hasta aquí, un filtro interesante es el de desenfoque (el típico blur). Pues bien, la matriz necesaria, es una matriz compuesta enteramente por unos. Esto quiere decir que va a mezclar literalmente el color de todos los píxeles adyacentes por igual, y el resultado será un desenfoque general.

También hay infinidad de otras opciones, puede obtenerse más contraste, detectar bordes (hay varios tipos de bordes, y son útiles para distinguir siluetas, imprescindible para robots por ejemplo), resaltar, repujado….. cada matriz ofrece un resultado distinto.

Matriz cualquiera Matriz para bordes

Esto en la práctica, teniendo PHP y la biblioteca GD (para tratamiento de imágenes) podemos efectuarlo con la función imageconvolution().
Los parámetros necesarios son un resource de imágen (creado con imagetruecolor, imagecreatefromjpeg, etc), la matriz de convolución (de tres por tres), un divisor para los elementos de la matriz, y un compensador (offset).

Un ejemplo de script en PHP:

  1. $im = imagecreatefromjpeg(‘fotografia.jpg’);
  2. $matrix = array(
  3. array( 2, 2, 2 ),  
  4. array( 2, 2, 2 ),  
  5. array( 2, 2, 2)
  6. );
  7. imageconvolution($im, $matrix, 16, 0);
  8. imagejpeg($im,‘fotografia_blur.jpg’);
  9. imagedestroy($im);

Para aquellos que no dispongan de esta función en su biblioteca GD, por ser un poco atrasada, o por cualquier otra razón, aquí hay un código para generarla:

  1. //include this file whenever you have to use imageconvolution…
  2. //you can use in your project, but keep the comment below :)
  3. //great for any image manipulation library
  4. //Made by Chao Xu(Mgccl) 2/28/07
  5. //www.webdevlogs.com
  6. //V 1.0
  7. if(!function_exists(‘imageconvolution’)){
  8. function imageconvolution($src, $filter, $filter_div, $offset){
  9.     if ($src==NULL) {
  10.         return 0;
  11.     }
  12.    
  13.     $sx = imagesx($src);
  14.     $sy = imagesy($src);
  15.     $srcback = ImageCreateTrueColor ($sx, $sy);
  16.     ImageCopy($srcback, $src,0,0,0,0,$sx,$sy);
  17.    
  18.     if($srcback==NULL){
  19.         return 0;
  20.     }
  21.        
  22.     for ($y=0; $y<$sy; ++$y){
  23.         for($x=0; $x<$sx; ++$x){
  24.             $new_r = $new_g = $new_b = 0;
  25.             $alpha = imagecolorat($srcback, $pxl[0], $pxl[1]);
  26.             $new_a = $alpha >> 24;
  27.            
  28.             for ($j=0; $j<3; ++$j) {
  29.                 $yv = min(max($y - 1 + $j, 0), $sy - 1);
  30.                 for ($i=0; $i<3; ++$i) {
  31.                         $pxl = array(min(max($x - 1 + $i, 0), $sx - 1), $yv);
  32.                     $rgb = imagecolorat($srcback, $pxl[0], $pxl[1]);
  33.                     $new_r += (($rgb >> 16) & 0xFF) * $filter[$j][$i];
  34.                     $new_g += (($rgb >> 8) & 0xFF) * $filter[$j][$i];
  35.                     $new_b += ($rgb & 0xFF) * $filter[$j][$i];
  36.                 }
  37.             }
  38.  
  39.             $new_r = ($new_r/$filter_div)+$offset;
  40.             $new_g = ($new_g/$filter_div)+$offset;
  41.             $new_b = ($new_b/$filter_div)+$offset;
  42.  
  43.             $new_r = ($new_r > 255)? 255 : (($new_r < 0)? 0:$new_r);
  44.             $new_g = ($new_g > 255)? 255 : (($new_g < 0)? 0:$new_g);
  45.             $new_b = ($new_b > 255)? 255 : (($new_b < 0)? 0:$new_b);
  46.  
  47.             $new_pxl = ImageColorAllocateAlpha($src, (int)$new_r, (int)$new_g, (int)$new_b, $new_a);
  48.             if ($new_pxl == -1) {
  49.                 $new_pxl = ImageColorClosestAlpha($src, (int)$new_r, (int)$new_g, (int)$new_b, $new_a);
  50.             }
  51.             if (($y >= 0) && ($y < $sy)) {
  52.                 imagesetpixel($src, $x, $y, $new_pxl);
  53.             }
  54.         }
  55.     }
  56.     imagedestroy($srcback);
  57.     return 1;
  58. }
  59. }
  60.  

Muy pronto os presentaré la versión definitiva de Imaset 2.0, qué nervios!

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

« Entradas Anteriores

del.icio.us meneame.net RSS

Buscar:



Tagcloud

Entradas Recientes

Meta: