Ändern Sie die Bildgröße in PHP

92

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

Bisher wurden Bilder erfolgreich hochgeladen, Dateitypen wurden erkannt und Namen bereinigt, aber ich möchte die Größenänderungsfunktion in den Code aufnehmen. Zum Beispiel habe ich ein Testbild mit einer Größe von 2,3 MB und einer Größe von 1331 x 1331, und ich möchte, dass der Code verkleinert wird, was meiner Meinung nach auch die Dateigröße des Bildes drastisch komprimiert.

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);
Alex Ryans
quelle
Haben Sie Beispiele wie diese stackoverflow.com/questions/10029838/image-resize-with-php ausprobiert ?
Coenie Richards
ohne den Wechsel upload_max_filesizein php.inierstens ist es möglich , die Datei mit einer Größe mehr als zu laden upload_max_filesize?. Gibt es eine Möglichkeit, die Größe des Bildes größer als zu ändern upload_max_filesize? ohne Änderung upload_max_filesizeinphp.ini
rch

Antworten:

138

Sie müssen entweder die ImageMagick- oder GD- Funktionen 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 Sie könnten diese Funktion so aufrufen ...

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

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

Ian Atkin
quelle
Vielen Dank! Vergib mir meine Unwissenheit, aber wo würde das in dem Code sitzen, den ich bereits habe, und wo würde der Funktionsaufruf sitzen? Habe ich Recht, wenn ich meine Datenbank INSERT habe, anstatt $ n einzufügen, würde ich $ img einfügen? Oder wäre $ n strukturiert $ n = ($ img = resize_image ('/ path / to / some / image.jpg', 200, 200))?
Alex Ryans
1
Speichern Sie Bilder als BLOBs? Ich würde empfehlen, Bilder im Dateisystem zu speichern und Referenzen in Ihre Datenbank einzufügen. Ich empfehle außerdem, die vollständige GD- (oder ImageMagick-) Dokumentation zu lesen, um zu sehen, welche anderen Optionen Ihnen zur Verfügung stehen.
Ian Atkin
17
Beachten Sie, dass diese Lösung nur für JPEGs funktioniert. Sie können imagecreatefromjpeg durch eines der folgenden Elemente ersetzen: imagecreatefromgd, imagecreatefromgif, imagecreatefrompng, imagecreatefromstring, imagecreatefromwbmp, imagecreatefromxbm, imagecreatefromxpm, um mit verschiedenen Bildtypen umzugehen.
Chris Hanson
2
@GordonFreeman Vielen Dank für das großartige Code-Snippet, aber es gibt einen Fehler, der dem Höhenbereich hinzugefügt abs()wird ceil($width-($width*abs($r-$w/$h))). Es wird in einigen Fällen benötigt.
Arman P.
4
Um das verkleinerte Bild im Dateisystem zu speichern, fügen Sie es imagejpeg($dst, $file);nach der imagecopyresampled($dst,...Zeile hinzu. Ändern $fileSie, wenn Sie das Original nicht überschreiben möchten.
wkille
22

Diese Ressource (defekter Link) ist ebenfalls eine Überlegung wert - ein sehr ordentlicher Code, der GD verwendet. Ich habe jedoch das endgültige Code-Snippet geändert, um diese Funktion zu erstellen, die den Anforderungen des OP entspricht ...

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-Datei einschließen ...

<?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;
   }      
 
}
?>
Ban-Geoengineering
quelle
1
Ihre Probe ist die beste. Es funktioniert direkt im Zend-Framework, ohne Comedy, Drama oder Haare ziehen zu müssen. Daumen hoch
Ich denke, der gesamte Code, den Sie benötigen, sollte in meiner Antwort enthalten sein, aber dies kann auch helfen: gist.github.com/arrowmedia/7863973 .
Ban-Geoengineering
17

Einfache PHP-Funktion verwenden ( Bildskala ):

Syntax:

imagescale ( $image , $new_width , $new_height )

Beispiel:

