web-dev-qa-db-de.com

Ändern Sie die Bildgröße in PHP

Ich möchte einen PHP Code schreiben, der die Größe aller über ein Formular hochgeladenen Bilder automatisch auf 147x147px ändert, aber ich habe keine Ahnung, wie ich vorgehen soll (ich bin ein relativer PHP Neuling).

Bisher wurden Bilder erfolgreich hochgeladen, Dateitypen erkannt und Namen bereinigt, aber ich möchte die Größenänderungsfunktion in den Code einfügen. Ich habe zum Beispiel ein Test-Image mit einer Größe von 2,3 MB und 1331 x 1331 und möchte, dass der Code die Größe des Images verringert. Ich gehe davon aus, dass dies auch die Dateigröße des Images dramatisch komprimieren wird.

Bisher habe ich Folgendes:

if ($_FILES) {
                //Put file properties into variables
                $file_name = $_FILES['profile-image']['name'];
                $file_size = $_FILES['profile-image']['size'];
                $file_tmp_name = $_FILES['profile-image']['tmp_name'];

                //Determine filetype
                switch ($_FILES['profile-image']['type']) {
                    case 'image/jpeg': $ext = "jpg"; break;
                    case 'image/png': $ext = "png"; break;
                    default: $ext = ''; break;
                }

                if ($ext) {
                    //Check filesize
                    if ($file_size < 500000) {
                        //Process file - clean up filename and move to safe location
                        $n = "$file_name";
                        $n = ereg_replace("[^A-Za-z0-9.]", "", $n);
                        $n = strtolower($n);
                        $n = "avatars/$n";
                        move_uploaded_file($file_tmp_name, $n);
                    } else {
                        $bad_message = "Please ensure your chosen file is less than 5MB.";
                    }
                } else {
                    $bad_message = "Please ensure your image is of filetype .jpg or.png.";
                }
            }
$query = "INSERT INTO users (image) VALUES ('$n')";
mysql_query($query) or die("Insert failed. " . mysql_error() . "<br />" . $query);
69
Alex Ryans

Sie müssen entweder die Funktionen ImageMagick oder Gd von PHP verwenden, um mit Bildern zu arbeiten.

Mit Gd zum Beispiel ist es so einfach wie ...

function resize_image($file, $w, $h, $crop=FALSE) {
    list($width, $height) = getimagesize($file);
    $r = $width / $height;
    if ($crop) {
        if ($width > $height) {
            $width = ceil($width-($width*abs($r-$w/$h)));
        } else {
            $height = ceil($height-($height*abs($r-$w/$h)));
        }
        $newwidth = $w;
        $newheight = $h;
    } else {
        if ($w/$h > $r) {
            $newwidth = $h*$r;
            $newheight = $h;
        } else {
            $newheight = $w/$r;
            $newwidth = $w;
        }
    }
    $src = imagecreatefromjpeg($file);
    $dst = imagecreatetruecolor($newwidth, $newheight);
    imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);

    return $dst;
}

Und diese Funktion könnte man so nennen ...

$img = resize_image(‘/path/to/some/image.jpg’, 200, 200);

Aus persönlicher Erfahrung reduziert das Resampling von Gd-Bildern auch die Dateigröße erheblich, insbesondere beim Resampling von rohen Digitalkamerabildern.

121
Gordon Freeman

Diese Ressource ist auch eine Überlegung wert - ein sehr aufgeräumter Code, der Gd verwendet. Ich habe jedoch das endgültige Code-Snippet geändert, um diese Funktion zu erstellen, die die Anforderungen des OPs erfüllt ...

function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {

    $target_dir = "your-uploaded-images-folder/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);

    $image = new SimpleImage();
    $image->load($_FILES[$html_element_name]['tmp_name']);
    $image->resize($new_img_width, $new_img_height);
    $image->save($target_file);
    return $target_file; //return name of saved file in case you want to store it in you database or show confirmation message to user

}

Sie müssen auch diese PHP file ...

<?php

/*
* File: SimpleImage.php
* Author: Simon Jarvis
* Copyright: 2006 Simon Jarvis
* Date: 08/11/06
* Link: http://www.white-hat-web-design.co.uk/blog/resizing-images-with-php/
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
* http://www.gnu.org/licenses/gpl.html
*
*/

