Redimensionner l'image en PHP

96

Je souhaite écrire du code PHP qui redimensionne automatiquement toute image téléchargée via un formulaire à 147x147px, mais je n'ai aucune idée de la façon de procéder (je suis un novice en PHP).

Jusqu'à présent, j'ai des images téléchargées avec succès, les types de fichiers étant reconnus et les noms nettoyés, mais j'aimerais ajouter la fonctionnalité de redimensionnement dans le code. Par exemple, j'ai une image de test de 2,3 Mo et de 1331x1331 en dimension, et j'aimerais que le code la redimensionne, ce qui, je suppose, compressera considérablement la taille du fichier de l'image.

Jusqu'à présent, j'ai ce qui suit:

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
la source
Avez-vous essayé des exemples comme ceux-ci stackoverflow.com/questions/10029838/image-resize-with-php ?
Coenie Richards
sans changer l' upload_max_filesizeen php.iniest tout d' abord possible de télécharger le fichier de taille plus upload_max_filesize?. Y a-t-il une chance de redimensionner l'image de taille plus que upload_max_filesize? sans changer upload_max_filesizeenphp.ini
RCH

Réponses:

140

Vous devez utiliser les fonctions ImageMagick ou GD de PHP pour travailler avec des images.

Avec GD, par exemple, c'est aussi simple que ...

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

Et vous pouvez appeler cette fonction, comme ça ...

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

D'après l'expérience personnelle, le rééchantillonnage d'image de GD réduit également considérablement la taille du fichier, en particulier lors du rééchantillonnage d'images brutes d'un appareil photo numérique.

Ian Atkin
la source
Merci! Pardonnez mon ignorance, mais où cela se situerait-il dans le code que j'ai déjà, et où se situerait l'appel de fonction? Ai-je raison de dire que là où j'ai ma base de données INSERT, plutôt que d'insérer $ n, j'insérerais $ img? Ou est-ce que $ n serait structuré $ n = ($ img = resize_image ('/ chemin / vers / un / image.jpg', 200, 200)) ;?
Alex Ryans
1
Stockez-vous des images en tant que BLOBs? Je recommanderais de stocker des images dans le système de fichiers et d'insérer des références dans votre base de données. Je recommande également de lire la documentation complète de GD (ou ImageMagick) pour voir les autres options disponibles.
Ian Atkin
17
Notez que cette solution ne fonctionne que pour les JPEG. Vous pouvez remplacer imagecreatefromjpeg par l'un des éléments suivants: imagecreatefromgd, imagecreatefromgif, imagecreatefrompng, imagecreatefromstring, imagecreatefromwbmp, imagecreatefromxbm, imagecreatefromxpm pour gérer différents types d'images.
Chris Hanson
2
@GordonFreeman Merci pour l'excellent extrait de code, mais il y a un problème, ajoutez abs(), comme ceil($width-($width*abs($r-$w/$h)))et même à la partie de hauteur. Il est nécessaire dans certains cas.
Arman P.
4
Pour enregistrer l'image redimensionnée dans le système de fichiers, ajoutez imagejpeg($dst, $file);après la imagecopyresampled($dst,...ligne. Modifiez $filesi vous ne souhaitez pas écraser l'original.
wkille
23

Cette ressource (lien rompu) vaut également la peine d'être prise en compte - un code très soigné qui utilise GD. Cependant, j'ai modifié leur extrait de code final pour créer cette fonction qui répond aux exigences des OP ...

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
    
}

Vous devrez également inclure ce fichier PHP ...

<?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;
   }      
 
}
?>
interdiction de la géo-ingénierie
la source
1
Votre échantillon est le meilleur. il fonctionne directement dans le framework Zend sans faire de comédie, de drame, de tirer les cheveux.
Je pense que tout le code dont vous avez besoin devrait être dans ma réponse, mais cela peut également aider: gist.github.com/arrowmedia/7863973 .
ban-geoengineering
19

Fonction PHP simple d'utilisation ( échelle d'images ):

Syntaxe:

imagescale ( $image , $new_width , $new_height )

Exemple:

Étape: 1 Lisez le fichier

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

Étape: 2: chargez le fichier image

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

Étape: 3: Notre Life-sauver arrive en «_» | Mettre l'image à l'échelle

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

Remarque: imagecale fonctionnera pour (PHP 5> = 5.5.0, PHP 7)

Source: Cliquez pour en savoir plus

M Abdullah
la source
Meilleure solution pour PHP 5.6.3>
Pattycake Jr
12

Si vous ne vous souciez pas du rapport d'aspect (c'est-à-dire que vous voulez forcer l'image à une dimension particulière), voici une réponse simplifiée

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

Gérons maintenant la partie téléchargement. Première étape, téléchargez le fichier dans le répertoire souhaité. Ensuite, appelez l'une des fonctions ci-dessus en fonction du type de fichier (jpg, png ou gif) et transmettez le chemin absolu de votre fichier téléchargé comme ci-dessous:

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

La valeur de retour $imgest un objet de ressource. Nous pouvons enregistrer dans un nouvel emplacement ou remplacer l'original comme ci-dessous:

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

J'espère que cela aide quelqu'un. Consultez ces liens pour en savoir plus sur le redimensionnement d' Imagick :: resizeImage et imagejpeg ()

Tunde Michael
la source
sans changer l' upload_max_filesizeen php.ini, d'une part , vous ne pouvez pas télécharger le fichier de taille plus upload_max_filesize. Y a-t-il une chance de redimensionner l'image de taille plus que upload_max_filesizesans changer upload_max_filesizeenphp.ini
rch
6

J'espère que cela fonctionnera pour vous.

