Last updated: Fri, 26 Dec 2008

imagecopyresampled

(PHP 4 >= 4.0.6, PHP 5)

imagecopyresampled — Copie, redimensionne, rééchantillonne une image

Description

bool imagecopyresampled ( resource $dst_image , resource $src_image , int $dst_x , int $dst_y , int $src_x , int $src_y , int $dst_w , int $dst_h , int $src_w , int $src_h )

imagecopyresampled() copie une zone rectangulaire de l'image src_im vers l'image dst_im . Durant la copie, la zone est rééchantillonnée de manière à conserver la clarté de l'image durant une réduction.

En d'autres termes, imagecopyresampled() prendra une forme rectangulaire src_image d'une largeur de src_w et d'une hauteur src_h à la position (src_x ,src_y ) et le placera dans une zone rectangulaire dst_image d'une largeur de dst_w et d'une hauteur de dst_h à la position (dst_x ,dst_y ).

Si les hauteurs et largeurs des source et destination diffèrent, l'image copiée sera étirée de manière appropriée. Les coordonnées sont celles du coin supérieur gauche. imagecopyresampled() peut servir à copier des zones d'une image vers elle-même, (si dst_image est la même que src_image ) mais si les régions se chevauchent, les résultats sont imprévisibles.

Liste de paramètres

dst_im: Lien vers la ressource de l'image de destination.
src_im: Lien vers la ressource de l'image source.
dst_x: X : coordonnées du point de destination.
dst_y: Y : coordonnées du point de destination.
src_x: X : coordonnées du point source.
src_y: Y : coordonnées du point source.
dst_w: Largeur de la destination.
dst_h: Hauteur de la destination.
src_w: Largeur de la source.
src_h: Hauteur de la source.

Valeurs de retour

Cette fonction retourne TRUE en cas de succès, FALSE en cas d'échec.

Exemples

Exemple #1 Exemple simple

Cet exemple redimensionne une image à la moitié de sa taille originale.


<?php
// Le fichier
$filename = 'test.jpg';
$percent = 0.5;

// Content type
header('Content-type: image/jpeg');

// Calcul des nouvelles dimensions
list($width, $height) = getimagesize($filename);
$new_width = $width * $percent;
$new_height = $height * $percent;

// Redimensionnement
$image_p = imagecreatetruecolor($new_width, $new_height);
$image = imagecreatefromjpeg($filename);
imagecopyresampled($image_p, $image, 0, 0, 0, 0, $new_width, $new_height, $width, $height);

// Affichage
imagejpeg($image_p, null, 100);
?>

L'exemple ci-dessus va afficher quelque chose de similaire à :

Exemple #2 Redimensionnement proportionnel d'une image

Cet exemple affichera une image avec une largeur ou une hauteur maximale de 200 pixels.


<?php
// Le fichier
$filename = 'test.jpg';

// Définition de la largeur et de la hauteur maximale
$width = 200;
$height = 200;

// Content type
header('Content-type: image/jpeg');

// Cacul des nouvelles dimensions
list($width_orig, $height_orig) = getimagesize($filename);

$ratio_orig = $width_orig/$height_orig;

if ($width/$height > $ratio_orig) {
   $width = $height*$ratio_orig;
} else {
   $height = $width/$ratio_orig;
}

// Redimensionnement
$image_p = imagecreatetruecolor($width, $height);
$image = imagecreatefromjpeg($filename);
imagecopyresampled($image_p, $image, 0, 0, 0, 0, $width, $height, $width_orig, $height_orig);

// Affichage
imagejpeg($image_p, null, 100);
?>

L'exemple ci-dessus va afficher quelque chose de similaire à :

Notes

Note: Il y a un problème dû aux limitations de la taille de la palette (255 + 1 couleurs différentes). Filtrer ou rééchantillonner une image demande plus de 255 couleurs, une approximation est alors utilisée pour calculer le nouveau nombre de couleurs. Avec une palette, si une nouvelle couleur ne peut être allouée, la couleur la plus proche (en théorie) est utilisée. Ce n'est pas toujours la couleur la plus proche visuellement. Cela peut générer des problèmes étranges, comme des images blanches. Pour éviter ce problème, passez en image TrueColor, comme celles générée par la fonction imagecreatetruecolor().

Voir aussi

imagecopyresized()

