imagecopyresampled

(PHP 4 >= 4.0.6, PHP 5, PHP 7)

imagecopyresampledCopy and resize part of an image with resampling

Beschreibung

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() copies a rectangular portion of one image to another image, smoothly interpolating pixel values so that, in particular, reducing the size of an image still retains a great deal of clarity.

In other words, imagecopyresampled() will take a rectangular area from src_image of width src_w and height src_h at position (src_x,src_y) and place it in a rectangular area of dst_image of width dst_w and height dst_h at position (dst_x,dst_y).

If the source and destination coordinates and width and heights differ, appropriate stretching or shrinking of the image fragment will be performed. The coordinates refer to the upper left corner. This function can be used to copy regions within the same image (if dst_image is the same as src_image) but if the regions overlap the results will be unpredictable.

Parameter-Liste

dst_image

Resource des Zielbildes.

src_image

Resource des Quellbildes.

dst_x

x-coordinate of destination point.

dst_y

y-coordinate of destination point.

src_x

x-coordinate of source point.

src_y

y-coordinate of source point.

dst_w

Destination width.

dst_h

Destination height.

src_w

Breite der Quelle.

src_h

Höhe der Quelle.

Rückgabewerte

Gibt bei Erfolg TRUE zurück. Im Fehlerfall wird FALSE zurückgegeben.

Beispiele

Beispiel #1 Simple example

This example will resample an image to half its original size.

<?php
// The file
$filename 'test.jpg';
$percent 0.5;

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

// Get new dimensions
list($width$height) = getimagesize($filename);
$new_width $width $percent;
$new_height $height $percent;

// Resample
$image_p imagecreatetruecolor($new_width$new_height);
$image imagecreatefromjpeg($filename);
imagecopyresampled($image_p$image0000$new_width$new_height$width$height);

// Output
imagejpeg($image_pnull100);
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

Output of example : Simple example

Beispiel #2 Resampling an image proportionally

This example will display an image with the maximum width, or height, of 200 pixels.

<?php
// The file
$filename 'test.jpg';

// Set a maximum height and width
$width 200;
$height 200;

// 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($width$height);
$image imagecreatefromjpeg($filename);
imagecopyresampled($image_p$image0000$width$height$width_orig$height_orig);

// Output
imagejpeg($image_pnull100);
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

Output of example : Resampling an image proportionally

Anmerkungen

Hinweis:

There is a problem due to palette image limitations (255+1 colors). Resampling or filtering an image commonly needs more colors than 255, a kind of approximation is used to calculate the new resampled pixel and its color. With a palette image we try to allocate a new color, if that failed, we choose the closest (in theory) computed color. This is not always the closest visual color. That may produce a weird result, like blank (or visually blank) images. To skip this problem, please use a truecolor image as a destination image, such as one created by imagecreatetruecolor().

Siehe auch

imagecopyresized() - Kopieren und Ändern der Größe eines Bild-Teiles

add a note add a note

User Contributed Notes 54 notes

up
147
wbcarts at juno dot com
4 years ago
FOUR RECTANGLES

                  $src_image                                   $dst_image
+------------+---------------------------------+   +------------+--------------------+
|            |                                 |   |            |                    |
|            |                                 |   |         $dst_y                  |
|            |                                 |   |            |                    |
|         $src_y                               |   +-- $dst_x --+----$dst_width----+ |
|            |                                 |   |            |                  | |
|            |                                 |   |            |    Resampled     | |
|            |                                 |   |            |                  | |
+-- $src_x --+------ $src_width ------+        |   |       $dst_height             | |
|            |                        |        |   |            |                  | |
|            |                        |        |   |            |                  | |
|            |                        |        |   |            |                  | |
|            |                        |        |   |            +------------------+ |
|            |        Sample          |        |   |                                 |
|            |                        |        |   |                                 |
|            |                        |        |   |                                 |
|       $src_height                   |        |   |                                 |
|            |                        |        |   +---------------------------------+
|            |                        |        |
|            |                        |        |
|            +------------------------+        |
|                                              |
|                                              |
+----------------------------------------------+
up
54
promaty at gmail dot com
6 years ago
Here is my ultimate image resizer that preserves transparency for gif's and png's and has an option to crop images to fixed dimensions (preserves image proportions by default)