Schritt: 1 Lesen Sie die Datei

$image_name =  'path_of_Image/Name_of_Image.jpg|png';      

Schritt: 2: Laden Sie die Bilddatei

 $image = imagecreatefromjpeg($image_name); // For JPEG
//or
 $image = imagecreatefrompng($image_name);   // For PNG

Schritt: 3: Unser Lebensretter kommt in '_' | Skalieren Sie das Bild

   $imgResized = imagescale($image , 500, 400); // width=500 and height = 400
//  $imgResized is our final product

Hinweis: Die Bildskala funktioniert für (PHP 5> = 5.5.0, PHP 7)

Quelle: Klicken Sie hier, um mehr zu lesen

M Abdullah
quelle
Beste Lösung für PHP 5.6.3>
Pattycake Jr
12

Wenn Sie sich nicht für das Seitenverhältnis interessieren (dh das Bild auf eine bestimmte Dimension erzwingen möchten), 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 im ersten Schritt 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 $imgist ein Ressourcenobjekt. Wir können an einem neuen Speicherort 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 von Imagick :: resizeImage und imagejpeg () finden Sie unter diesen Links.

Tunde Michael
quelle
ohne den Wechsel upload_max_filesizein php.inierstens können Sie die Datei mit einer Größe mehr als nicht laden upload_max_filesize. Gibt es eine Möglichkeit , das Bild der Größe mehr , um die Größe als upload_max_filesizeohne Änderung upload_max_filesizeinphp.ini
rch
6

Ich hoffe es wird für dich funktionieren.

