Classe de redimensionnement d'images php

Télécharger le projet
Commenter

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);	
	}
}
?>
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (beejeridou)