imagecopyresized

imagecopymergegray

Last updated: Fri, 26 Dec 2008

add a note User Contributed Notes
imagecopyresampled

MBorgPL at gmail dot com
28-Dec-2008 08:53


Another addition to zorroswordsman at gmail dot com's resize class. 



The function takes $_FILES['sent_image'] as 1st parameter. The 2nd is complete destination path. 



It only moves images. 



It returns destination path if succeeded, and false if any error occurred. 



<?php

public function move_image($tmp_img, $dest_img)

{

    //verifies if the uploaded file is an image

    if (strpos($tmp_img['type'], 'image') !== false) 

        {

        //moves the uploaded file into the destination place

        if (move_uploaded_file($tmp_img['tmp_name'], $dest_img)) {

            return $dest_img;

        }

    }        

    return false;

}

?>

MBorg_PL
28-Dec-2008 01:39


Another tiny ammendment to zorroswordsman at gmail dot com's resize class AND matt at rees-jenkins dot co dot uk addition. The class may resize to different width and height not only same ones:



<?php

// Set maximum image size (pixels)

public function set_size($max_x = 100,$max_y = 100)

{

    

    // Resize

    if($this->x_input > $max_x || $this->y_input > $max_y)

    {



        $a= $max_x / $max_y;

        $b= $this->x_input / $this->y_input;

        

        if ($a<$b)

        {



            $this->x_output = $max_x;

            $this->y_output = ($max_x / $this->x_input) * $this->y_input;



        }

        else

        {



            $this->y_output = $max_y;

            $this->x_output = ($max_y / $this->y_input) * $this->x_input;



        }

        // Ready

        

        $this->resize = TRUE;

        

    }

    

    // Don't resize        

    else { $this->resize = FALSE; }

    

}

?>



And the use of the class is now:



<?php



##### DEMO #####



// Image

$src = "myimage.jpg";



// Begin

$img = new imaging;

$img->set_img($src);

$img->set_quality(80);



// Small thumbnail

$img->set_size(250,150);

$img->save_img("small_250x150_" . $src);



// Baby thumbnail

$img->set_size(50,250);

$img->save_img("baby_50x250_" . $src);



// Finalize

$img->clear_cache();



?>

matt at rees-jenkins dot co dot uk
14-Oct-2008 01:32


A tiny ammendment to zorroswordsman at gmail dot com's resize class. It was only resizing if both the width AND height where greater than the desired size. This should fix it:



<?php

// Set maximum image size (pixels)

function set_size($size = 100)

{

    // Resize

    if($this->x_input > $size || $this->y_input > $size)

    {

        // Wide

        if($this->x_input >= $this->y_input)

        {

            $this->x_output = $size;

            $this->y_output = ($this->x_output / $this->x_input) * $this->y_input;

        }

        // Tall

        else

        {

            $this->y_output = $size;

            $this->x_output = ($this->y_output / $this->y_input) * $this->x_input;

        }

        // Ready

        $this->resize = TRUE;

    }

    // Don't resize

    else { $this->resize = FALSE; }

}

?>

zorroswordsman at gmail dot com
25-Sep-2008 05:46


I've created a PHP5 image resize class, using ImageCopyResampled, that someone might find useful, with support for JPEG, PNG, and GIF formats. It retains the original image's aspect ratio when resizing, and doesn't resize or resample if the original width and height is smaller then the desired resize.



<?php



// Imaging

class imaging

{



    // Variables

    private $img_input;

    private $img_output;

    private $img_src;

    private $format;

    private $quality = 80;

    private $x_input;

    private $y_input;

    private $x_output;

    private $y_output;

    private $resize;



    // Set image

    public function set_img($img)

    {



        // Find format

        $ext = strtoupper(pathinfo($img, PATHINFO_EXTENSION));



        // JPEG image

        if(is_file($img) && ($ext == "JPG" OR $ext == "JPEG"))

        {



            $this->format = $ext;

            $this->img_input = ImageCreateFromJPEG($img);

            $this->img_src = $img;

            



        }



        // PNG image

        elseif(is_file($img) && $ext == "PNG")

        {



            $this->format = $ext;

            $this->img_input = ImageCreateFromPNG($img);

            $this->img_src = $img;



        }



        // GIF image

        elseif(is_file($img) && $ext == "GIF")

        {



            $this->format = $ext;

            $this->img_input = ImageCreateFromGIF($img);

            $this->img_src = $img;



        }



        // Get dimensions

        $this->x_input = imagesx($this->img_input);

        $this->y_input = imagesy($this->img_input);



    }