<?php
function image_resize($src, $dst, $width, $height, $crop=0){

  if(!list(
$w, $h) = getimagesize($src)) return "Unsupported picture type!";

 
$type = strtolower(substr(strrchr($src,"."),1));
  if(
$type == 'jpeg') $type = 'jpg';
  switch(
$type){
    case
'bmp': $img = imagecreatefromwbmp($src); break;
    case
'gif': $img = imagecreatefromgif($src); break;
    case
'jpg': $img = imagecreatefromjpeg($src); break;
    case
'png': $img = imagecreatefrompng($src); break;
    default : return
"Unsupported picture type!";
  }

 
// resize
 
if($crop){
    if(
$w < $width or $h < $height) return "Picture is too small!";
   
$ratio = max($width/$w, $height/$h);
   
$h = $height / $ratio;
   
$x = ($w - $width / $ratio) / 2;
   
$w = $width / $ratio;
  }
  else{
    if(
$w < $width and $h < $height) return "Picture is too small!";
   
$ratio = min($width/$w, $height/$h);
   
$width = $w * $ratio;
   
$height = $h * $ratio;
   
$x = 0;
  }

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

 
// preserve transparency
 
if($type == "gif" or $type == "png"){
   
imagecolortransparent($new, imagecolorallocatealpha($new, 0, 0, 0, 127));
   
imagealphablending($new, false);
   
imagesavealpha($new, true);
  }

 
imagecopyresampled($new, $img, 0, 0, $x, 0, $width, $height, $w, $h);

  switch(
$type){
    case
'bmp': imagewbmp($new, $dst); break;
    case
'gif': imagegif($new, $dst); break;
    case
'jpg': imagejpeg($new, $dst); break;
    case
'png': imagepng($new, $dst); break;
  }
  return
true;
}
?>

Example that I use when uploading new images to the server.

This saves the original picture in the form:
original.type

and creates a new thumbnail:
100x100.type

<?php
  $pic_type
= strtolower(strrchr($picture['name'],"."));
 
$pic_name = "original$pic_type";
 
move_uploaded_file($picture['tmp_name'], $pic_name);
  if (
true !== ($pic_error = @image_resize($pic_name, "100x100$pic_type", 100, 100, 1))) {
    echo
$pic_error;
   
unlink($pic_name);
  }
  else echo
"OK!";
?>

Cheers!
up
3
hoangvu4000 at gmail dot com
4 years ago
My complete function to resize an image  with exif data

<?php
function CreateThumbnail($pic,$thumb,$thumbwidth, $quality = 100)
{
        
       
$im1=ImageCreateFromJPEG($pic);
        if(
function_exists("exif_read_data")){
               
$exif = exif_read_data($pic);
                if(!empty(
$exif['Orientation'])) {
                switch(
$exif['Orientation']) {
                case
8:
                   
$im1 = imagerotate($im1,90,0);
                    break;
                case
3:
                   
$im1 = imagerotate($im1,180,0);
                    break;
                case
6:
                   
$im1 = imagerotate($im1,-90,0);
                    break;
                }
                }
        }
       
$info = @getimagesize($pic);
       
       
$width = $info[0];
        
       
$w2=ImageSx($im1);
       
$h2=ImageSy($im1);
       
$w1 = ($thumbwidth <= $info[0]) ? $thumbwidth : $info[0]  ;
        
       
$h1=floor($h2*($w1/$w2));
       
$im2=imagecreatetruecolor($w1,$h1);
        
       
imagecopyresampled ($im2,$im1,0,0,0,0,$w1,$h1,$w2,$h2);
       
$path=addslashes($thumb);
       
ImageJPEG($im2,$path,$quality);
       
ImageDestroy($im1);
       
ImageDestroy($im2);
        
}
?>
up
13
zorroswordsman at gmail dot com
9 years ago
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();

?>
up
3
Anonymous
12 years ago
It should be noted that the imagecopyresampled() function is much more blurry than Photoshop CS's default bicubic funtion. And looks similar to a blury version of Photoshop's bilinear function. The documentation fails to note which algorithm is used in resampling.
up
5
satanas147 at gmail dot com
8 years ago
Another add-on to previous php5 class for thumbnail (with a merge of Matt and Zorro's proposals).
This is dedicated to generate thumbnail on the fly for a webpage using the subclass thumbnail.
It saves the generated thumb as myimage_tn, in the same directory.
I'm quite new with php5, so I think this could be optimized, but it seems to work fine.

<?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($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; }
    }
   
// 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);
    }
}
class
thumbnail extends imaging {
    private
$image;
    private
$width;
    private
$height;
   
    function
__construct($image,$width,$height) {
parent::set_img($image);
parent::set_quality(80);
parent::set_size($width,$height);
           
$this->thumbnail= pathinfo($image, PATHINFO_DIRNAME).pathinfo($image, PATHINFO_FILENAME).'_tn.'.pathinfo($image, PATHINFO_EXTENSION);
parent::save_img($this->thumbnail);
parent::clear_cache();
        }
    function
__toString() {
            return
$this->thumbnail;
    }
}

