Redimensionner l'image dans PHP
Je veux écrire du code PHP qui redimensionne automatiquement toute image téléchargée via un formulaire à 147x147px, mais je ne sais pas comment m'y prendre (je suis un parentPHP novice).
Jusqu'à présent, les images ont été 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 au code. Par exemple, j'ai une image de test de 2,3 Mo, de dimension 1331x1331, et j'aimerais que le code soit redimensionné, ce qui, je suppose, compressera considérablement la taille de l'image.
Jusqu'à présent, j'ai les informations suivantes:
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);
Vous devez utiliser les fonctions ImageMagick ou Gd de PHP pour travailler avec des images.
Avec D.ieu, 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 pourriez appeler cette fonction, comme si ...
$img = resize_image(‘/path/to/some/image.jpg’, 200, 200);
De par mon expérience personnelle, le rééchantillonnage des images de Gd réduit également considérablement la taille du fichier, en particulier lors du rééchantillonnage des images brutes d'appareils photo numériques.
Cette ressource vaut également la peine d'être pris en compte - un code très ordonné 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;
}
}
?>
Si vous ne vous souciez pas de l'aspect rationnel (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;
}
Nous allons maintenant gérer la partie upload. Première étape, téléchargez le fichier dans le répertoire de votre choix. 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 indiqué ci-dessous:
// jpg change the dimension 750, 450 to your desired values
$img = resize_imagejpg('path/image.jpg', 750, 450);
La valeur de retour $img est un objet 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 ça aide quelqu'un. Vérifiez ces liens pour en savoir plus sur le redimensionnement Imagick :: resizeImage et imagejpeg ()
Il suffit simplement d’utiliser la fonction php:
// Read the image
$img = imagecreatefromjpeg("source_of_img.jpg");
// Now resize the image width = 200 and height = 200
$imgresize = imagescale($img, 200, 200);
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);
}
(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 du premier cadre (l'animation originale reste intacte ...)
J'ai créé ceci pour mon php 7.2 projet (exemple: imagebmp sure (PHP 7> = 7.2.0): php/manual/function. imagebmp ) about techfry.com/php-tutorial , avec Gd2, (donc rien de la bibliothèque tierce) et très similaire à la réponse de Nico Bistolfi, mais fonctionne avec les cinq types d'image de base ( png, jpeg, webp, bmp et gif ), créant un nouveau fichier redimensionné, sans modification de l’original, et de tous les éléments d’une fonction et prêt à l'emploi (copier et coller 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 l'orignal):
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;
}
J'ai créé une bibliothèque facile à utiliser pour redimensionner les images. On peut le trouver 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');
Les autres fonctionnalités, si vous en avez besoin, sont:
- Redimensionnement rapide et facile - Redimensionner en paysage, portrait ou auto
- Récolte facile
- Ajouter du texte
- Ajustement de la qualité
- Filigranage
- Ombres et reflets
- Support de transparence
- Lire les métadonnées EXIF
- Bordures, coins arrondis, rotation
- Filtres et effets
- Netteté de l'image
- Conversion de type d'image
- Support BMP
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);
}
?>
Vous pouvez essayer la bibliothèque TinyPNG PHP. 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 auprès 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 comme suit.
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
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 ));
}
}
Je vous recommanderais d'utiliser piio.co , une fois que vous avez chargé vos images sur votre stockage, il vous suffit d'utiliser l'URL de l'image d'origine dans votre tag <img /> et la bibliothèque fera automatiquement le redimensionnement pour vous.
Votre balise d'image ressemblera à ceci:
<img data-piio="/image/gallery/p/image1.jpg" />
Ensuite, une fois le script initialisé, Piio redimensionnera automatiquement l’image et la diffusera à partir d’un CDN.
Voici un lien vers le docs
Si vous voulez le faire manuellement , alors je vous recommande d'utiliser les fonctions php natives, cela utilisera la bibliothèque Gd. Par exemple, si vous souhaitez redimensionner un fichier JPEG, vous pouvez commencer par:
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);
Pour sortir directement l'image:
imagejpeg($thumb);
Pour enregistrer l'image dans un fichier:
imagejpeg($thumb, 'filepath/image.jpg');