    // Set maximum image size (pixels)

    public function set_size($size = 100)

    {



        // Resize

        if($this->x_input > $size && $this->y_input > $size)

        {



            // Wide

            if($this->x_input >= $this->y_input)

            {



                $this->x_output = $size;

                $this->y_output = ($this->x_output / $this->x_input) * $this->y_input;



            }



            // Tall

            else

            {



                $this->y_output = $size;

                $this->x_output = ($this->y_output / $this->y_input) * $this->x_input;



            }



            // Ready

            $this->resize = TRUE;



        }



        // Don't resize

        else { $this->resize = FALSE; }



    }



    // Set image quality (JPEG only)

    public function set_quality($quality)

    {



        if(is_int($quality))

        {



            $this->quality = $quality;



        }



    }



    // Save image

    public function save_img($path)

    {



        // Resize

        if($this->resize)

        {



            $this->img_output = ImageCreateTrueColor($this->x_output, $this->y_output);

            ImageCopyResampled($this->img_output, $this->img_input, 0, 0, 0, 0, $this->x_output, $this->y_output, $this->x_input, $this->y_input);



        }



        // Save JPEG

        if($this->format == "JPG" OR $this->format == "JPEG")

        {



            if($this->resize) { imageJPEG($this->img_output, $path, $this->quality); }

            else { copy($this->img_src, $path); }



        }



        // Save PNG

        elseif($this->format == "PNG")

        {



            if($this->resize) { imagePNG($this->img_output, $path); }

            else { copy($this->img_src, $path); }



        }



        // Save GIF

        elseif($this->format == "GIF")

        {



            if($this->resize) { imageGIF($this->img_output, $path); }

            else { copy($this->img_src, $path); }



        }



    }



    // Get width

    public function get_width()

    {



        return $this->x_input;



    }



    // Get height

    public function get_height()

    {



        return $this->y_input;



    }



    // Clear image cache

    public function clear_cache()

    {



        @ImageDestroy($this->img_input);

        @ImageDestroy($this->img_output);



    }



}



##### DEMO #####



// Image

$src = "myimage.jpg";



// Begin

$img = new imaging;

$img->set_img($src);

$img->set_quality(80);



// Small thumbnail

$img->set_size(200);

$img->save_img("small_" . $src);



// Baby thumbnail

$img->set_size(50);

$img->save_img("baby_" . $src);



// Finalize

$img->clear_cache();



?>

crash
12-Aug-2008 04:49


The suggestion of converting a gif to a png to retain transparency was useful. However the steps used to maintain the transparency work for a gif as well, so the conversion step is not necessary. Just do everything the same, and save as a gif anyway. i.e.



<?php

$g_iw is new image width

$g_ih is new image height



$img_src=imagecreatefromgif($g_srcfile);

$img_dst=imagecreatetruecolor($g_iw,$g_ih);



//preserve alpha

imagecolortransparent($img_dst, imagecolorallocate($img_dst, 0, 0, 0));

imagealphablending($img_dst, false);

imagesavealpha($img_dst, true);

imagecopyresampled($img_dst, $img_src, 0, 0, 0, 0, $g_iw, $g_ih, $g_is[0], $g_is[1]);



imagegif($img_dst, $g_dstfile); 

imagedestroy($img_dst); 

?>

swizec at swizec dot com
17-Jul-2008 12:20


Wrote a function for sanitising user uploaded images. It saves the native image in size roughly 800x600 so it still fits on most screens when opened, makes a desired size thumbnail and turns all images into high quality jpegs for smaller bandwidth use.



Thumbnails are made in a similar way a designer would make them in photoshop, first resize the most troublesome dimension to desired size, then crop the rest out so the image retains proportions and most of it ends up in the thumbnail.



<?php 



// $image is $_FILES[ <image name> ]

// $imageId is the id used in a database or wherever for this image

// $thumbWidth and $thumbHeight are desired dimensions for the thumbnail

function processImage( $image, $imageId, $thumbWidth, $thumbHeight )

