Classe de redimensionnement d'images php

Soyez le premier à donner votre avis sur cette source.

Vue 7 931 fois - Téléchargée 840 fois

Description

Bonjour,

Comme promis, voici ma classe de redimensionnement d'images couplée à celle d'upload de fichiers.

3 types de redimensionnement: l'homothétie, le crop (carré ou rectangle), le wallpaper.

Lors d'un redimensionnement, le script essaye de centrer au maximum la zone en fonction si l'image source est de type portrait ou paysage.

Lors d'un redimensionnement de type "homothety", si on précise largeur+hauteur, le redimensionnement prendra la taille correspondante si l'image source est de type portrait ou paysage. Dans le cas contraire, l'image prendra toujours la largeur comme référence.

Par défaut, si le redimensionnement demandé est plus grand que l'image source, afin de ne pas dégrader la qualité de l'image, le redimensionnement ne se fait pas... sauf si on déclare la méthode : setForceDimensions();

La methode setDeleteSource() permet de supprimer l'image source afin de ne garder que les images redimensionnées.

La gestion du memory_limit imposé par le serveur est gérée. En effet, votre image source peut contenir "trop" de pixels tout en étant inférieure au poids limite. Si ce cas est rencontré (j'ai testé avec une image de 2000px de large), l'image source sera redimensionnée à 1000px pour les traitements des vignettes suivantes.
Ce calcul est effectué grâce au 3ème paramètre du constructeur. C'est le nombre de redimensionnements que l'on compte effectuer. Ce calcul se base sur un memory_limit de 32MO que vous pouvez changer avec la methode setMemoryLimit().
La méthode setMemoryUsed() affiche la mémoire utilisée par le script (en Mo).

Si vous avez des questions... j'avoue que mon explication peut être zarbi.

Executez class.ImageResize.php sur votre serveur pour utiliser l'exemple qui se trouve tout en bas.

Vous devez bien entendu être en PHP5 et avoir activé la bibliothèque GD(2).

Source / Exemple :


<?php
class ImageResize {

	private $memoryUsed = false;
	private $infosDebug;
	
	private $droits = 0777;
	private $memoryLimit = 32;
	
	private $pathSource;
	private $imgNameSource;
	private $imgSource;
	private $extension;
	private $sizeSource;
	private $typeResize;
	
	private $ressource;
	
	private $forceDimensions = false;
	private $deleteSource = false;
	private $alphaMode = false;
	private $txtImg;
	private $fontFamily = 'polices/arial.ttf';
	
	private $errorResize;
	
	//SET
	public function setMemoryUsed() {
		$this->memoryUsed = true;
	}
	public function setDroits($v) {
		$this->droits = $v;
	}
	public function setnbrResize($v) {
		$this->nbrResize = $v;
	}
	public function setMemoryLimit($v) {
		$this->memoryLimit = $v;
	}
	public function setTxtImg($v) {
		$this->txtImg = $v;
	}
	public function setForceDimensions() {
		$this->forceDimensions = true;
	}
	public function setDeleteSource() {
		$this->deleteSource = true;
	}
	public function setAlphaMode() {
		$this->alphaMode = true;
	}
	
	//GET
	private function getMemory() {
		if($this->extension == ".png" || $this->extension == ".PNG") 
			$this->memory = 0;
		else {
			$this->infosDebug = getimagesize($this->imgSource);
			$m_need = round((($this->infosDebug[0]*$this->infosDebug[1]*$this->infosDebug['bits']*$this->infosDebug['channels']/8+pow(2,16))*1.65)*$this->nbrResize); 
			$this->memory = round($m_need / pow(1024,2),2);
		}
	}
	public function getImgSource() {
		return $this->imgSource;
	}
	public function getImgName() {
		return $this->imgName;
	}
	public function getErrorResize() {
		return $this->errorResize;
	}
	public function getPathImg() {
		return $this->pathImg;
	}
	
	//CONSTRUCT
	public function __construct($pathSource, $imgName, $extension, $nbrResize=1) {
		if(file_exists($pathSource."/".$imgName.$extension)) {
			$this->pathSource = $pathSource;
			$this->imgName = $imgName;
			$this->extension = $extension;
			$this->imgNameSource = $imgName.$extension;
			$this->imgSource = $pathSource."/".$this->imgNameSource;
			$this->nbrResize = $nbrResize;
			
			$this->getMemory();
			if($this->memory >= $this->memoryLimit) {
				$newSource = new ImageResize($this->pathSource, $this->imgName, $this->extension);
				$this->ressource = $newSource->resize("homothety", $this->pathSource, "1000", substr($this->imgNameSource,0,-4));
				$this->sizeSource = getimagesize($newSource->imgSource);
				imagedestroy($newSource->ressource);
			}			
			else {
				if(!$this->imgWorking())
					$this->errorResize = "<b class=''>ERREUR</b> : L'image de travail n'a pas pu être créée";
			}
		}
		else {
			$this->errorResize = "<b class=''>ERREUR</b> : L'image source n'existe pas";
			return false;
		}
	}
	
	//METHOD
	private function imgWorking() {
		$this->sizeSource = getimagesize($this->imgSource);
		switch($this->sizeSource[2]) {
			case 1: // gif
				$this->ressource = @imagecreatefromgif($this->imgSource); break;
			case 2: // jpeg
				$this->ressource = @imagecreatefromjpeg($this->imgSource); break;
			case 3: // png
				$this->ressource = @imagecreatefrompng($this->imgSource); break;
			default:
				$this->errorResize = "<b class=''>ERREUR</b> : L'image source n'est pas reconnue"; 
				return false;
		}
		return true;
	}
	public function resize($typeResize, $path, $dimensions="", $imgName="") {
		if(is_resource($this->ressource)) {
			$this->typeResize = $typeResize;
			$this->path = $path;
			$this->uniqName($imgName);
			
			switch($this->typeResize) {
				case "homothety":
					$finalImg = $this->defineHomothety($dimensions); break;
				case "homothetyHeight":
					$finalImg = $this->defineHomothety($dimensions, "height"); break;
				case "crop":
					$finalImg = $this->defineCrop($dimensions); break;
				case "wallpaper":
					$finalImg = $this->defineWallpaper(); break;
			}
			if($this->createDir())
				if($this->createImg($finalImg)) {
					$this->getMemory();
					$this->pathImg = $this->path."/".$this->imgName.$this->extension;
					return $finalImg;
				}
		}
		else {
			$this->errorResize = "<b class=''>ERREUR</b> : La ressource de l'image n'est pas accessible"; 
			return false;
		}
	}		
	private function defineHomothety($dimensions, $constraint="") {
		if(preg_match('`\/`', $dimensions)) {
			$tabDimensions = explode("/", $dimensions);
			
			//paysage
			if($this->sizeSource[0] > $this->sizeSource[1]) {
				$width = round($tabDimensions[0]);
				$height = round($this->sizeSource[1]*($tabDimensions[0]/$this->sizeSource[0]));
			}
			//portrait
			else {
				$width = round($this->sizeSource[0]*($tabDimensions[1]/$this->sizeSource[1]));
				$height = round($tabDimensions[1]);
			}
		}
		else {
			if($constraint == "height") {
				$height = round($dimensions);
				$width = round($this->sizeSource[0]*($height/$this->sizeSource[1]));
			}
			else {
				$width = round($dimensions);
				$height = round($this->sizeSource[1]*($width/$this->sizeSource[0]));
			}
		}
		if(!$this->forceDimensions && ($this->sizeSource[0] < $width && $this->sizeSource[1] < $height)) {
			$width = round($this->sizeSource[0]);
			$height = round($this->sizeSource[1]);
		}
		
		$finalImg = imagecreatetruecolor($width, $height);
		if($this->alphaMode) 
			$this->alpha($finalImg);

		imagecopyresampled($finalImg, $this->ressource, 0, 0, 0, 0, $width, $height, $this->sizeSource[0], $this->sizeSource[1]);
		return $finalImg;
	}
	private function defineCrop($dimensions) {
		if(preg_match('`\/`', $dimensions)) {
			$tabDimensions = explode("/", $dimensions);
			$width = $tabDimensions[0];
			$height = $tabDimensions[1];
		}
		else {
			$width = $dimensions;
			$height = $dimensions;
		}
		if(!$this->forceDimensions && ($this->sizeSource[0] < $width || $this->sizeSource[1] < $height)) {
			$width = $this->sizeSource[0];
			$height = $this->sizeSource[1];
		}
		//RAPPORT
		$rapportWidth = $this->sizeSource[0]/$width;
		$rapportHeight = $this->sizeSource[1]/$height;
		$rapportScale = ($rapportWidth < $rapportHeight)?1/$rapportWidth:1/$rapportHeight;
		
		$ajustWidth = round($this->sizeSource[0]*$rapportScale);
		$ajustHeight = round($this->sizeSource[1]*$rapportScale);
			
		//IMG intermediaire
		$ajustImg = imagecreatetruecolor($ajustWidth, $ajustHeight);
		if($this->alphaMode) 
			$this->alpha($ajustImg);
			
		imagecopyresampled($ajustImg, $this->ressource, 0, 0, 0, 0, $ajustWidth, $ajustHeight, $this->sizeSource[0], $this->sizeSource[1]);
		
		//COORDONNEES
		$coordWidthSource = 0;
		$coordHeightSource = 0;
		if($this->sizeSource[0] > $this->sizeSource[1])
			$coordWidthSource = round(($ajustWidth - $width) / 2);
		else 
			$coordHeightSource = round(($ajustHeight - $height) / 2);
			
		$finalImg = imagecreatetruecolor($width, $height);
		if($this->alphaMode) 
			$this->alpha($finalImg);
			
		imagecopy($finalImg, $ajustImg, 0, 0, $coordWidthSource, $coordHeightSource, $ajustWidth, $ajustHeight);
		return $finalImg;
	}
	private function defineWallpaper() {
		return $this->ressource;
	}
	private function createImg($finalImg) {
		$this->writeTxtImg($finalImg);
		if($this->alphaMode) 
			$this->alpha($finalImg);
		
		switch($this->sizeSource[2]) {
			case 1: // gif
				$op = imagegif($finalImg, $this->path."/".$this->imgName.$this->extension, 100); break;
			case 2: // jpeg
				$op = imagejpeg($finalImg, $this->path."/".$this->imgName.$this->extension, 100); break;
			case 3: // png
				$op = imagepng($finalImg, $this->path."/".$this->imgName.$this->extension); break;
			default:
				$this->errorResize = "<b class=''>ERREUR</b> : L'image ".$this->imgName." n'a pas pu être redimentionée"; 
				return false; break;
		}
		return $op;
	}
	private function alpha($img) {
		imagealphablending($img, false);
		imagesavealpha($img, true);
	}
	private function writeTxtImg($img) {
		if($this->txtImg != "" && $this->typeResize == "wallpaper") {
			$shadow = imagecolorallocate($this->ressource, 128, 128, 128);
			$blanc = imagecolorallocate($this->ressource, 223, 223, 223);
			$police = 20;
			putenv('GDFONTPATH='.realpath('.'));
			
			$font = $this->fontFamily;			
			
			imagettftext($img, $police, 0, 25, 40, $shadow, $font, $this->txtImg);
			imagettftext($img, $police, 0, 26, 41, $blanc, $font, $this->txtImg);
		}
	}
	private function uniqName($imgName) {
		if($imgName == "")
			$imgName = uniqid("", true);
		$this->imgName = $imgName;
	}
	private function createDir() {
		if($this->path != "") {
			if(preg_match('`\/`', $this->path)) {
				$path = explode("/", $this->path);
				$newDir = "";
				foreach($path as $dir) {
					if($dir == "..") {
						$newDir .= "../";
						continue;
					}
					if(!file_exists($newDir.$dir))
						mkdir($newDir.$dir, $this->droits); 
						
					$newDir .= $dir."/";
				}
			}
			else if(!file_exists($this->path))
				mkdir($this->path, $this->droits);
				
			return true;
		}
		else {
			$this->errorResize = "<b class=''>ERREUR</b> : Aucune destination n'a été spécifiée";
			return false;
		}
    }
	public function deleteFile($file) {
		if(file_exists($file)) {
			@unlink($file);
			return true;
		}
		else
			return false;
	}
	public function __destruct() {			
		if($this->deleteSource) {
			if(!$this->deleteFile($this->imgSource))
				$this->errorResize = "<b class=''>ERREUR</b> : Impossible de supprimer l'image source";
		}
		if($this->memoryUsed)
			echo $this->errorResize = "<br /><b class=''>DEBUG</b> : ".$this->memory." Mo de cache utilisée";
		
		if(is_resource($this->ressource))
			imagedestroy($this->ressource);	
	}
}
?>

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
5
Date d'inscription
jeudi 19 juin 2008
Statut
Membre
Dernière intervention
13 octobre 2010

hhhhhh ok men :)
Messages postés
35
Date d'inscription
lundi 10 avril 2006
Statut
Membre
Dernière intervention
21 mai 2010

La source est sur cette page. A vous d'adapter l'exemple selon vos besoins.

Cordeialement,
//Beejeridou */
Messages postés
5
Date d'inscription
jeudi 19 juin 2008
Statut
Membre
Dernière intervention
13 octobre 2010

j'ai besoin d'une classe qui fait L'upload multiple plus le redimensionnement des images en 3 types l'homothétie, le crop et le wallpaper. si vous vous avez une source aider moi SVP
Messages postés
5
Date d'inscription
jeudi 19 juin 2008
Statut
Membre
Dernière intervention
13 octobre 2010

si j'ai trouver sur d'autre source d'upload crée en POO l'upload multiple sans passé par le flash
Messages postés
35
Date d'inscription
lundi 10 avril 2006
Statut
Membre
Dernière intervention
21 mai 2010

Salut,
Il te suffit de déclarer plusieurs objets. Après, j'imagine que tu gères l'upload multiple en Flash? php/HTML ne le gère pas à lui tout seul.
Afficher les 41 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.