********
*
DEMO *
********
$thumb = new thumbnail('./image_dir/sub_dir/myimage.jpg',100,100);
echo
'<img src=\''.$thumb.'\' alt=\'myimage\' title=\'myimage\'/>';

   
?>
up
2
wm at violet dot bg
9 years ago
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;
    }
?>
up
3
alex-thennstaett-remove at gmx dot net
5 years ago
Having updated GD-Library from 2.0.35-r1 to 2.0.35-r3 using negative numbers for $dstX or $dstY started to produce unpredictable results, such as inserting shrinked images and enlarging $dstH or $dstW all by itself. While it did work fine previously, one should avoid using or calculating negative numbers for imagecopyresampled from the beginning.
up
2
kazuya
3 years ago
<?php

$new_file
= img_resize("./img/", "test.jpg","copy_test.jpg",300);
echo
"<IMG src = '$new_file'>";

function
img_resize($path,$tmp_name,$new_name,$new_width){
    if (!
file_exists($path.$filename)){
        echo
"file not found!";
        exit;
    }
    if (!
is_writable($path)){
        echo
"error:permission denied!";
        exit;
    }
    list(
$width, $height) = getimagesize($path . $tmp_name);
   
$new_height = abs($new_width * $height / $width);
   
$image_p = imagecreatetruecolor($new_width, $new_height);
   
$image = imagecreatefromjpeg($path . $tmp_name);
   
imagecopyresampled($image_p, $image, 0, 0, 0, 0,
                       
$new_width, $new_height, $width, $height);
   
imagejpeg($image_p, $path . $new_name);
    return
$path.$new_name;
}

?>
up
2
bobbyboyojones at hotmail dot com
9 years ago
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);
    }
}

?>
up
2
fluffle <at> gmail <dot> com
12 years ago
Just to clarify that src_w and src_h do not necessarily need to be the source image width and height, as they specify the size of the rectangle cropped from the source picture, with its top left corner situated at (src_x, src_y).

For example, the code below crops a jpeg image to be square, with the square situated in the centre of the original image, and then resizes it to a 100x100 thumbnail.

list($ow, $oh) = getimagesize($image_filename);
$big = imagecreatefromjpeg($image_filename);
$thumb = imagecreatetruecolor(100,100);
if ($ow > $oh) {
    $off_w = ($ow-$oh)/2;
    $off_h = 0;
    $ow = $oh;
} elseif ($oh > $ow) {
    $off_w = 0;
    $off_h = ($oh-$ow)/2;
    $oh = $ow;
} else {
    $off_w = 0;
    $off_h = 0;
}
imagecopyresampled($thumb, $big, 0, 0, $off_w, $off_h, 100, 100, $ow, $oh);
up
2
seifer at loveletslive dot com
8 years ago
Okay so I saw that others have posted this already but I just messed around and made it so figured I would share it.

Mine works, not to say others don't, I haven't tested them.

This function creates a thumbnail of the specfied size.
If the thumbnail is a different ration it will automatically crop the center of the source image.

It works if the source image is bigger or smaller than the desired "cropped thumbnail."

Here is the code...
<?php
function CroppedThumbnail($imgSrc,$thumbnail_width,$thumbnail_height) { //$imgSrc is a FILE - Returns an image resource.
    //getting the image dimensions 
   
list($width_orig, $height_orig) = getimagesize($imgSrc);  
   
$myImage = imagecreatefromjpeg($imgSrc);
   
$ratio_orig = $width_orig/$height_orig;
   
    if (
$thumbnail_width/$thumbnail_height > $ratio_orig) {
      
$new_height = $thumbnail_width/$ratio_orig;
      
$new_width = $thumbnail_width;
    } else {
      
$new_width = $thumbnail_height*$ratio_orig;
      
$new_height = $thumbnail_height;
    }
   
   
$x_mid = $new_width/2//horizontal middle
   
$y_mid = $new_height/2; //vertical middle
   
   
$process = imagecreatetruecolor(round($new_width), round($new_height));
   
   
imagecopyresampled($process, $myImage, 0, 0, 0, 0, $new_width, $new_height, $width_orig, $height_orig);
   
$thumb = imagecreatetruecolor($thumbnail_width, $thumbnail_height);
   
imagecopyresampled($thumb, $process, 0, 0, ($x_mid-($thumbnail_width/2)), ($y_mid-($thumbnail_height/2)), $thumbnail_width, $thumbnail_height, $thumbnail_width, $thumbnail_height);

   
imagedestroy($process);
   
imagedestroy($myImage);
    return
$thumb;
}