{

    $type = $image[ 'type' ];

    $galleryPath = 'images/collection/';

    

    if ( strpos( $type, 'image/' ) === FALSE )

    { // not an image

        return FALSE;

    }

    $type = str_replace( 'image/', '', $type );

    $createFunc = 'imagecreatefrom' . $type;

    

    $im = $createFunc( $image[ 'tmp_name' ] );

    

    $size = getimagesize( $image[ 'tmp_name' ] );

    

    $w = $size[ 0 ];

    $h = $size[ 1 ];

    if ( $w > 800 || $h > 600 )

    { // we make sure the image isn't too huge

        if ( $w > 800 )

        {

            $nw = 800;

            $nh = ceil( $nw*($h/$w) );

        }elseif( $h > 600 )

        {

            $nh = 600;

            $nw = ceil( $nh*($w/$h) );

        }

        

        $im2 = imagecreatetruecolor( $nw, $nh );

        imagecopyresampled( $im2, $im, 0, 0, 0, 0, $nw, $nh, $w, $h );

        imagedestroy( $im );

        

        $im = $im2;

        $w = $nw;

        $h = $nh;

    }

    

    // create thumbnail

    $tw = $thumbWidth;

    $th = $thumbHeight;

    $imT = imagecreatetruecolor( $tw, $th );

    

    if ( $tw/$th > $th/$tw )

    { // wider

        $tmph = $h*($tw/$w);

        $temp = imagecreatetruecolor( $tw, $tmph );

        imagecopyresampled( $temp, $im, 0, 0, 0, 0, $tw, $tmph, $w, $h ); // resize to width

        imagecopyresampled( $imT, $temp, 0, 0, 0, $tmph/2-$th/2, $tw, $th, $tw, $th ); // crop

        imagedestroy( $temp );

    }else

    { // taller

        $tmpw = $w*($th/$h );

        $imT = imagecreatetruecolor( $tmpw, $th );

        imagecopyresampled( $imT, $im, 0, 0, 0, 0, $tmpw, $h, $w, $h ); // resize to height

        imagecopyresampled( $imT, $temp, 0, 0, $tmpw/2-$tw/2, 0, $tw, $th, $tw, $th ); // crop

        imagedestroy( $temp );

    }

    

    // save the image

    imagejpeg( $im, $galleryPath . $imgid . '.jpg', 100 );

    imagejpeg( $imT, $galleryPath . $imgid . '_thumb.jpg', 100 );

}



?>

mattura gmail com
19-May-2008 08:53


Here's a little function I wrote to resize images to a maximum dimension - based on what facebook does in the galleries. You put in a source, destination and a maximum dimension in pixels (eg 300), and for example if the image is long and thin, the longest edge will be 300px, yet the image retains proportions. A square image will become 300x300, a 6x4 (landscape) will become 300x200, a 4x6 (portrait) - 200x300 etc.

It works on jpg images, but other formats can easily be added.

<?php

function createThumb($spath, $dpath, $maxd) {

 $src=@imagecreatefromjpeg($spath);

 if (!$src) {return false;} else {

  $srcw=imagesx($src);

  $srch=imagesy($src);

  if ($srcw<$srch) {$height=$maxd;$width=floor($srcw*$height/$srch);}

  else {$width=$maxd;$height=floor($srch*$width/$srcw);}

  if ($width>$srcw && $height>$srch) {$width=$srcw;$height=$srch;}  //if image is actually smaller than you want, leave small (remove this line to resize anyway)

  $thumb=imagecreatetruecolor($width, $height);

  if ($height<100) {imagecopyresized($thumb, $src, 0, 0, 0, 0, $width, $height, imagesx($src), imagesy($src));}

  else {imagecopyresampled($thumb, $src, 0, 0, 0, 0, $width, $height, imagesx($src), imagesy($src));}

  imagejpeg($thumb, $dpath);

  return true;

 }

}

?>

bobbyboyojones at hotmail dot com
18-Mar-2008 09:41


I hated that enlarging an image resulted in giant pixels rather than a smoother look, so I wrote this function.  It takes longer, but gives a much nicer look.



<?php



