Mostrando las entradas con la etiqueta PHP. Mostrar todas las entradas
Mostrando las entradas con la etiqueta PHP. Mostrar todas las entradas

miércoles, agosto 30, 2017

Configuring VirtualHosts in XAMPP on Mac

Development locally, so one of the first applications I installed was XAMPP, a cross platform Apache/MySQL/PHP stack. While I know that MAMP is very popular on Mac, I have been using XAMPP for many years so I thought I’d stick with what I know.
Installing XAMPP was a snap, but when I came to create my own Apache VirtualHosts things started getting fiddly. Here are the steps I followed to get everything running smoothly.

What are VirtualHosts?

First, some quick background on what we’re trying to achieve.
VirtualHosts allow Apache to map a hostname to a directory on the filesystem. You can set up as many VirtualHosts as you need, so that each website operates under its own hostname. For example, you might want to map mysite.local to /Users/yourusername/mysite. To test your development site all you would need to do is plug “http://mysite.local” into your browser’s address bar.

Enable VirtualHosts

The first thing you’ll need to do is open the file /Applications/XAMPP/xamppfiles/etc/httpd.conf in your favourite text editor. Look for the following lines:
# Virtual hosts
#Include /Applications/XAMPP/etc/extra/httpd-vhosts.conf
Uncomment the second line by removing the hash (#), so that Apache loads your custom VirtualHosts configuration file:
# Virtual hosts
Include /Applications/XAMPP/etc/extra/httpd-vhosts.conf

Create your VirtualHosts

Open the file /Applications/XAMPP/xamppfiles/etc/extra/httpd-vhosts.conf. Towards the bottom of the file you will see some example VirtualHosts, which you should comment out or delete.
At the bottom of the file, add ‘localhost’ as the default named VirtualHost:
# localhost

    ServerName localhost
    DocumentRoot "/Applications/XAMPP/xamppfiles/htdocs"
    
        Options Indexes FollowSymLinks Includes execCGI
        AllowOverride All
        Require all granted
    
This step is necessary to ensure that http://localhost still points at XAMPP’s htdocs directory once we’ve created our custom VirtualHosts. Personally I don’t use the htdocs directory a lot, but occasionally it’s useful to have somewhere to perform quick tests.
Now you are ready to create your own VirtualHosts. After the default localhost that you just created, add:
# My custom host

    ServerName mysite.local
    DocumentRoot "/Users/yourusername/path/to/your/site"
    
        Options Indexes FollowSymLinks Includes ExecCGI
        AllowOverride All
        Require all granted
    
    ErrorLog "logs/mysite.local-error_log"
In the above example you should replace “mysite.local” with your own hostname. This can be anything you wish, but make sure you choose a hostname that won’t conflict with a real domain name. Using a .local extension makes it obvious that the site is hosted locally rather than on a public web server.
The path to your website can point at any folder in your OS X user directory. I store most of my sites inside of Dropbox so that I can access them on both my home and work machines. If your path includes spaces, make sure you enclose it in quotes, like in my example.

Edit your hosts file

Once you’ve saved your httpd.conf and httpd-vhosts.conf files, the next step is to edit your OS X hosts file so it knows how to handle your new ServerName. The hosts file is used by OS X to map hostnames to IP addresses. In this case we want to map your new ServerName to the IP address 127.0.0.1, which is your localhost.
Fire up a Terminal instance, and at the prompt type the following command:
sudo nano /etc/hosts
Enter your OS X password when prompted, and the hosts file will be opened in the nano text editor. You’ll see that the hosts file already contains some default hostname mappings (e.g. “127.0.0.1 localhost”). Use your keyboard’s arrow keys to navigate to the bottom of the file and add your own mapping:
# XAMPP VirtualHost mappings
127.0.0.1 mysite.local
Save the host file using the key combo control+o, and pressing return when prompted to choose the filename. Close the file using control+x.

Restart Apache

So that your changes take effect, restart Apache. This can be done using XAMPP Control, which is found at /Applications/XAMPP/XAMPP Control.app.
Point your browser at http://mysite.local (or whatever ServerName you chose) and you should see your website. However, there’s a chance that instead you’ll be faced with a…

403 error

Because Apache runs as the ‘nobody’ user by default, it may not have adequate permission to browse your OS X user directory or some of its subdirectories, in which case you’ll see a 403 ‘access forbidden’ error when you try and view your development site. Similarly, you may find that although you can view your dev site, PHP throws errors when you attempt to write files or make directories on the filesystem.
To fix this you can configure Apache to run as your OS X user. Open /Applications/XAMPP/xamppfiles/etc/httpd.conf and look for the following lines:
# User/Group: The name (or #number) of the user/group to run httpd as.
# It is usually good practice to create a dedicated user and group for
# running httpd, as with most system services.
#
User daemon
Group daemon
Change User to your OS X username, and save the file:
User yourusername
Restart Apache and you should now be able to navigate your site without any issues, including manipulating files and folders using PHP.
If you have problems viewing the XAMPP splash pages at http://localhost now that Apache is running as your user (e.g. nothing happens when you try to set the language), then you’ll need to give your user read/write privileges on the file /Applications/XAMPP/xamppfiles/htdocs/xampp/lang.tmp
Making the change I’ve described above carries certain security risks, and if you choose to run Apache as your OS X user then you’ll need to be quite certain that XAMPP is not accessible from outside your local network. From what I understand, XAMPP’s built in security features ensure that this is the case out-of-the-box, and it is straightforward to beef up security for additional piece of mind.
If you’re not convinced that it’s safe to let Apache run as your OS X user, another option is to change the permissions of your dev directories so that the ‘nobody’ or ‘_www’ user can read/write to them.I suspect that I would quickly tire of setting folder permissions, which is why I have opted to take the path of least resistance!

Conclusion

Hopefully this post helps someone else to get XAMPP up and running on OS X. 

fuente:
http://jonathannicol.com/blog/2012/03/11/configuring-virtualhosts-in-xampp-on-mac/

martes, agosto 29, 2017

Instalar Composer Manager Php

Cómo instalar Composer globalmente

Composer es el gestor de paquetes que utilizan todas las aplicaciones PHP modernas. Por eso es muy importante saber instalarlo correctamente en tu sistema operativo.
Cuando se publicó Composer por primera vez, se recomendaba descargarlo para cada proyecto PHP ejecutando este código:
$ cd mi-proyecto/
$ curl -sS https://getcomposer.org/installer | php
Este comando descarga Composer en forma de archivo PHAR. Así que para ejecutar cualquier comando de Composer, debías utilizar lo siguiente:
$ php composer.phar ...
Aunque esta forma de instalar Composer funciona perfectamente, tiene varias desventajas importantes:
  • Debes descargar Composer para cada proyecto que crees, lo cual no es muy productivo y te hará malgastar espacio en el disco duro.
  • Como Composer se actualiza muy frecuentemente, mantenerlo actualizado en todos tus proyectos será casi imposible y te costará mucho tiempo.
Por todo ello, se recomienda instalar Composer globalmente en cada máquina, lo que permite utilizar una única instalación de Composer para gestionar todos tus proyectos PHP.

Instalación global

Sistemas Linux y Mac OS X

Abre una consola de comandos y ejecuta lo siguiente para descargar la versión más reciente de Composer y convertirla en un comando del sistema:
$ curl -sS https://getcomposer.org/installer | php
$ sudo mv composer.phar /usr/local/bin/composer
Si por alguna extraña razón no puedes ejecutar curl para descargar Composer, prueba con el siguiente comando alternativo que usa php:
$ php -r "readfile('https://getcomposer.org/installer');" | php

Sistemas Windows

Descarga el archivo Composer-Setup.exe desde el sitio web del proyecto Composer y ejecútalo como cualquier otro instalador de Windows. 

Comprobando la instalación

Independientemente del sistema operativo que utilices, debes abrir una nueva ventana de la consola de comandos para probar la instalación realizada. Una vez abierta, ejecuta lo siguiente para comprobar que Composer se ha instalado bien:
$ composer --version
 
Composer version 1e27ff5e22df81e3cd0cd36e5fdd4a3c5a031f4a
Como Composer se actualiza frecuentemente, en tu caso verás un identificador de versión diferente.
Ahora ya puedes ejecutar cualquier comando de Composer en cualquier proyecto de tu sistema simplemente escribiendo composer:
$ cd mi-proyecto/
$ composer install
 
...
 
$ composer update
 
...
 
$ composer create-project symfony/framework-standard-edition mi-proyecto/

Actualizando Composer

Una de las principales ventajas de la instalación global de Composer es que puedes actualizarlo para todos tus proyectos ejecutando simplemente el siguiente comando:
$ composer self-update
En sistemas Linux y Mac OS X es posible que debas ejecutar el anterior comando con sudo por delante.

Referencias

PinoStudio1.com

domingo, julio 25, 2010

PHP For the Absolute Beginner


This area is intended for everyone new to PHP. It opens with a series of informal, entertaining tutorials written by Vikram Vaswani, founder and CEO of Melonfire. These tutorials build on a previously-published 5-part series which has now been updated and extended to embrace PHP 5, making parts of it suitable for those of you who already have worked with PHP 4 in the past.
If you came here to learn about elementary PHP 4 or basic PHP 5, this is for you. Enjoy!

fuente:
http://devzone.zend.com/6/php-101--php-for-the-absolute-beginner/

martes, junio 15, 2010

GD library PHP

Libreria GD

Para entender perfectamente esta librería, les viene muy bien leer los siguientes apuntes (si no lo tienen muy claro):


También, estas funciones otorgan las propiedades de la imagen:

Código
imagesx($im); //devuelve el ancho de la imagen

imagesy($im); //devuelve el alto de la imagen

getimagesize($direccion);

La función getimagesize devuelve un array con los datos de la imagen. Por ejemplo, aplicándolo a la imagen http://blog.nuestroclima.com/wp-content/uploads/2007/08/imagen_satelital_hires.jpg devuelve:
Código:
Array

(

    [0] => 4096       Ancho

    [1] => 4096       Altura

    [2] => 2

    [3] => width="4096" height="4096"

    [bits] => 8

    [channels] => 3

    [mime] => image/jpeg

)


Perfecto, empecemos. Para crear una imagen se utilizan estos siguientes:

Para crear desde un archivo sea en tu servidor o en uno externo:
Código
$im = imagecreatefrompng("dirección"); //para imágenes png

$im = imagecreatefromgif("dirección"); //para imagenes gif

$im = imagecreatefromjpeg("dirección"); //para imagenes jpg y jpeg
Si se carga una imagen con transparencias, para conservarlas, hace falta agregar estas dos lineas despues de crearla.
Código
imagealphablending($im, true);

imagesavealpha($im, true);

 

Ahora, para crear una imagen de cero basta con las funciones:

Código
$im = imagecreate($ancho, $alto);

//para imagenes con una paleta de colores, 

//osea, no tan buena calidad del color.

//

//

$im = imagecreatetruecolor($ancho, $alto);

//para imagenes con un color real, esta es la más usada...
Bueno, ya utilizando estas funciones habremos creado la imagen. No se olviden que siempre se tiene que asignar el valor reslutante de esta fuincion a una nueva variable (no hace falta que sea nueva ¬¬ jajaj).



Datos a tener en cuenta:


Antes de seguir, tiene que quedarles algo claro fundamental mente, y es la visualizacion de la imagen y la DESTRUCCION de la misma. Por qué destruir? Porque sino queda guardada la imagen en la memoria RAM del servidor y eso no es muy agradable. Entonces, para visualizarla basta con agregar el header correspondiente para el tipo:
Código
header("Content-type: image/".$imagenextension.);
Y para imprimir la imagen se usa el comando "image" seguido del tipo de imagen. por ejemplo para una imagen png:
Código
imagepng($im);
Seguido de esta función le va:
Código
imagedestroy($im);



Contenido de las imagenes:


Ahora que tenemos la imagen, vamos a darle el contenido. Para ellos se puede dibujar lineas, puntos, rectángulos (solo el borde) o rectángulos rellenos (no de dulce de leche!! ;D), así como los rectángulos, elipses y polígonos indicando cantidad de puntos y posición de los mismos. También se pueden crear colores de toda la gamma RGB con o sin transparencia. Se puede agregar texto de fuentes por defecto de la librería o fuentes del tipo "True Type", "Free type" y "PostScript" importándolas de un enlace externo. Primeramente vamos por partes y comenzamos por el principio, los colores ;D.


Colores:


Para las creaciones de colores tenemos dos funciones y un verso sin esfuerzo.
Código
$nombreDelColor = imagecolorallocate($r, $g, $b);

$nombreDelColor = imagecolorallocatealpha($r, $g, $b, $valorAlfa);



Por ejemplo podemos crear el color rojo, el amarillo y el violeta:
Código
$rojo = imagecolorallocate(255, 0, 0);

$amarillo = imagecolorallocate(255, 255, 0);

$violeta = imagecolorallocate(0, 255, 255);
Y si se quiere agregar opacidad a uno de estos colores:
Código
$azul = imagecolorallocate(0, 0, 255, 50); //ahí tenemos un 50% de opacidad...



Además de crear colores, se puede tomar el color de un píxel determinado de una imagen determinada con la función imagecolorat();, su sintaxis es
Código
imagecolorat($im, $x, $y);
Código
//por ejemplo en la imagen utilizada es una rápida que encontré por internet de un "mundo"

$im = imagecreatefromjpeg("http://www.hyparion.com/web/diccionari/dics/astronomia/imatges/tierra.jpg");

$color = imagecolorat($im, 100, 100);
Ahora, acá se nos complica un poco. La variable "color" recibe el valor de 9146518 y decimos: "Qué carajo!?". Bueno, para que ese es un valor que para nosotros trabajarlo como rgba (Red Green Blue Alpha, osea, rojo verde azul y transparencia). Para "convertirlo" a ese (rgba) o hexadecimal tenemos las posibilidades de:
Código
//esto se cumple una vez realizado el proceso anterior...

//automático para rgba, el más fácil y practico de todos!

$color = imagecolorsforindex($im, $color);

/*este devuelve un array con los valores:

Array

(

   [red] => 255

   [green] => 0

   [blue] => 0

   [alpha] => 0

)

*/

//

//

//este es simple, se le da un formato y devuelve el valor del color en hexadecimal.

$hex = sprintf("%06X", $color); //devuelve FF0000

//

//

//manualmente para rgba, el más complicado de entender y es lo 

//mismo que la función imagecolorsforindex() pero igualmente se los explico...

$colores = array();

$colores['red'] = ($color >> 16) & 0xFF;

$colores['green'] = ($color >> 8) & 0xFF;

$colores['blue'] = $color & 0xFF;

$colores['alpha'] = ($color >> 24) & 0xFF;

 
Ahora paso a explicar esas cosas raras que nos da php.net sin decirnos que es ¬¬.
Los caracteres ">>" cumplen el rol de operador y recibe el nombre de operador bitwise. Lo que hace este operador es correr determinadas veces la posición del valor indicado en binario. Osea, la variable $color toma un píxel de color rojo puro (a puro me refiero a rgb(255,0,0)) el valor retornado va a ser igual a: 16711680 :o mientras que el valor en rgb es 255. Entonces, diciéndole que me corra 16 lugares los bits de 16711680 me va a dar como resultado un numero decimal igual a 255. Ahora, si no colocamos el 0xFF en el valor del rojo, nos damos cuenta que no hay diferencia, pero cuando tratamos valores rgba, el 0xFF delimita la cantidad de bits para cada valor. Es como decir, para cada valor (rgb) corresponden 8 bits (por eso siempre los corremos para que queden los 8 primeros bits) en cambio, para el valor de alpha le corresponden solo 7 bits, pero como lo corremos 24 lugares quedando solo 7 bits (es como un substring a una cadena de 7 caracteres, aunque le indiques 8, siempre devuelve 7). Se entendió esto? Bueno, sigamos que apenas vamos por los colores!!!

Fondo:

Una cosa muy molesta de la libreria gd, es el color de fondo que por defecto lo pone negro. para eso esta la funcion imagefill() que rellena la imagen desde donde se le indique con el color establecido. Su sintaxis es:
Código
imagefill($im, $x, $y, $color)
Para que rellene por completo la imagen, los valores de $x,$y son igual a 0,0.



Trazados:

Puntos:


Ahora que tenemos los colores, vamos a dibujar. Primero vamos a empezar por un punto, que aunque sea de solo un píxel, es muy útil como para un ejemplo, un captcha. No hace falta demásiada explicación, dibuja un píxel en x,y del color $color
Código
imagesetpixel($im, $x, $y, $color); //$color es igual a el resultado de la función imagecolorallocate()

Líneas:

Para poder dibujar una linea, se indica el x,y de inicio y el x,y de final:
Código
imageline($im, $xInicio, $yInicio, $xFin, $yFin, $color);
Por ejemplo si $im es una imagen de color real de 100x100 y con fondo blanco (ya va a llegar esa parte) podría realizar esto:



Con esto:
Código
$im = imagecreatetruecolor(100, 100);

$color = imagecolorallocate($im, 0,0,0);

imageline($im, 10, 35, 76, 85, $color);



Poligonos, rectángulos y elipses:[/b]

Una vez entendido esto! nos vamos con los polígonos, primero lo primero! el rectángulo
para dibujar un rectángulo se puede dibujar solo su contorno (el borde va a medir 1px) o el rectángulo relleno de color (filled).
Sinceramente la sintaxis es idéntica a la de imageline además, son iguales entre si, solo el borde, o relleno.
Código
imagefilledrectangle($im, $xInicio, $yInicio, $xFin, $yFin, $color);

imagerectangle($im, $xInicio, $yInicio, $xFin, $yFin, $color);
Para el elipse, circulo u ovalo (cambia según los valores dados), al igual que el rectángulo y el polígono que lo vamos a ver posteriormente, se puede solo el borde o relleno. su sintaxis es:
Código
imageellipse($im, $centroX, $centroY, $ancho, $altura, $color);

imagefilledellipse($im, $centroX, $centroY, $ancho, $altura, $color);
Donde $centroX,Y son la posición del punto medio del elipse.
Bueno, para el polígono, se complica otra vez un poco. En la sintaxis del polígono:
Código
imagepolygon($im, $puntosArray, $cantidadPuntos, $color);

imagefilledpolygon($im, $puntosArray, $cantidadPuntos, $color);
La variable $puntosArray es un array, porque no le puse ese nombre al pedo xD jajaja. La estructura del array tiene que ser, cada dos valores corresponden a los valores x,y de un punto, osea:
Código
$puntosArray= array (

/*

x  y  */

10, 10,  //punto 1

15, 26,  //punto 2

50, 36,  //punto 3

68, 10   //punto 4, este ultimo numero va sin coma al final!!

);
En realidad no es tan complicado :P. y para $cantidadPuntos, lógicamente se indica la cantidad de los puntos. pero para no contarlos, basta con un:
Código
$cantidadPuntos = count($puntosArray) / 2;
Y listo. Ahora, el resultado de esta función es una imagen parecida a esta:






Agregar textos:


Ya terminamos con las formás y esas cosas. Ahora vamos por el texto. Para escribir en una imagen se puede utilizar las fuentes que trae por defecto la librería gd o fuentes del "True type", "Free type" o "PostScript Type1". La sintaxis para las postscript se ponen un poco jodidas, además, no conozco las fuentes del tipo postscript. Así que paso a explicar principalmente el imagestring(), además de escribir horizontalmente, también esta la función imagestringup() que escribe verticalmente:
Código
imagestring($im, $fuente, $x, $y, $cadenaTexto, $color);

imagestringup($im, $fuente, $x, $y, $cadenaTexto, $color);
Para la variable $fuente se puede usar los números del 1 al 6. Los ejemplos serian:



Fijense como a partir del numero 5 se repite el tipo de fuente. El problema de imagestring es que tienen el tamaño de fuente fija.

Con funciones donde se indica una fuente externa, se puede indicar el ángulo del texto (ahora lo van a entender) y el tamaño de la fuente. Yo les voy a explicar nomás imagettftext y sus derivados.

(Para descargar fuentes, aca en el foro tenemos una excelente recopilación. )

Primero van a necesitar un archivo del tipo ttf y conocer su link xD, puede estar en el mismo directorio o en uno externo, pero como cualquier cosa, recomiendo que este en tu mismo servidor para que no haya problemás. Yo por ejemplo voy a usar la fuente Hemi Head la cual es utilizada por el foro.
Antes que nada, la sintaxis de esta función es:
Código
$fuente = "hemihead.ttf";

imagettftext($im, $tamanio, $ángulo, $x, $y, $color, $fuente, $texto)
La variable fuente indica donde se encuentra el archivo de la fuente.
Por ejemplo este código,
Código


header("Content-type: image/png");

$im = imagecreatetruecolor(100, 100);

$color = imagecolorallocate($im, 255, 255, 255);

$fuente = "HEMIHEAD.TTF";

imagettftext($im, 15, 0, 15, 20, $color, $fuente, "Wiki");

imagepng($im);

imagedestroy($im);

?>
Da como resultado esta imagen:



Ahora, si yo cambio el ángulo que en caso anterior es 0 por 315:
Código
imagettftext($im, 15, 315, 15, 20, $color, $fuente, "Wiki");
Da como resultado:






Centrar textos:



Una gran necesidad al momento de usar textos en la librería gd, es el tema de centrar el texto. Acá es donde entra en acción la matemática. piensen, primeramente vamos a necesitar conocer el tamaño que ocupa el texto. Para una fuente utilizada con imagestring() se utilizan las funciones:
Código
imagefontheight($fuente);

imagefontwidth($fuente);
Estas funciones devuelven la altura y el ancho en píxeles respectivamente de un carácter de la fuente especificada. como devuelve las propiedades de un solo carácter (es el mismo valor para cualquier carácter) hay que multiplicar los valores obtenidos por la cantidad de caracteres implementados. Entonces podemos hacer algo así:
Código
$fuente = 1;

$cantidadCaracteres = strlen($texto);

$textoAltura = imagefontheight($fuente) * $cantidadCaracteres;

$textoAncho = imagefontwidth($fuente) * $cantidadCaracteres;
Y listo!, pero eso es nomás para las fuentes por defecto, ahora si se quiere con una fuente que usamos en imagettftext, tenemos la función imagettfbbox, su sintaxis:
Código
imagettfbbox($tamanio, $ángulo, $fuente, $texto);
El resultado de esta función es un array con 8 puntos:


0 esquina inferior izquierda, posición X

1 esquina inferior izquierda, posición Y

2 esquina inferior derecha, posición X

3 esquina inferior derecha, posición Y

4 esquina superior derecha, posición X

5 esquina superior derecha, posición Y

6 esquina superior izquierda, posición X

7 esquina superior izquierda, posición Y

Los datos que nosotros necesitamos son, abajo a la derecha y cumplirán el rol de x = ancho y y = altura.

Ahora que tenemos el valor que ocupa el texto tenemos que averiguar cual tiene que ser la posición del texto en la imagen. Cuando usamos una de las funciones para agregar texto, las posiciones x,y que indicamos van a ser las de arriba a la izquierda, por eso no podemos simplemente indicarle el centro de la imagen. Por eso, tenemos que restarle las medidas del texto a las medidas de la imagen. Obviamente hay que hacer ancho de la imagen - (menos) ancho del texto y alto imagen - alto texto. El resultado de estas operaciones dividido dos ( / 2) va a ser la posición x,y que le vamos a asignar al texto. Esto quedaría más o menos así:
Código


header("Content-type: image/png");

$im = imagecreatetruecolor(100, 100);

$color = imagecolorallocate($im, 255, 255, 255);

$fuente = "HEMIHEAD.TTF";

$cajaTexto = imagettfbbox(15, 0, $fuente, "Wiki");

$xCentrado = (imagesx($im) - $cajaTexto[2]) / 2;

$yCentrado = (imagesy($im) - $cajaTexto[3]) / 2;

imagettftext($im, 15, 0, $xCentrado, $yCentrado, $color, $fuente, "Wiki");

imagepng($im);

imagedestroy($im);

?>
Entonces podemos observar que el texto quedo centrado:



Entonces terminamos con suerte la implementacion del texto en imagenes.



Redimensionar:

Una de las otras herramientas que nos da GD es la posibilidad de redimensionar y copiar imagenes.
Para redimensionar lo único que se hace es copiar una imagen a otra indicándole desde donde copiar y pegar, y que tamaño se quiere. Además, tenemos dos funciones una que redimensiona como el paint( osea como que faltan píxeles), es imagecopyresize(). Y otra que rredimensiona suavizando los valores de los píxeles. Esa función es:
Código
imagecopyresampled($im_original, $im_detino, $x_destino, $y_destino, $x_original, $y_original, $ancho_destino, $alto_destino, $ancho_orginal, $alto_orginal);
Donde los x,y son desde donde se quiere copiar la imagen, y los de destino son desde donde se quiere ubicar la imagen.
Si yo tengo esta imagen:



Y quiero que mida la mitad como esto:



Tengo que hacer esto:
Código


header("Content-type: image/jpg");

$im_original = imagecreatefromjpeg("http://www.foroswebgratis.com/fotos/1/3/9/3/5//595440elhacker.jpg");

$im_destino = imagecreatetruecolor(imagesx($im_original) / 2 ,imagesy($im_original) / 2 );

$blanco = imagecolorallocate($im_destino, 255, 255, 255);

imagefill($im_destino, 0, 0, $blanco);

imagecopyresampled($im_destino, $im_original, 0, 0, 0, 0, imagesx($im_destino), imagesy($im_destino), imagesx($im_original), imagesy($im_original));

imagejpeg($im_destino);

imagedestroy($im_destino);

imagedestroy($im_original);

?>


Y listo. por ultimo dejo claro que con imagecopyresize() permite copiar partes dentro de una misma imagen...



Fuente:

http://wiki.elhacker.net/programacion/php/libreria-gd