[PHP]: ThumbAndCrop (Resize & Crop Immagini con PHP)

Ecco a voi una nuova classe presa dalla mia dispensa, anzi dal mio cervello visto che l’ho scritta ieri notte! 🙂

Quante volte ci è capitato di dover effettuare una miniatura di un immagine via php, molte volte ci si dimentica le funzioni e i loro parametri, poi bisogna usare la funzione adatta al tipo di immagine da manipolare, ecc… ecc…

Oggi vi presento questa nuova classe php che ho nominato: Thumb And Crop ovvero rimpicciolisci e ritaglia.

Grazie a questa classe potremo:

– Ottenere le dimensioni di un immagine

– Ottenere le dimensioni di un immagine mantenendo le proporzioni

– Creare una miniatura di un immagine

– Ritagliare un pezzo di un immagine

– Combinare la funzione Crop alla Thumb per avere una foto ritagliata e rimpicciolita

– Manipolare un immagine Jpeg, Gif, Png, Bmp senza cambiare il codice in base al tipo di immagine.

Veniamo ora al codice della classe:

<?php
	class ThumbAndCrop
	{

		private $handleimg;
		private $original = "";
		private $handlethumb;
		private $oldoriginal;

		/*
			Apre l'immagine da manipolare
		*/
		public function openImg($file)
		{
			$this->original = $file;

			if($this->extension($file) == 'jpg' || $this->extension($file) == 'jpeg')
			{
				$this->handleimg = imagecreatefromjpeg($file);
			}
			elseif($this->extension($file) == 'png')
			{
				$this->handleimg = imagecreatefrompng($file);
			}
			elseif($this->extension($file) == 'gif')
			{
				$this->handleimg = imagecreatefromgif($file);
			}
			elseif($this->extension($file) == 'bmp')
			{
				$this->handleimg = imagecreatefromwbmp($file);
			}
		}

		/*
			Ottiene la larghezza dell'immagine
		*/
		public function getWidth()
		{
			return imageSX($this->handleimg);
		}

		/*
			Ottiene la larghezza proporzionata all'immagine partendo da un'altezza
		*/
		public function getRightWidth($newheight)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$neww = ($oldw * $newheight) / $oldh;

			return $neww;
		}

		/*
			Ottiene l'altezza dell'immagine
		*/
		public function getHeight()
		{
			return imageSY($this->handleimg);
		}

		/*
			Ottiene l'altezza proporzionata all'immagine partendo da una larghezza
		*/
		public function getRightHeight($newwidth)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$newh = ($oldh * $newwidth) / $oldw;

			return $newh;
		}

		/*
			Crea una miniatura dell'immagine
		*/
		public function creaThumb($newWidth, $newHeight)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$this->handlethumb = imagecreatetruecolor($newWidth, $newHeight);

			return imagecopyresampled($this->handlethumb, $this->handleimg, 0, 0, 0, 0, $newWidth, $newHeight, $oldw, $oldh);
		}

		/*
			Ritaglia un pezzo dell'immagine
		*/
		public function cropThumb($width, $height, $x, $y)
		{
			$oldw = $this->getWidth();
			$oldh = $this->getHeight();

			$this->handlethumb = imagecreatetruecolor($width, $height);

			return imagecopy($this->handlethumb, $this->handleimg, 0, 0, $x, $y, $width, $height);
		}

		/*
			Salva su file la Thumbnail
		*/
		public function saveThumb($path, $qualityJpg = 100)
		{
			if($this->extension($this->original) == 'jpg' || $this->extension($this->original) == 'jpeg')
			{
				return imagejpeg($this->handlethumb, $path, $qualityJpg);
			}
			elseif($this->extension($this->original) == 'png')
			{
				return imagepng($this->handlethumb, $path);
			}
			elseif($this->extension($this->original) == 'gif')
			{
				return imagegif($this->handlethumb, $path);
			}
			elseif($this->extension($this->original) == 'bmp')
			{
				return imagewbmp($this->handlethumb, $path);
			}
		}

		/*
			Stampa a video la Thumbnail
		*/
		public function printThumb()
		{
			if($this->extension($this->original) == 'jpg' || $this->xtension($this->original) == 'jpeg')
			{
				header("Content-Type: image/jpeg");
				imagejpeg($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'png')
			{
				header("Content-Type: image/png");
				imagepng($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'gif')
			{
				header("Content-Type: image/gif");
				imagegif($this->handlethumb);
			}
			elseif($this->extension($this->original) == 'bmp')
			{
				header("Content-Type: image/bmp");
				imagewbmp($this->handlethumb);
			}
		}

		/*
			Distrugge le immagine per liberare le risorse
		*/
		public function closeImg()
		{
			imagedestroy($this->handleimg);
			imagedestroy($this->handlethumb);
		}

		/*
			Imposta la thumbnail come immagine sorgente,
			in questo modo potremo combinare la funzione crea con la funzione crop
		*/
		public function setThumbAsOriginal()
		{
			$this->oldoriginal = $this->handleimg;
			$this->handleimg = $this->handlethumb;
		}

		/*
			Resetta l'immagine originale
		*/
		public function resetOriginal()
		{
			$this->handleimg = $this->oldoriginal;
		}

		/*
			Estrae l'estensione da un file o un percorso
		*/
		private function extension($percorso)
		{
			if(eregi("[\|\\]", $percorso))
			{
				// da percorso
				$nome = $this->nomefile($percorso);

				$spezzo = explode(".", $nome);

				return strtolower(trim(array_pop($spezzo)));
			}
			else
			{
				//da file
				$spezzo = explode(".", $percorso);

				return strtolower(trim(array_pop($spezzo)));
			}
		}

		/*
			Estrae il nome del file da un percorso
		*/
		private function nomefile($path, $ext = true)
		{
			$diviso = spliti("[/|\\]", $path);

			if($ext)
			{
				return trim(array_pop($diviso));
			}
			else
			{
				$nome = explode(".", trim(array_pop($diviso)));

				array_pop($nome);

				return trim(implode(".", $nome));
			}
		}
	}
?>

Salviamo il file come thumbncrop.inc.php ed apriamo il file di esempio per provare la classe e scriviamo il seguente codice:

	// includo la classe
	require_once("libs/thumbncrop.inc.php");

	// valorizzo la variabile
	$tb = new ThumbAndCrop();

Come si può vedere abbiamo solamente incluso la classe, e valorizzato la variabile $tb.

Spiegazione delle funzioni:

In anzitutto la prima funzione da utilizzare obbligatoriamente è “openImg” passando come parametro il nome del file da aprire.

$tb->openImg(“ghi.jpg”);

Dopo-di-ché abbiamo le funzioni per ottenere le dimensioni dell’ immagine aperta:

$tb->getHeight();

$tb->getWidth();

Invece se dobbiamo ridimensionare l’immagine mantenendo le proporzioni basterà usare una di queste 2 funzioni, passando come parametro la larghezza/altezza di riferimento… esempio: dopo aver aperto l’immagine, se vogliamo ridimensionarla in larghezza a 100 pixels mantenendo l’altezza proporzionata, basterà usare la funzione “getRightHeight” passando come parametro, la larghezza indicativa ovvero 100.

$newHeight = $tb->getRightHeight(100);

$newWidth = $tb->getRightWidth(75);

Dopo aver calcolato le dimensioni passiamo ora a creare la miniatura con la funzione “creaThumb” e passando come parametro la larghezza e l’altezza da ottenere.

$tb->creaThumb(100, $newHeight);

Ora possiamo scegliere se printare a video l’immagine con la funzione “printThumb” (l’header verrà inviato in automatico non bisogna inserirlo a mano), oppure salvare l’immagine su disco con la funzione “saveThumb” passando come parametro il nome del file da creare, e nel caso sia un jpg anche la qualità dell’immagine finale (default: 100).

$tb->printThumb();

$tb->saveThumb(“cropthumb.jpg”);

Dopo-di-ché non ci resta che chiudere l’immagine aperta, per liberare le risorse con “closeImg”.

$tb->closeImg();

Oltre alla miniatura possiamo creare una piccola immagine contenente un ritaglio dell’immagine sorgente, basterà usare la funzione “cropThumb” prima di “closeImg”, infatti anche dopo aver usato l’immagine originale per creare una miniatura o ritagliare un pezzo dell’immagine, utilizzando di nuovo le funzioni senza chiudere l’immagine, potremo lavorare ancora sull’immagine originale…

Quindi potremo creare N miniature per volta usando semplicemente la funzione “creaThumb” e la stessa cosa vale anche per “cropThumb”.

La funzione “cropThumb” richiede 4 parametri, e sono larghezza finale, altezza finale, coordinata X dell’immagine originale dal quale iniziare a copiare l’immagine, coordinata Y dell’immagine originale dal quale iniziare a copiare l’immagine.

E se volessimo combinare le funzione rimpicciolisci e ritaglia? Ad esempio partendo da un’immagine 400×300, creare una miniatura 100×50 partendo a 20px dall’alto. Vediamo il codice in riferimento a quello precedentemente scritto:

	// creo la miniatura con le dimensioni da me volute
	$tb->creaThumb(100, $newHeight);

	// abilito il ThumbAndCrop
	$tb->setThumbAsOriginal();

	// taglio l'img a dimensione 100x50 artendo dalla thumb x:0, y:20
	$tb->cropThumb(100, 50, 0, 20);

Come possiamo vedere creiamo prima la miniatura da 400×300 (immagine originale) a 100×75 (miniatura proporzionata), dopo-di-ché usando la funzione “setThumbAsOriginal” setto la miniatura come immagine originale, quindi a partire da questo momento, ogni operazione fatta con le funzioni verrà effettuata sulla miniatura e non più sull’immagine originale! (per ripristinare l’immagine originale basterà utilizzare la funzione “resetOriginal”. Ed ora ritaglio un’immagine di 100×50 partendo dalle coordinate della miniature X:0 ed Y:20.

Spero che la classe vi possa essere utile, lasciate qualche commento se apprezzate! 😉

Scarica i file di esempio: ThumbAndCrop