function imagecopyresampledSMOOTH(&$dst_img, &$src_img, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h, $mult=1.25){

    // don't use a $mult that's too close to an int or this function won't make much of a difference



    $tgt_w = round($src_w * $mult);

    $tgt_h = round($src_h * $mult);

    

    // using $mult <= 1 will make the current step w/h smaller (or the same), don't allow this, always resize by at least 1 pixel larger

    if($tgt_w <= $src_w){ $tgt_w += 1; }

    if($tgt_h <= $src_h){ $tgt_h += 1; }

    

    // if the current step w/h is larger than the final height, adjust it back to the final size

    // this check also makes it so that if we are doing a resize to smaller image, it happens in one step (since that's already smooth)

    if($tgt_w > $dst_w){ $tgt_w = $dst_w; }

    if($tgt_h > $dst_h){ $tgt_h = $dst_h; }



    $tmpImg = imagecreatetruecolor($tgt_w, $tgt_h);



    imagecopyresampled($tmpImg, $src_img, 0, 0, $src_x, $src_y, $tgt_w, $tgt_h, $src_w, $src_h);

    imagecopy($dst_img, $tmpImg, $dst_x, $dst_y, 0, 0, $tgt_w, $tgt_h);

    imagedestroy($tmpImg);



    // as long as the final w/h has not been reached, reep on resizing

    if($tgt_w < $dst_w OR $tgt_h < $dst_h){

        imagecopyresampledSMOOTH($dst_img, $dst_img, $dst_x, $dst_y, $dst_x, $dst_y, $dst_w, $dst_h, $tgt_w, $tgt_h, $mult);

    }

}



?>

arnar at netvistun dot is
16-Mar-2008 08:58


A small thumb script. Lets you specify max height and width. The thumb will always be of a rectangular shape while the image itself retains it's proportions. Very clean.



<?php

// The file

$filename = 'a.jpg';



// Set a maximum height and width

$width = 80;

$height = 80;



$thumbsize = 80;



// Content type

header('Content-type: image/jpeg');



// Get new dimensions

list($width_orig, $height_orig) = getimagesize($filename);



$ratio_orig = $width_orig/$height_orig;



if ($width/$height > $ratio_orig) {

   $width = $height*$ratio_orig;

} else {

   $height = $width/$ratio_orig;

}



// Resample

$image_p = imagecreatetruecolor($thumbsize, $thumbsize);

$image = imagecreatefromjpeg($filename);

imagecopyresampled($image_p, $image, -($width/2) + ($thumbsize/2), -($height/2) + ($thumbsize/2), 0, 0, $width, $height, $width_orig, $height_orig);



// Output

imagejpeg($image_p, null, 100);

?>

rayg at daylongraphics dot com
07-Mar-2008 12:45


Here's a simple function to resample one JPEG imagefile to another while keeping aspect ratio of the source within the destination's dimensions. You can also tune the allowable distortion if you end up making too many thumbnails with thin blank areas around them. Should work when enlarging images too. Function returns true if it worked, false if not.



function resample_picfile($src, $dst, $w, $h)

{

    // If distortion stretching is within the range below,

    // then let image be distorted.

    $lowend = 0.8;

    $highend = 1.25;



    $src_img = imagecreatefromjpeg($src);

    if($src_img)

    {

        $dst_img = ImageCreateTrueColor($w, $h);

        /* if you don't want aspect-preserved images 

to have a black bkgnd, fill $dst_img with the color of your choice here. 

        */



        if($dst_img)

        {

            $src_w = imageSX($src_img);

            $src_h = imageSY($src_img);



            $scaleX = (float)$w / $src_w;

            $scaleY = (float)$h / $src_h;

            $scale = min($scaleX, $scaleY);



            $dstW = $w;

            $dstH = $h;

            $dstX = $dstY = 0;



            $scaleR = $scaleX / $scaleY;

            if($scaleR < $lowend || $scaleR > $highend)

            {

                $dstW = (int)($scale * $src_w + 0.5);

                $dstH = (int)($scale * $src_h + 0.5);



                // Keep pic centered in frame.

                $dstX = (int)(0.5 * ($w - $dstW));

                $dstY = (int)(0.5 * ($h - $dstH));

            }

            

            imagecopyresampled(

                $dst_img, $src_img, $dstX, $dstY, 0, 0, 

                $dstW, $dstH, $src_w, $src_h); 

            imagejpeg($dst_img, $dst); 

            imagedestroy($dst_img);

        }

        imagedestroy($src_img);

        return file_exists($dst);

    }

    return false;

}