/**
         * 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);
        }
Er.gaurav soni
quelle
6

( WICHTIG : Bei der Größenänderung von Animationen (animiertes Webp oder GIF) ist das Ergebnis ein nicht animiertes, aber in der Größe geändertes Bild aus dem ersten Frame! (Die ursprüngliche Animation bleibt erhalten ...)

Ich habe dies für mein PHP 7.2- Projekt (Beispiel imagebmp sicher (PHP 7> = 7.2.0): php / manual / function.imagebmp ) über techfry.com/php-tutorial mit GD2 (also keine Bibliothek von Drittanbietern) und erstellt Sehr ähnlich der Antwort von Nico Bistolfi, funktioniert jedoch mit allen fünf grundlegenden Bildmimetypen ( PNG, JPEG, WebP, BMP und GIF ) und erstellt eine neue Datei mit geänderter Größe, ohne die ursprüngliche zu ändern , und alles 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)) {
        return null;
    }

    $types = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_GIF, IMAGETYPE_BMP, IMAGETYPE_WEBP];
    $type = exif_imagetype ($imagePath);

    if (!in_array ($type, $types)) {
        return null;
    }

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

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

    switch ($type) {
        case IMAGETYPE_JPEG:
            $image = imagecreatefromjpeg ($imagePath);
            if (!$outBool) $outExt = 'jpg';
            break;
        case IMAGETYPE_PNG:
            $image = imagecreatefrompng ($imagePath);
            if (!$outBool) $outExt = 'png';
            break;
        case IMAGETYPE_GIF:
            $image = imagecreatefromgif ($imagePath);
            if (!$outBool) $outExt = 'gif';
            break;
        case IMAGETYPE_BMP:
            $image = imagecreatefrombmp ($imagePath);
            if (!$outBool) $outExt = 'bmp';
            break;
        case IMAGETYPE_WEBP:
            $image = imagecreatefromwebp ($imagePath);
            if (!$outBool) $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);

    // Rotate image on iOS
    if(function_exists('exif_read_data') && $exif = exif_read_data($imagePath, 'IFD0'))
    {
        if(isset($exif['Orientation']) && isset($exif['Make']) && !empty($exif['Orientation']) && preg_match('/(apple|ios|iphone)/i', $exif['Make'])) {
            switch($exif['Orientation']) {
                case 8:
                    if ($width > $height) $newImage = imagerotate($newImage,90,0);
                    break;
                case 3:
                    $newImage = imagerotate($newImage,180,0);
                    break;
                case 6:
                    $newImage = imagerotate($newImage,-90,0);
                    break;
            }
        }
    }

    switch (true) {
        case in_array ($outExt, ['jpg', 'jpeg']): $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) {
        return null;
    }

    return $newPath;
}
danigore
quelle
Du bist großartig! Dies ist eine einfache und saubere Lösung. Ich hatte ein Problem mit dem Imagick-Modul und löste Probleme mit dieser einfachen Klasse. Vielen Dank!
Ivijan Stefan Stipić
Großartig, wenn Sie möchten, dass ich später ein weiteres Update hinzufügen kann, verbessere ich dies ein wenig.
Ivijan Stefan Stipić
sicher! Ich habe immer noch keine Zeit, um den Teil zur Größenänderung der Animation zu erstellen ...
danigore
@danigore, wie man die Größe von Rohbildern ( .cr2, .dng, .nefund dergleichen) ändert ? GD2 hat keine Unterstützung und nach viel Mühe konnte ich ImageMagick einrichten. Beim Lesen der Datei schlägt jedoch ein Verbindungszeitlimit fehl. Und auch kein Fehlerprotokoll.
Krishna
1
@danigore Ich füge Ihrer Funktion die automatische Bildrotation hinzu, um Apple-Probleme zu beheben.
Ivijan Stefan Stipić
5

Ich habe eine benutzerfreundliche Bibliothek zum Ändern der Bildgröße erstellt. Es kann hier auf Github gefunden werden .

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 diese benötigen, sind:

  • Schnelle und einfache Größenänderung - Größe auf Querformat, Hochformat oder Auto ändern
  • Einfache Ernte
  • Text hinzufügen
  • Qualitätsanpassung
  • Wasserzeichen
  • Schatten und Reflexionen
  • Transparenzunterstützung
  • Lesen Sie EXIF-Metadaten
  • Rahmen, abgerundete Ecken, Drehung
  • Filter und Effekte
  • Bildschärfung
  • Bildtypkonvertierung
  • BMP-Unterstützung
Jarrod
quelle
Das hat mir den Tag gerettet. Es gibt jedoch einen kleinen Hinweis, den ich an jemanden gerichtet habe, der 3 Tage lang wie ich gesucht hat und kurz davor war, die Hoffnung zu verlieren, eine Größenänderungslösung zu finden. Wenn Sie in Zukunft undefinierte Indexhinweise sehen, sehen Sie einfach diesen Link: github.com/Oberto/php-image-magician/pull/16/commits Und wenden Sie die Änderungen auf die Dateien an. Es wird 100% ohne Probleme funktionieren.
Hema_Elmasry
1
Hey, @Hema_Elmasry. Zu Ihrer Information, ich habe diese Änderungen gerade in der Hauptversion zusammengeführt :)
Jarrod
Ok, sorry, ich habe es nicht bemerkt. Aber ich habe eine Frage. Wenn ich die Größe auf eine kleinere Auflösung ändere, ohne dass sich die Qualität ändert, ist die angezeigte Bildqualität viel geringer. Ist Ihnen schon etwas Ähnliches passiert? Weil ich immer noch keine Lösung gefunden habe.
Hema_Elmasry
2

Hier ist eine erweiterte Version der Antwort, die @Ian Atkin 'gegeben hat. Ich fand es sehr gut funktioniert. Für größere Bilder ist das :). Sie können kleinere Bilder tatsächlich vergrößern, wenn Sie nicht vorsichtig sind. Änderungen: - Unterstützt JPG-, JPEG-, PNG-, GIF- und BMP-Dateien. - Bewahrt die Transparenz für PNG- und GIF-Dateien. - Überprüft, ob die Größe des Originals noch nicht kleiner ist. - Überschreibt das direkt angegebene Bild.

Hier ist es also. Die Standardwerte der Funktion sind die "goldene Regel"

function resize_image($file, $w = 1200, $h = 741, $crop = false)
   {
       try {
           $ext = pathinfo(storage_path() . $file, PATHINFO_EXTENSION);
           list($width, $height) = getimagesize($file);
           // if the image is smaller we dont resize
           if ($w > $width && $h > $height) {
               return true;
           }
           $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;
               }
           }
           $dst = imagecreatetruecolor($newwidth, $newheight);

           switch ($ext) {
               case 'jpg':
               case 'jpeg':
                   $src = imagecreatefromjpeg($file);
                   break;
               case 'png':
                   $src = imagecreatefrompng($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'gif':
                   $src = imagecreatefromgif($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'bmp':
                   $src = imagecreatefrombmp($file);
                   break;
               default:
                   throw new Exception('Unsupported image extension found: ' . $ext);
                   break;
           }
           $result = imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);
           switch ($ext) {
               case 'bmp':
                   imagewbmp($dst, $file);
                   break;
               case 'gif':
                   imagegif($dst, $file);
                   break;
               case 'jpg':
               case 'jpeg':
                   imagejpeg($dst, $file);
                   break;
               case 'png':
                   imagepng($dst, $file);
                   break;
           }
           return true;
       } catch (Exception $err) {
           // LOG THE ERROR HERE 
           return false;
       }
   }
Daniel Doinov
quelle
Tolle Funktion @DanielDoinov - danke fürs Posten - kurze Frage: Gibt es eine Möglichkeit, nur die Breite zu übergeben und die Höhe der Funktion basierend auf dem Originalbild relativ anpassen zu lassen? Mit anderen Worten, wenn das Original 400 x 200 ist, können wir der Funktion mitteilen, dass die neue Breite 200 betragen soll, und die Funktion herausfinden lassen, dass die Höhe 100 betragen sollte?
Marcnyc
In Bezug auf Ihren bedingten Ausdruck halte ich es nicht für sinnvoll, die Größenänderungstechnik auszuführen, wenn $w === $width && $h === $height. Denk darüber nach. Sollte sein >=und >=Vergleiche. @ Daniel
mickmackusa
1

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 ));        
      }



  }  

quelle
1

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);
}
?>
Gayan Sandamal
quelle
0

Sie können die TinyPNG PHP-Bibliothek ausprobieren. Mit dieser Bibliothek wird Ihr Bild beim Ändern der Größe automatisch optimiert. Alles, was Sie benötigen, um die Bibliothek zu installieren und einen API-Schlüssel von https://tinypng.com/developers zu erhalten . 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 gleichen Thema geschrieben http://artisansweb.net/resize-image-php-using-tinypng

Sajid Sayyad
quelle
0

Ich würde einen einfachen Weg vorschlagen:

function resize($file, $width, $height) {
    switch(pathinfo($file)['extension']) {
        case "png": return imagepng(imagescale(imagecreatefrompng($file), $width, $height), $file);
        case "gif": return imagegif(imagescale(imagecreatefromgif($file), $width, $height), $file);
        default : return imagejpeg(imagescale(imagecreatefromjpeg($file), $width, $height), $file);
    }
}
Amir Fo
quelle
0
private function getTempImage($url, $tempName){
  $tempPath = 'tempFilePath' . $tempName . '.png';
  $source_image = imagecreatefrompng($url); // check type depending on your necessities.
  $source_imagex = imagesx($source_image);
  $source_imagey = imagesy($source_image);
  $dest_imagex = 861; // My default value
  $dest_imagey = 96;  // My default value

  $dest_image = imagecreatetruecolor($dest_imagex, $dest_imagey);

  imagecopyresampled($dest_image, $source_image, 0, 0, 0, 0, $dest_imagex, $dest_imagey, $source_imagex, $source_imagey);

  imagejpeg($dest_image, $tempPath, 100);

  return $tempPath;

}}

Dies ist eine angepasste Lösung, die auf dieser großartigen Erklärung basiert . Dieser Typ machte eine schrittweise Erklärung. Hoffe es gefällt allen.

Emiliano Barboza
quelle