//Create the thumbnail
$newThumb = CroppedThumbnail("MyImageName.jpg",75,100);

// And display the image...
header('Content-type: image/jpeg');
imagejpeg($newThumb);
?>
up
2
sam at durosoft.com
4 years ago
The ultimate smart image re-sizing routine. You provide the original image, and a desired width and/or height. The function will intelligently re-size the original image to fit, centered, within the specified dimensions. Either width or height can be omitted to have the re-size "lock" only on width or height. Fantastic for thumbnail generation. Designed to work with PNG's.

function resize_image_smart($orig, $dest_width=null, $dest_height=null)
{
  $orig_width = imagesx($orig);
  $orig_height = imagesy($orig);
  $vertical_offset = 0;
  $horizontal_offset = 0;
  if($dest_width == null)
  {
    if($dest_height == null)
    {
      die('$dest_width and $dest_height cant both be null!');
    }
    // height is locked
    $dest_width = $dest_height * $orig_width / $orig_height;
  } else {
    if($dest_height == null)
    {
      // width is locked
      $dest_height = $dest_width * $orig_height / $orig_width;
    } else {
      // both dimensions are locked
      $vertical_offset = $dest_height - ($orig_height * $dest_width) / $orig_width;
      $horizontal_offset = $dest_width - ($dest_height * $orig_width) / $orig_height;
      if($vertical_offset < 0) $vertical_offset = 0;
      if($horizontal_offset < 0) $horizontal_offset = 0;
    }
  }
  $img = imagecreatetruecolor($dest_width, $dest_height);
  imagesavealpha($img, true);
  imagealphablending($img, false);
  $transparent = imagecolorallocatealpha($img, 0, 0, 0, 127);
  imagefill($img, 0, 0, $transparent);
  imagecopyresampled($img, $orig, round($horizontal_offset / 2),
                                  round($vertical_offset / 2),
                                  0,
                                  0,
                                  round($dest_width - $horizontal_offset),
                                  round($dest_height - $vertical_offset),
                                  $orig_width,
                                  $orig_height);
  return $img;
}
up
1
z3n666 at gmail dot com
8 years ago
I was looking around and couldn't find a function that resizes images to any ratio without leaving a blank area, so i wrote this one. It's able to resize images to any size ratio, when the ratio is no match with the original it will crop proportional area on the original and resize it.

<?php

function _ckdir($fn) {
    if (
strpos($fn,"/") !== false) {
       
$p=substr($fn,0,strrpos($fn,"/"));
        if (!
is_dir($p)) {
           
_o("Mkdir: ".$p);
           
mkdir($p,777,true);
        }
    }
}
function
img_resizer($src,$quality,$w,$h,$saveas) {
   
/* v2.5 with auto crop */
   
$r=1;
   
$e=strtolower(substr($src,strrpos($src,".")+1,3));
    if ((
$e == "jpg") || ($e == "peg")) {
       
$OldImage=ImageCreateFromJpeg($src) or $r=0;
    } elseif (
$e == "gif") {
       
$OldImage=ImageCreateFromGif($src) or $r=0;
    } elseif (
$e == "bmp") {
       
$OldImage=ImageCreateFromwbmp($src) or $r=0;
    } elseif (
$e == "png") {
       
$OldImage=ImageCreateFromPng($src) or $r=0;
    } else {
       
_o("Not a Valid Image! (".$e.") -- ".$src);$r=0;
    }
    if (
$r) {
        list(
$width,$height)=getimagesize($src);
       
// check if ratios match
       
$_ratio=array($width/$height,$w/$h);
        if (
$_ratio[0] != $_ratio[1]) { // crop image

            // find the right scale to use
           
$_scale=min((float)($width/$w),(float)($height/$h));

           
// coords to crop
           
$cropX=(float)($width-($_scale*$w));
           
$cropY=(float)($height-($_scale*$h));   
           
           
// cropped image size
           
$cropW=(float)($width-$cropX);
           
$cropH=(float)($height-$cropY);
           
           
$crop=ImageCreateTrueColor($cropW,$cropH);
           
// crop the middle part of the image to fit proportions
           
ImageCopy(
               
$crop,
               
$OldImage,
               
0,
               
0,
                (int)(
$cropX/2),
                (int)(
$cropY/2),
               
$cropW,
               
$cropH
           
);
        }
       
       
// do the thumbnail
       
$NewThumb=ImageCreateTrueColor($w,$h);
        if (isset(
$crop)) { // been cropped
           
ImageCopyResampled(
               
$NewThumb,
               
$crop,
               
0,
               
0,
               
0,
               
0,
               
$w,
               
$h,
               
$cropW,
               
$cropH
           
);
           
ImageDestroy($crop);
        } else {
// ratio match, regular resize
           
ImageCopyResampled(
               
$NewThumb,
               
$OldImage,
               
0,
               
0,
               
0,
               
0,
               
$w,
               
$h,
               
$width,
               
$height
           
);
        }
       
_ckdir($saveas);
       
ImageJpeg($NewThumb,$saveas,$quality);
       
ImageDestroy($NewThumb);
       
ImageDestroy($OldImage);
    }
    return
$r;
}