RandomFeatureRequest
02-Mar-2008 05:51


If anyone felt like implementing Bicubic Sharper and/or Bicubic Smoother, that would seriously rock.

wm at violet dot bg
20-Feb-2008 11:16


This is a fixed version of ImageCopyResampledBicubic posted by liviu.malaescu

The original version wasn't respecting src_x & src_y args



<?php

    function ImageCopyResampledBicubic(&$dst_image, &$src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h)  {

        // we should first cut the piece we are interested in from the source

        $src_img = ImageCreateTrueColor($src_w, $src_h);

        imagecopy($src_img, $src_image, 0, 0, $src_x, $src_y, $src_w, $src_h);



        // this one is used as temporary image

        $dst_img = ImageCreateTrueColor($dst_w, $dst_h);



        ImagePaletteCopy($dst_img, $src_img);

        $rX = $src_w / $dst_w;

        $rY = $src_h / $dst_h;

        $w = 0;

        for ($y = 0; $y < $dst_h; $y++)  {

            $ow = $w; $w = round(($y + 1) * $rY);

            $t = 0;

            for ($x = 0; $x < $dst_w; $x++)  {

                $r = $g = $b = 0; $a = 0;

                $ot = $t; $t = round(($x + 1) * $rX);

                for ($u = 0; $u < ($w - $ow); $u++)  {

                    for ($p = 0; $p < ($t - $ot); $p++)  {

                        $c = ImageColorsForIndex($src_img, ImageColorAt($src_img, $ot + $p, $ow + $u));

                        $r += $c['red'];

                        $g += $c['green'];

                        $b += $c['blue'];

                        $a++;

                    }

                }

                ImageSetPixel($dst_img, $x, $y, ImageColorClosest($dst_img, $r / $a, $g / $a, $b / $a));

            }

        }



        // apply the temp image over the returned image and use the destination x,y coordinates

        imagecopy($dst_image, $dst_img, $dst_x, $dst_y, 0, 0, $dst_w, $dst_h);



        // we should return true since ImageCopyResampled/ImageCopyResized do it

        return true;

    }

?>

Michael Shepanski
15-Jan-2008 08:09


Here is a function I thought I would share that will resample and copy an image with rounded corners.



<?php

/** ------------------------------------------------------------

 * Copy and resample an image with rounded corners.

 * ----------------------------------------------------------- */

function imageRoundedCopyResampled(&$dstimg, &$srcimg, $dstx, $dsty, $srcx,

                                   $srcy, $dstw, $dsth, $srcw, $srch, $radius) {

    # Resize the Source Image

    $srcResized = imagecreatetruecolor($dstw, $dsth);

    imagecopyresampled($srcResized, $srcimg, 0, 0, $srcx, $srcy,

                       $dstw, $dsth, $srcw, $srch);

    # Copy the Body without corners

    imagecopy($dstimg, $srcResized, $dstx+$radius, $dsty,

              $radius, 0, $dstw-($radius*2), $dsth);

    imagecopy($dstimg, $srcResized, $dstx, $dsty+$radius,

              0, $radius, $dstw, $dsth-($radius*2));

    # Create a list of iterations; array(array(X1, X2, CenterX, CenterY), ...)

    # Iterations in order are: Top-Left, Top-Right, Bottom-Left, Bottom-Right

    $iterations = array(

        array(0, 0, $radius, $radius),

        array($dstw-$radius, 0, $dstw-$radius, $radius),

        array(0, $dsth-$radius, $radius, $dsth-$radius),

        array($dstw-$radius, $dsth-$radius, $dstw-$radius, $dsth-$radius)

    );

    # Loop through each corner 'iteration'

    foreach($iterations as $iteration) {

        list($x1,$y1,$cx,$cy) = $iteration;

        for ($y=$y1; $y<=$y1+$radius; $y++) {

            for ($x=$x1; $x<=$x1+$radius; $x++) {

                # If length (X,Y)->(CX,CY) is less then radius draw the point

                $length = sqrt(pow(($cx - $x), 2) + pow(($cy - $y), 2));

                if ($length < $radius) {

                    imagecopy($dstimg, $srcResized, $x+$dstx, $y+$dsty,

                              $x, $y, 1, 1);

                }

            }

        }

    }

}

?>