/**
         * 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
la source
6

( IMPORTANT : dans le cas d'un redimensionnement d'animation (webp ou gif animé), le résultat sera une image non animée, mais redimensionnée à partir de la première image! (L'animation d'origine reste intacte ...)

J'ai créé ceci dans mon projet php 7.2 (exemple imagebmp sure (PHP 7> = 7.2.0): php / manual / function.imagebmp ) à propos de techfry.com/php-tutorial , avec GD2, (donc rien de bibliothèque tierce) et très similaire à la réponse de Nico Bistolfi, mais fonctionne avec les cinq types d'images de base ( png, jpeg, webp, bmp et gif ), créant un nouveau fichier redimensionné, sans modifier l'original, et le tout dans une seule fonction et prêt à l'emploi (copiez et collez dans votre projet). (Vous pouvez définir l'extension du nouveau fichier avec le cinquième paramètre, ou simplement le laisser, si vous souhaitez conserver le signal d'origine):

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
la source
Vous êtes formidable! C'est une solution simple et propre. J'ai eu un problème avec le module Imagick et résoudre des problèmes avec cette classe simple. Merci!
Ivijan Stefan Stipić
Génial, si vous voulez, je peux ajouter une autre mise à jour plus tard, je l'améliore un peu.
Ivijan Stefan Stipić
sûr! Je n'ai toujours pas le temps de construire la partie de redimensionnement de l'animation ...
danigore
@danigore, comment redimensionner les images brutes ( .cr2, .dng, .nefet les likes)? GD2 n'a aucun support et après beaucoup de difficultés, j'ai pu configurer ImageMagick. Mais, il échoue avec une erreur de délai de connexion lors de la lecture du fichier. Et, pas de journal des erreurs non plus ..
Krishna Chebrolu
1
@danigore J'ajoute à votre fonction la rotation automatique de l'image pour résoudre les problèmes d'Apple.
Ivijan Stefan Stipić
5

J'ai créé une bibliothèque facile à utiliser pour le redimensionnement d'image. Il peut être trouvé ici sur Github .

Un exemple d'utilisation de la bibliothèque:

// 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');

D'autres fonctionnalités, si vous en avez besoin, sont:

  • Redimensionnement rapide et facile - Redimensionner en paysage, portrait ou automatique
  • Récolte facile
  • Ajouter du texte
  • Ajustement de la qualité
  • Filigrane
  • Ombres et reflets
  • Prise en charge de la transparence
  • Lire les métadonnées EXIF
  • Bordures, coins arrondis, rotation
  • Filtres et effets
  • Accentuation de l'image
  • Conversion de type d'image
  • Prise en charge BMP
Jarrod
la source
Cela m'a sauvé la journée. Cependant, il y a un petit avis que j'ai à quelqu'un qui cherchait 3 jours comme moi et était sur le point de perdre espoir de trouver une solution de redimensionnement. Si vous voyez des avis d'index non définis à l'avenir, consultez simplement ce lien: github.com/Oberto/php-image-magician/pull/16/commits Et appliquez les modifications aux fichiers. Cela fonctionnera à 100% sans aucun problème.
Hema_Elmasry
1
Hé, @Hema_Elmasry. FYI, je viens de fusionner ces changements dans le main :)
Jarrod
Ok, désolé, je n'ai pas remarqué. Mais j'ai une question. Lorsque je redimensionne à une résolution plus petite avec la qualité non modifiée, la qualité de l'image affichée est bien inférieure. Est-ce que quelque chose de similaire vous est déjà arrivé? Parce que je n'ai toujours pas trouvé de solution.
Hema_Elmasry
2

Voici une version étendue de la réponse donnée par @Ian Atkin '. J'ai trouvé que cela fonctionnait extrêmement bien. Pour des images plus grandes, c'est :). Vous pouvez en fait agrandir des images plus petites si vous ne faites pas attention. Modifications: - Prend en charge les fichiers jpg, jpeg, png, gif, bmp - Préserve la transparence pour .png et .gif - Vérifie deux fois si la taille de l'original n'est pas déjà plus petite - Remplace l'image donnée directement (c'est ce dont j'avais besoin)

Alors voilà. Les valeurs par défaut de la fonction sont la "règle d'or"

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
la source
Excellente fonction @DanielDoinov - merci de l'avoir postée - question rapide: existe-t-il un moyen de ne passer que la largeur et de laisser la fonction ajuster relativement la hauteur en fonction de l'image originale? En d'autres termes, si l'original est de 400x200, pouvons-nous dire à la fonction que nous voulons que la nouvelle largeur soit de 200 et laisser la fonction déterminer que la hauteur doit être de 100?
marcnyc
En ce qui concerne votre expression conditionnelle, je ne pense pas qu'il soit logique d'exécuter la technique de redimensionnement if $w === $width && $h === $height. Pensez-y. Devrait être >=et des >=comparaisons. @Daniel
mickmackusa
1

Gâteau ZF:

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



  }  

la source
1

J'ai trouvé un moyen mathématique de faire ce travail

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

Exemple en direct - 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
la source
0

Vous pouvez essayer la bibliothèque PHP TinyPNG. En utilisant cette bibliothèque, votre image est optimisée automatiquement pendant le processus de redimensionnement. Tout ce dont vous avez besoin pour installer la bibliothèque et obtenir une clé API de https://tinypng.com/developers . Pour installer une bibliothèque, exécutez la commande ci-dessous.

composer require tinify/tinify

Après cela, votre code est le suivant.

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

J'ai écrit un blog sur le même sujet http://artisansweb.net/resize-image-php-using-tinypng

Sajid Sayyad
la source
0

Je suggérerais un moyen simple:

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
la source
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;

}

C'est une solution adaptée basée sur cette grande explication. Ce type a fait une explication étape par étape. J'espère que tout le monde l'appréciera.

Emiliano Barboza
la source