?>
up
1
areddan at silverarm dot ie
11 years ago
<?php
// The file
$filein = ''; // File in
$fileout = 'ttt.gif'; // Fileout - optional

$imagethumbsize_w = 100; // thumbnail size (area cropped in middle of image)
$imagethumbsize_h = 75; // thumbnail size (area cropped in middle of image)
resize_then_crop( $filein,$fileout,$imagethumbsize_w,
$imagethumbsize_h,/*rgb*/"255","255","255");

//Author Alan Reddan Silverarm Solutions
//Date 27/01/2005
//Function that works well with images.
//It takes the image and reduces its size to best fit. i.e If you have an image
//that is 200 X 100 and you want a thumbnail of 75 X 50,
//it first resizes the image to 100 X 50
//and then takes out a portion 75 X 50 from then center of the input image.
//So loads of image information is retained.
//The corollary also holds if your input image is 100 X 200
//it first resizes image to 75 X 150 and then takes out a
//portion 75 X 75 from the centre
// The advantage here is that function decides on whether
//resize is by width or height itself.
//it also decides whether to use the height or the width as the base start point
//in the case that athumbnail is rectangular

function resize_then_crop( $filein,$fileout,
$imagethumbsize_w,$imagethumbsize_h,$red,$green,$blue)
{

// Get new dimensions
list($width, $height) = getimagesize($filein);
$new_width = $width * $percent;
$new_height = $height * $percent;

   if(
preg_match("/.jpg/i", "$filein"))
   {
      
$format = 'image/jpeg';
   }
   if (
preg_match("/.gif/i", "$filein"))
   {
      
$format = 'image/gif';
   }
   if(
preg_match("/.png/i", "$filein"))
   {
      
$format = 'image/png';
   }
  
       switch(
$format)
       {
           case
'image/jpeg':
          
$image = imagecreatefromjpeg($filein);
           break;
           case
'image/gif';
          
$image = imagecreatefromgif($filein);
           break;
           case
'image/png':
          
$image = imagecreatefrompng($filein);
           break;
       }

$width = $imagethumbsize_w ;
$height = $imagethumbsize_h ;
list(
$width_orig, $height_orig) = getimagesize($filein);

if (
$width_orig < $height_orig) {
 
$height = ($imagethumbsize_w / $width_orig) * $height_orig;
} else {
   
$width = ($imagethumbsize_h / $height_orig) * $width_orig;
}

if (
$width < $imagethumbsize_w)
//if the width is smaller than supplied thumbnail size
{
$width = $imagethumbsize_w;
$height = ($imagethumbsize_w/ $width_orig) * $height_orig;;
}

if (
$height < $imagethumbsize_h)
//if the height is smaller than supplied thumbnail size
{
$height = $imagethumbsize_h;
$width = ($imagethumbsize_h / $height_orig) * $width_orig;
}

$thumb = imagecreatetruecolor($width , $height); 
$bgcolor = imagecolorallocate($thumb, $red, $green, $blue);  
ImageFilledRectangle($thumb, 0, 0, $width, $height, $bgcolor);
imagealphablending($thumb, true);

imagecopyresampled($thumb, $image, 0, 0, 0, 0,
$width, $height, $width_orig, $height_orig);
$thumb2 = imagecreatetruecolor($imagethumbsize_w , $imagethumbsize_h);
// true color for best quality
$bgcolor = imagecolorallocate($thumb2, $red, $green, $blue);  
ImageFilledRectangle($thumb2, 0, 0,
$imagethumbsize_w , $imagethumbsize_h , $white);
imagealphablending($thumb2, true);

$w1 =($width/2) - ($imagethumbsize_w/2);
$h1 = ($height/2) - ($imagethumbsize_h/2);

imagecopyresampled($thumb2, $thumb, 0,0, $w1, $h1,
$imagethumbsize_w , $imagethumbsize_h ,$imagethumbsize_w, $imagethumbsize_h);

// Output
//header('Content-type: image/gif');
//imagegif($thumb); //output to brow