class SimpleImage {

   var $image;
   var $image_type;

   function load($filename) {

      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {

         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {

         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {

         $this->image = imagecreatefrompng($filename);
      }
   }
   function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image,$filename);
      }
      if( $permissions != null) {

         chmod($filename,$permissions);
      }
   }
   function output($image_type=IMAGETYPE_JPEG) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image);
      }
   }
   function getWidth() {

      return imagesx($this->image);
   }
   function getHeight() {

      return imagesy($this->image);
   }
   function resizeToHeight($height) {

      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }

   function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }

   function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }

   function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }      

}
?>
17

Wenn Sie sich nicht für das Seitenverhältnis interessieren (d. H. Sie möchten das Bild auf eine bestimmte Dimension zwingen), finden Sie hier eine vereinfachte Antwort

// for jpg 
function resize_imagejpg($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromjpeg($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

 // for png
function resize_imagepng($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefrompng($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

// for gif
function resize_imagegif($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromgif($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

Lassen Sie uns nun den Upload-Teil behandeln. Laden Sie zunächst die Datei in das gewünschte Verzeichnis hoch. Rufen Sie dann eine der oben genannten Funktionen basierend auf dem Dateityp (jpg, png oder gif) auf und übergeben Sie den absoluten Pfad Ihrer hochgeladenen Datei wie folgt:

 // jpg  change the dimension 750, 450 to your desired values
 $img = resize_imagejpg('path/image.jpg', 750, 450);

Der Rückgabewert $img ist ein Ressourcenobjekt. Wir können an einem neuen Ort speichern oder das Original wie folgt überschreiben:

 // again for jpg
 imagejpeg($img, 'path/newimage.jpg');

Hoffe das hilft jemandem. Weitere Informationen zum Ändern der Größe finden Sie unter Imagick :: resizeImage und imagejpeg ()

11
Tunde Michael

Benutze einfach die PHP-Funktion: gegeben als

// Read the image
$img = imagecreatefromjpeg("source_of_img.jpg");

// Now resize the image width = 200 and height = 200
$imgresize = imagescale($img, 200, 200);
6
M Abdullah

Ich hoffe, es wird für Sie arbeiten.

/**
         * Image re-size
         * @param int $width
         * @param int $height
         */
        function ImageResize($width, $height, $img_name)
        {
                /* Get original file size */
                list($w, $h) = getimagesize($_FILES['logo_image']['tmp_name']);


                /*$ratio = $w / $h;
                $size = $width;

                $width = $height = min($size, max($w, $h));

                if ($ratio < 1) {
                    $width = $height * $ratio;
                } else {
                    $height = $width / $ratio;
                }*/

                /* Calculate new image size */
                $ratio = max($width/$w, $height/$h);
                $h = ceil($height / $ratio);
                $x = ($w - $width / $ratio) / 2;
                $w = ceil($width / $ratio);
                /* set new file name */
                $path = $img_name;


                /* Save image */
                if($_FILES['logo_image']['type']=='image/jpeg')
                {
                    /* Get binary data from image */
                    $imgString = file_get_contents($_FILES['logo_image']['tmp_name']);
                    /* create image from string */
                    $image = imagecreatefromstring($imgString);
                    $tmp = imagecreatetruecolor($width, $height);
                    imagecopyresampled($tmp, $image, 0, 0, $x, 0, $width, $height, $w, $h);
                    imagejpeg($tmp, $path, 100);
                }
                else if($_FILES['logo_image']['type']=='image/png')
                {
                    $image = imagecreatefrompng($_FILES['logo_image']['tmp_name']);
                    $tmp = imagecreatetruecolor($width,$height);
                    imagealphablending($tmp, false);
                    imagesavealpha($tmp, true);
                    imagecopyresampled($tmp, $image,0,0,$x,0,$width,$height,$w, $h);
                    imagepng($tmp, $path, 0);
                }
                else if($_FILES['logo_image']['type']=='image/gif')
                {
                    $image = imagecreatefromgif($_FILES['logo_image']['tmp_name']);

                    $tmp = imagecreatetruecolor($width,$height);
                    $transparent = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                    imagefill($tmp, 0, 0, $transparent);
                    imagealphablending($tmp, true); 

                    imagecopyresampled($tmp, $image,0,0,0,0,$width,$height,$w, $h);
                    imagegif($tmp, $path);
                }
                else
                {
                    return false;
                }

                return true;
                imagedestroy($image);
                imagedestroy($tmp);
        }
5
Er.gaurav soni

( [~ # ~] wichtig [~ # ~] : Bei Animationen (animiertes Webp oder GIF) wird die Größe nicht geändert animiertes, aber verkleinertes Bild ab dem ersten Frame! (Die ursprüngliche Animation bleibt erhalten ...)

Ich habe dies für mein php 7.2 Projekt erstellt (Beispiel imagebmp sure (PHP 7> = 7.2.0): php/manual/function. imagebmp ) about techfry.com/php-tutorial , mit Gd2 (also nichts für Bibliotheken von Drittanbietern) und sehr ähnlich der Antwort von Nico Bistolfi, funktioniert aber mit allen fünf grundlegenden Bildmimetypen ( png, jpeg, webp, bmp und gif ) Erstellen einer neuen Datei mit geänderter Größe, ohne die ursprüngliche Datei zu ändern, und das gesamte Material in einer Funktion und gebrauchsfertig (kopieren und in Ihr Projekt einfügen). (Sie können die Erweiterung der neuen Datei mit dem fünften Parameter festlegen oder sie einfach belassen, wenn Sie das Original behalten möchten.):

function createResizedImage(
    string $imagePath = '',
    string $newPath = '',
    int $newWidth = 0,
    int $newHeight = 0,
    string $outExt = 'DEFAULT'
) : ?string
{
    if (
        $newPath === '' or
        file_exists($imagePath) === false
    ) {
        return null;
    }

    if (
        in_array(
            (
                $type = exif_imagetype($imagePath)
            ),
            [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_GIF, IMAGETYPE_BMP, IMAGETYPE_WEBP]
        ) === false
    ) {
        return null;
    }

    list($width, $height) = getimagesize($imagePath);

    $outBool = in_array($outExt, ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']);

    switch (true)
    {
        case  $type === IMAGETYPE_JPEG:
            $image = imagecreatefromjpeg($imagePath);
            if ($outBool === false) $outExt = 'jpg';
            break;
        case $type === IMAGETYPE_PNG:
            $image = imagecreatefrompng($imagePath);
            if ($outBool === false) $outExt = 'png';
            break;
        case $type === IMAGETYPE_GIF:
            $image = imagecreatefromgif($imagePath);
            if ($outBool === false) $outExt = 'gif';
            break;
        case $type === IMAGETYPE_BMP:
            $image = imagecreatefrombmp($imagePath);
            if ($outBool === false) $outExt = 'bmp';
            break;
        case $type === IMAGETYPE_WEBP:
            $image = imagecreatefromwebp($imagePath);
            if ($outBool === false) $outExt = 'webp';
    }

    $newImage = imagecreatetruecolor($newWidth, $newHeight);

    //TRANSPARENT BACKGROUND
    $color = imagecolorallocatealpha($newImage, 0, 0, 0, 127); //fill transparent back
    imagefill($newImage, 0, 0, $color);
    imagesavealpha($newImage, true);

    //ROUTINE
    imagecopyresampled($newImage, $image, 0, 0, 0, 0, $newWidth, $newHeight, $width, $height);

    switch (true)
    {
        case in_array($outExt, ['jpg', 'jpeg']) === true: $success = imagejpeg($newImage, $newPath);
            break;
        case $outExt === 'png': $success = imagepng($newImage, $newPath);
            break;
        case $outExt === 'gif': $success = imagegif($newImage, $newPath);
            break;
        case  $outExt === 'bmp': $success = imagebmp($newImage, $newPath);
            break;
        case  $outExt === 'webp': $success = imagewebp($newImage, $newPath);
    }

    if ($success === false)
    {
        return null;
    }

    return $newPath;
}
2
danigore

Ich habe eine benutzerfreundliche Bibliothek zur Größenänderung von Bildern erstellt. Es kann gefunden werden hier auf Github .

Ein Beispiel für die Verwendung der Bibliothek:

// Include PHP Image Magician library
require_once('php_image_magician.php');

// Open JPG image
$magicianObj = new imageLib('racecar.jpg');

// Resize to best fit then crop (check out the other options)
$magicianObj -> resizeImage(100, 200, 'crop');

// Save resized image as a PNG (or jpg, bmp, etc)
$magicianObj -> saveImage('racecar_small.png');

Weitere Funktionen, falls Sie sie benötigen, sind:

  • Schnelle und einfache Größenänderung - Ändern Sie die Größe auf Querformat, Hochformat oder Automatisch
  • Einfache Ernte
  • Text hinzufügen
  • Qualitätsanpassung
  • Wasserzeichen
  • Schatten und Reflexionen
  • Transparenzunterstützung
  • EXIF-Metadaten lesen
  • Ränder, abgerundete Ecken, Drehung
  • Filter und Effekte
  • Bildschärfe
  • Bildtypkonvertierung
  • BMP-Unterstützung
2
Jarrod

Ich habe einen mathematischen Weg gefunden, um diesen Job zu erledigen

Github repo - https://github.com/gayanSandamal/easy-php-image-resizer

Live-Beispiel - https://plugins.nayague.com/easy-php-image-resizer/

<?php
//path for the image
$source_url = '2018-04-01-1522613288.PNG';

//separate the file name and the extention
$source_url_parts = pathinfo($source_url);
$filename = $source_url_parts['filename'];
$extension = $source_url_parts['extension'];

//define the quality from 1 to 100
$quality = 10;

//detect the width and the height of original image
list($width, $height) = getimagesize($source_url);
$width;
$height;

//define any width that you want as the output. mine is 200px.
$after_width = 200;

//resize only when the original image is larger than expected with.
//this helps you to avoid from unwanted resizing.
if ($width > $after_width) {

    //get the reduced width
    $reduced_width = ($width - $after_width);
    //now convert the reduced width to a percentage and round it to 2 decimal places
    $reduced_radio = round(($reduced_width / $width) * 100, 2);

    //ALL GOOD! let's reduce the same percentage from the height and round it to 2 decimal places
    $reduced_height = round(($height / 100) * $reduced_radio, 2);
    //reduce the calculated height from the original height
    $after_height = $height - $reduced_height;

    //Now detect the file extension
    //if the file extension is 'jpg', 'jpeg', 'JPG' or 'JPEG'
    if ($extension == 'jpg' || $extension == 'jpeg' || $extension == 'JPG' || $extension == 'JPEG') {
        //then return the image as a jpeg image for the next step
        $img = imagecreatefromjpeg($source_url);
    } elseif ($extension == 'png' || $extension == 'PNG') {
        //then return the image as a png image for the next step
        $img = imagecreatefrompng($source_url);
    } else {
        //show an error message if the file extension is not available
        echo 'image extension is not supporting';
    }

    //HERE YOU GO :)
    //Let's do the resize thing
    //imagescale([returned image], [width of the resized image], [height of the resized image], [quality of the resized image]);
    $imgResized = imagescale($img, $after_width, $after_height, $quality);

    //now save the resized image with a suffix called "-resized" and with its extension. 
    imagejpeg($imgResized, $filename . '-resized.'.$extension);

    //Finally frees any memory associated with image
    //**NOTE THAT THIS WONT DELETE THE IMAGE
    imagedestroy($img);
    imagedestroy($imgResized);
}
?>
1
Gayan Sandamal

Sie können es mit TinyPNG versuchen PHP= library. Mit dieser Bibliothek wird Ihr Bild während des Größenänderungsprozesses automatisch optimiert. Alles, was Sie zum Installieren der Bibliothek und Abrufen eines API-Schlüssels von https: //tinypng.com/developers . Führen Sie den folgenden Befehl aus, um eine Bibliothek zu installieren.

composer require tinify/tinify

Danach lautet Ihr Code wie folgt.

require_once("vendor/autoload.php");

\Tinify\setKey("YOUR_API_KEY");

$source = \Tinify\fromFile("large.jpg"); //image to be resize
$resized = $source->resize(array(
    "method" => "fit",
    "width" => 150,
    "height" => 100
));
$resized->toFile("thumbnail.jpg"); //resized image

Ich habe einen Blog zum selben Thema geschrieben http://artisansweb.net/resize-image-php-using-tinypng

1
Sajid Sayyad

ZF-Kuchen:

<?php

class FkuController extends Zend_Controller_Action {

  var $image;
  var $image_type;

  public function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {

    $target_dir = APPLICATION_PATH  . "/../public/1/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);

    //$image = new SimpleImage();
    $this->load($_FILES[$html_element_name]['tmp_name']);
    $this->resize($new_img_width, $new_img_height);
    $this->save($target_file);
    return $target_file; 
    //return name of saved file in case you want to store it in you database or show confirmation message to user



  public function load($filename) {

      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {

         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {

         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {

         $this->image = imagecreatefrompng($filename);
      }
   }
  public function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image,$filename);
      }
      if( $permissions != null) {

         chmod($filename,$permissions);
      }
   }
  public function output($image_type=IMAGETYPE_JPEG) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image);
      }
   }
  public function getWidth() {

      return imagesx($this->image);
   }
  public function getHeight() {

      return imagesy($this->image);
   }
  public function resizeToHeight($height) {

      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }

  public function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }

  public function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }

  public function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }

  public function savepicAction() {
    ini_set('display_errors', 1);
    ini_set('display_startup_errors', 1);
    error_reporting(E_ALL);

    $this->_helper->layout()->disableLayout();
    $this->_helper->viewRenderer->setNoRender();
    $this->_response->setHeader('Access-Control-Allow-Origin', '*');

    $this->db = Application_Model_Db::db_load();        
    $ouser = $_POST['ousername'];


      $fdata = 'empty';
      if (isset($_FILES['picture']) && $_FILES['picture']['size'] > 0) {
        $file_size = $_FILES['picture']['size'];
        $tmpName  = $_FILES['picture']['tmp_name'];  

        //Determine filetype
        switch ($_FILES['picture']['type']) {
            case 'image/jpeg': $ext = "jpg"; break;
            case 'image/png': $ext = "png"; break;
            case 'image/jpg': $ext = "jpg"; break;
            case 'image/bmp': $ext = "bmp"; break;
            case 'image/gif': $ext = "gif"; break;
            default: $ext = ''; break;
        }

        if($ext) {
          //if($file_size<400000) {  
            $img = $this->store_uploaded_image('picture', 90,82);
            //$fp      = fopen($tmpName, 'r');
            $fp = fopen($img, 'r');
            $fdata = fread($fp, filesize($tmpName));        
            $fdata = base64_encode($fdata);
            fclose($fp);

          //}
        }

      }

      if($fdata=='empty'){

      }
      else {
        $this->db->update('users', 
          array(
            'picture' => $fdata,             
          ), 
          array('username=?' => $ouser ));        
      }



  }  
1
YumYumYum

Ich würde Ihnen empfehlen, piio.co zu verwenden. Sobald Sie Ihre Bilder in Ihren Speicher hochgeladen haben, verwenden Sie einfach die ursprüngliche Bild-URL in Ihrem <img /> - Tag und Die Bibliothek übernimmt automatisch die Größenänderung für Sie.

Ihr Bild-Tag sieht folgendermaßen aus:

<img data-piio="/image/gallery/p/image1.jpg" />

Sobald Sie Piios Skript initialisieren, wird die Größe des Abbilds automatisch geändert und von einem CDN bereitgestellt.

Hier ist ein Link zu docs

Wenn Sie es manuell tun möchten , dann empfehle ich, dass Sie die nativen PHP-Funktionen verwenden, dies wird die Gd-Bibliothek verwenden. Wenn Sie beispielsweise die Größe eines JPEG ändern möchten, können Sie mit Folgendem beginnen:

list($width, $height) = getimagesize($filepath);
$original = imagecreatefromjpeg($filepath);
$thumb    = imagecreatetruecolor($new_width, $new_height);
imagecopyresized($thumb, $original, 0, 0, 0, 0, $new_width, $new_height, $width, $height);

So geben Sie das Bild direkt aus:

imagejpeg($thumb);

So speichern Sie das Bild in einer Datei:

imagejpeg($thumb, 'filepath/image.jpg');

1
Nico Bistolfi