Forum d'entraide PHPFrance

Bonjour,

Voilà j'ai crée une classe image.

La voici:

<?php

class Image
{

	var $img_id; 		// Id de l'image
	var $img; 			// Nom de l'image
	var $type_resize;	// Type de réduction -- small ou big
	var $degres; 		// Angle de rotation
   	var $error;			// Variable pour les erreurs
	
	
	/*
	@ Constante de la classe
	*/
		// Taille des images dans la liste
		const MAX_SMALL_WIDTH = 150;
		const MAX_SMALL_HEIGHT = 150;
	
		// Taille des images dans la liste
		const MAX_BIG_WIDTH = 300;
		const MAX_BIG_HEIGHT = 300;
	
		// Réglage des qualités
		const QUALITY_JPEG = 100;		// Pour les jpeg -- Valeur comprise entre 0 et 100
		const QUALITY_PNG = 7;			// Pour les png -- Valeur comprise entre 0 et 10
		
		// Réglage des écritures
		const TEXT_ANGLE = 0;
		const TEXT_POLICE = "arial.ttf";
		const TEXT_SIZE = 12;
		const TEXT = "Copyright 2008";
		
			// Réglage pour small 
			const TEXT_CORD_Y_SMALL = 140;
			const TEXT_CORD_X_SMALL = 5;
			
			// Réglage pour big
			const TEXT_CORD_Y_BIG = 290;
			const TEXT_CORD_X_BIG = 5;


	

	/*
	@ Fonction qui détermine la hauteur de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Height($image)
	{
	
		$this->list_img = getimagesize($image);

		return $this->list_img[1];
		
	}
	
	
	/*
	@ Fonction qui détermine la largeur de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Width($image)
	{
	
		$this->list_img = getimagesize($image);

		return $this->list_img[0];
		
	}
	
	
	/*
	@ Fonction qui détermine le type de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Type($image)
	{
	
		$this->list_img = getimagesize($image);

		return $this->list_img[2];
	
	}


	/*
	@ Fonction de création du nouveau nom de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Name($image, $type)
	{
	
		$this->name_img = strtolower($image);
		$this->name_img = substr($this->name_img, 0, -4);

		switch($type)
		{	
			case 1:
				$this->ext = '.gif';
			break;
			
			case 2:
				$this->ext = '.jpeg';
			break;
			
			case 3:
				$this->ext = '.png';
			break;
		}

		return $this->name_img.$this->ext;
	
	}


	/*
	@ Fonction qui détermine le nom de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Data_Image_Name($image)
	{
	
		$this->name_img = strtolower($image);
		$this->name_img = substr($this->name_img, 0, -4);

		return $this->name_img;
	
	}


	/*
	@ Fonction qui détermine le type de header a utiliser
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Header($type, $image)
	{
	
		switch($type)
		{	
			case 1:
				header('Content-type: image/gif');
			break;
			
			case 2:
				header('Content-type: image/jpeg');
			break;
			
			case 3:
				header('Content-type: image/png');
			break;
		}

	}


	/*
	@ Fonction d'affichage de l'image
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Save($type, $image)
	{

		switch($type)
		{	
			case 1:
				imagegif($image);
			break;
			
			case 2:
				imagejpeg($image, '', self::QUALITY_JPEG);
			break;
			
			case 3:
				imagepng($image);
			break;
		}
		
	}


	/*
	@ Fonction qui libere la mémoire
	@ 
	@ $image = Nom de l'image
	*/
	private function Get_Image_Destroy($type, $image)
	{
	
		imagedestroy($image.$type);
	
	}


	/*
	@ Fonction d'erreur
	*/
   	public function Get_Message_Error($error)
	{
      	if(!empty($error))
		{
         	echo $error;
      	}
   	}
	




	/*
	@ Fonction d'affichage d'image
	*/
	public function Write()
	{
	
		$this->width = $this->Get_Image_Width($this->img);
		$this->height = $this->Get_Image_Height($this->img);
		$this->type = $this->Get_Image_Type($this->img);

		
		if($this->type_resize == 'small')
		{
			$max_width = self::MAX_SMALL_WIDTH;
			$max_height = self::MAX_SMALL_HEIGHT;
		}
		elseif($this->type_resize == 'big')
		{
			$max_width = self::MAX_BIG_WIDTH;
			$max_height = self::MAX_BIG_HEIGHT;		
		}
		

		$this->Get_Image_Header($this->type, $this->img); 
		

		$thumb = imagecreatetruecolor($max_width, $max_height);
		
		
		switch($this->type)
		{	
			case 1:
				$source = imagecreatefromgif($this->img);
			break;
			
			case 2:
				$source = imagecreatefromjpeg($this->img);
			break;
			
			case 3:
				$source = imagecreatefrompng($this->img);
			break;
		}


		imagecopyresampled($thumb, $source, 0, 0, 0, 0, $max_width, $max_height, $this->width, $this->height);

		$this->Get_Image_Save($this->type, $thumb);
		
		$this->Get_Image_Destroy($this->type, $thumb);

	}
	

	/*
	@ Fonction de réduction d'image
	*/
	public function Resize()
	{
	
		$this->width = $this->Get_Image_Width($this->img);
		$this->height = $this->Get_Image_Height($this->img);
		$this->type = $this->Get_Image_Type($this->img);

		
		if($this->type_resize == 'small')
		{
			$max_width = self::MAX_SMALL_WIDTH;
			$max_height = self::MAX_SMALL_HEIGHT;
			
			$coordonnee_x = self::TEXT_CORD_X_SMALL;
			$coordonnee_y = self::TEXT_CORD_Y_SMALL;
		}
		elseif($this->type_resize == 'big')
		{
			$max_width = self::MAX_BIG_WIDTH;
			$max_height = self::MAX_BIG_HEIGHT;		
			
			$coordonnee_x = self::TEXT_CORD_X_BIG;
			$coordonnee_y = self::TEXT_CORD_Y_BIG;
		}
		
		
		if($this->width >= $max_width)
		{
			if($this->height >= $max_height)
			{
				$new_w = $max_width;
				$new_h = $max_height;
			}
			else
			{
				$new_w = $max_width;
				$new_h = $this->height;
			}
		}
		elseif($this->height >= $max_height)
		{
			$new_w = $this->width;
			$new_h = $max_height;
		}
		

		$this->Get_Image_Header($this->type, $this->img); 
		
		
		$thumb = imagecreatetruecolor($new_w, $new_h);
		
		
		switch($this->type)
		{	
			case 1:
				$source = imagecreatefromgif($this->img);
			break;
			
			case 2:
				$source = imagecreatefromjpeg($this->img);
			break;
			
			case 3:
				$source = imagecreatefrompng($this->img);
			break;
		}

		imagecopyresampled($thumb, $source, 0, 0, 0, 0, $new_w, $new_h, $this->width, $this->height);

		$couleur = ImageColorAllocate($thumb, 221, 221, 221);
		
		imagettftext(
			$thumb, 
			self::TEXT_SIZE, 
			self::TEXT_ANGLE, 
			$coordonnee_x, 
			$coordonnee_y, 
			$couleur, 
			self::TEXT_POLICE, 
			self::TEXT
		);

		$this->Get_Image_Save($this->type, $thumb);
		
		$this->Get_Image_Destroy($this->type, $thumb);

	}


	/*
	@ Fonction de rotation d'image
	*/
	public function Rotate()
	{

		$this->type = $this->Get_Image_Type($this->img);


		$this->Get_Image_Header($this->type, $this->img); 
		
		
		if($this->type_resize == 'small')
		{
			$coordonnee_x = self::TEXT_CORD_X_SMALL;
			$coordonnee_y = self::TEXT_CORD_Y_SMALL;
		}
		elseif($this->type_resize == 'big')
		{
			$coordonnee_x = self::TEXT_CORD_X_BIG;
			$coordonnee_y = self::TEXT_CORD_Y_BIG;
		}
		
		
		switch($this->type)
		{	
			case 1:
				$source = imagecreatefromgif($this->img);
			break;
			
			case 2:
				$source = imagecreatefromjpeg($this->img);
			break;
			
			case 3:
				$source = imagecreatefrompng($this->img);
			break;
		}


		$thumb = imagerotate($source, $this->degres, 0);		
	
		$couleur = ImageColorAllocate($thumb, 0, 0, 0);

		imagettftext(
			$thumb, 
			self::TEXT_SIZE, 
			self::TEXT_ANGLE, 
			$coordonnee_x, 
			$coordonnee_y, 
			$couleur, 
			self::TEXT_POLICE, 
			self::TEXT
		);

		$this->Get_Image_Save($this->type, $thumb);

		$this->Get_Image_Destroy($this->type, $thumb);

	}
	

	/*
	@ Fonction d'affichage du descriptif de l'image
	*/
	public function Data_Info()
	{
		
		global $db;
	
		$sql = "select * from ".TABLE_PHOTO." where photo_id = '".$this->img_id."'";
		$req = $db->sql_query($sql);
		$row = $db->sql_fetch_array($req);
		
		$this->width = $this->Get_Image_Width($row['photo_link']);
		$this->height = $this->Get_Image_Height($row['photo_link']);
		$this->type = $this->Get_Image_Type($row['photo_link']);

		$list[$i]['photo_name'] = $row['photo_name'];
		$list[$i]['photo_author'] = $row['photo_author'];
		$list[$i]['photo_desc'] = $row['photo_desc'];
		$list[$i]['photo_date'] = $row['photo_date'];
		$list[$i]['photo_width'] = $this->width;
		$list[$i]['photo_height'] = $this->height;
		$list[$i]['photo_type'] = $this->type;
		$list[$i]['photo_view'] = $row['photo_view'];
		
		return array($list);

	}

}

?>

Le problème est que lorsque j'exécute cette url: http://www.monsite.fr/show.php?file=1&mode=resize

Cela ne m'affiche rien.

Voici le contenu de mon fichier show.php

<?php

include('inc/class/class_mysql.php');
include('inc/config.php');
include('inc/function/constant.php');
include('inc/class/class_image.php');

$db = new Sql();
$db->sql_connect($host, $login_host, $pass_host, $hostname);

$file = $_GET['file'];
$mode = $_GET['mode'];
$ang = $_GET['ang'];

$sql = "select * from ".TABLE_PHOTO." where photo_id = '".$file."'";

if( !($req = $db->sql_query($sql)) )
{
	$db->sql_error(TABLE_FOLDER, 'sql_query()', __LINE__, __FILE__, $sql, mysql_error());
}

$row = $db->sql_fetch_array($req);

$file_link = $row['photo_link'];

if($ang == '')
{
	$angle = 0;
}
elseif($ang == 1)
{
	$angle = 90;
}
elseif($ang == -1)
{
	$angle = -90;
}
elseif($ang == 0)
{
	$angle = 180;
}


$image = new Image;

$image->img = $file_link;
$image->degres = $angle;
$image->type_resize = "big";

switch($mode)
{
	case 'rotate':
		$image->Rotate();
	break;
	
	case 'resize':
		$image->Resize();
	break;
}

?>

Quand je fais:

echo $file_link;

J'obtiens bien ce qui est stockés dans ma bdd donc un lien comme ceci: upload/dossier_01/01.JPG

Et quand je met ce lien dans mon url je vois bien l'image donc pourquoi je n'arrive pas à l'afficher avec ma classe surtout que c'est pareil avec les fonctions Write() et Rotate().


Merci d'avance...

Pourquoi tu écris la classe comme si elle était statique (avec des self:: partout) ? Si tu en fais des instances, c'est $this qu'il faut utiliser..

De plus, je vois pas dans show ou tu demandes d'afficher l'image. Alors il me semble logique que rien ne s'affiche. Enfin, dans les limites de ce que tu nous dis.

Pour les self c'est parce que j'ai vu sur le net qu'on se servait des self pour les constante je ne savais point que l'on pouvait se servir des this.

Et pour l'affichage je fais dans une autre page:

Je trouve ta classe, mal construite car ses méthodes ne s'impliquent pas totalement dans le modèle objet. Par exemple, la majorité des méthodes utilisent des paramètres qui leur fournissent des images alors qu'une méthode de classe doit affecter l'entité de la classe elle-même. Je pense à la méthode write() par exemple, qui normalement doit manipuler l'entité image et retourner une métamorphose, mais toi tu fourni l'image à traiter comme si cette dernière est étrangère à la classe. Et il y' en a bien d'autres remarques de ce type.

Pour t'aider à appréhender le modèle objet de ta classe image voici une structure d'exemple qui n'est qu'une proposition tirée de ce que tu as fait :

Programme : Image.class.php

<?php

class Image
{
	private $fileName;  // Nom de fichier de l'image
	
    /*
    @ Constructeur de la classe
    */
    public function __construct($fileName=null)
	{
		$this->fileName = $fileName;
	}
    /*
    @ Constantes de la classe
    */
        // Petite Taille
        const MAX_SMALL_WIDTH = 50;
        const MAX_SMALL_HEIGHT = 50;
    
        // Grande Taille
        const MAX_BIG_WIDTH = 300;
        const MAX_BIG_HEIGHT = 300;
    
        // Réglage des qualités
        const QUALITY_JPEG = 100;        // Pour les jpeg -- Valeur comprise entre 0 et 100

    /*
    @ Fonctions d'information sur le fichier de l'image
    */
    public function getFileName()
    {
    	return $this->fileName;
	}	
	
	/*
    @ Fonction qui détermine la largeur de l'image
    */
    public function getWidth()
    {
        $size = getimagesize($this->fileName);
        return $size[0];       
    }
    
    /*
    @ Fonction qui détermine la hauteur de l'image
    */
    public function getHeight()
    {
        $size = getimagesize($this->fileName);
        return $size[1];
    }
    
    /*
    @ Fonction qui détermine le type de l'image
    */
    public function getType()
    {
        $size = getimagesize($this->fileName);
        return $size[2]; 
    }

    /*
    @ Fonction qui détermine le chemin du fichier image
    */
    public function getPath()
    {
    	$fileInfo = pathinfo($this->fileName);
		return $fileInfo['dirname'];
	}
	
    /*
    @ Fonction qui détermine le nom propre du fichier image
    */
    public function getName()
    {
    	$fileInfo = pathinfo($this->fileName);
		return $fileInfo['basename'];
	}
	
    /*
    @ Fonction qui détermine l'extension du fichier image
    */
    public function getExtension()
    {
    	$fileInfo = pathinfo($this->fileName);
		return $fileInfo['extension'];
	}
	
    /*
    @ Fonctions de création d'une ressource de travail pour l'image
    */
    public function getRessource()
	{
		switch($this->getType())
		{
			case 1 	: return imagecreatefromgif($this->fileName);
			case 2 	: return imagecreatefromjpeg($this->fileName);
			case 3 	: return imagecreatefrompng($this->fileName);
		}
	}

    /*
    @ Fonction qui détermine le type de header à utiliser
    */
    public function getHeader()
    {
        $size = getimagesize($this->fileName);
		return 'Content-type: ' . $size['mime'];           
    }

    /*
    @ Fonction d'affichage de l'image
    */
    public function write($type_resize=null, $toFile=null)
    {
		// Créer une ressource de travail
		$image_source = $this->getRessource();
		// Determiner la taille de redimensionnement
		switch (strtolower(trim($type_resize)))
        {
            case 'small' : 
				$max_width = self::MAX_SMALL_WIDTH;
            	$max_height = self::MAX_SMALL_HEIGHT;
				break;
            case 'big' : 
           		$max_width = self::MAX_BIG_WIDTH;
            	$max_height = self::MAX_BIG_HEIGHT;
				break;
			default : // taille normale
           		$max_width = $this->getWidth();
            	$max_height =  $this->getHeight();      
        }
        // Copier + redimensionner l'image
        $image_copy = imagecreatetruecolor($max_width, $max_height);
        imagecopyresampled($image_copy, $image_source, 0, 0, 0, 0, $max_width, $max_height, $this->getWidth(), $this->getHeight());
		// Sortie du résultat
		header($this->getHeader());
		switch($this->getType())
        {    
            case 1: imagegif($image_copy, $toFile); break;
            case 2: imagejpeg($image_copy, $toFile, self::QUALITY_JPEG); break;
            case 3: imagepng($image_copy, $toFile); break;
        }
		imagedestroy($image_copy);
                imagedestroy($image_source);
    }
}

//test de la classe
$img1 = new Image("images/image1.gif");

// affichage direct + choix du mode de redimensionnement
$img1->write("big");
//$img1->write("small");
//$img1->write();

// sortie dans un fichier + choix du mode de redimensionnement
//$img1->write("big", "images/image1_big.gif");
//$img1->write("small", "images/image1_small.gif");
//$img1->write(null, "images/image1_copy.gif");

?> 

Bonne lecture

Merci Sadeq pour cette proposition je comprend je fesais pas mal de chose qui n'allait point avec.

J'ai testé ta classe et cela m'affiche cette erreur dans le code source de la page: Et la ligne 103 est celle-ci:

return imagecreatefromjpeg($this->fileName);

Elle est dans la fonction getRessource().

Pourtant je pensais avoir remis la fonction write() dans l'ordre mais apparement un truc cloche et je comprend pas le quel.

Voici la new fonction write():

    /*
    @ Fonction d'affichage de l'image
    */
    public function write($type_resize=null, $toFile=null)
    {
        // Déterminer la taille de redimensionnement
        switch (strtolower(trim($type_resize)))
        {
            case 'small': 
                $max_width = self::MAX_SMALL_WIDTH;
                $max_height = self::MAX_SMALL_HEIGHT;
            break;
			
            case 'big': 
                $max_width = self::MAX_BIG_WIDTH;
                $max_height = self::MAX_BIG_HEIGHT;
            break;
			
            default: // taille normale
                $max_width = $this->getWidth();
                $max_height =  $this->getHeight();      
        }
		
        // Sortie du résultat
        header($this->getHeader());
		
        // Créer une ressource de travail
        $image_source = $this->getRessource();
		
        // Copier + redimensionner l'image
        $image_copy = imagecreatetruecolor($max_width, $max_height);
        imagecopyresampled($image_copy, $image_source, 0, 0, 0, 0, $max_width, $max_height, $this->getWidth(), $this->getHeight());
		
        switch($this->getType())
        {    
            case 1: 
				imagegif($image_copy, $toFile); 
			break;
			
            case 2: 
				imagejpeg($image_copy, $toFile, self::QUALITY_JPEG); 
			break;
			
            case 3: 
				imagepng($image_copy, $toFile); 
			break;
        }
		
        imagedestroy($image_copy);
        imagedestroy($image_source);
    }

Pas vu où est le pb pour le code...
Juste un petit commentaire concernant QUALITY_JPEG. Faut éviter de la mettre à 100 car ça fait des fichiers très lourds et on ne gagne quasiment rien en qualité quand on dépasse la valeur 87- 88 (qui produit des fichiers encore raisonnables).

A propos, j'ai fait moultes essais, actuellement via php et ses fonctions classiques y'a pas moyen d'approcher la qualité de redimensionnement obtenue via un logiciel photo. Le résultat reste exploitable dans la plupart des cas (e-commerce, photos familiales etc.), mais si c'est pour exposer une galerie d'art, en l'état actuel faut faire le travail séparément dans un logiciel photo - y'a pas photo

J'ai testé ta classe et cela m'affiche cette erreur dans le code source de la page:

Code : Tout sélectionner

Fatal error: Call to undefined function imagecreatefromjpeg() in C:\wamp\www\Gallerie\includes\class\class_img.php on line 103

Et la ligne 103 est celle-ci:

return imagecreatefromjpeg($this->fileName);

Elle est dans la fonction getRessource().

as-tu pensé à ajouter l'extension "php_gd2" à php? (le minimum est la version GD-1.8 pour supporter la fonction imagecreatefromjpeg())

Effectivement la librairie était désactiver mais c'est bon je l'ai activé donc dans le code source j'ai bien le codage de l'image mais elle s'affiche toujours pas dans ma balise img

Bonsoir,

Ben j'ai trouvé.

Voici un bout de ma classe si sa intéresse quelqu'un.

<?php

class Image
{

	private $fileName;


    /*
    @ Constantes de la classe
    */
        // Petite Taille
        const MAX_SMALL_WIDTH = 120;
        const MAX_SMALL_HEIGHT = 120;
    
        // Moyenne Taille
        const MAX_MEDIUM_WIDTH = 320;
        const MAX_MEDIUM_HEIGHT = 320;
    
        // Grande Taille
        const MAX_BIG_WIDTH = 500;
        const MAX_BIG_HEIGHT = 500;
    
        // Réglage des qualités
        const QUALITY_JPEG = 88;        // Pour les jpeg -- Valeur comprise entre 0 et 100


    /*
    @ Constructeur de la classe
    */
    public function __construct($fileName = null)
    {	
        $this->fileName = $fileName;
    }
	
    /*
    @ Déconstructeur de la classe
    */
    public function __destruct() 
	{
        if(is_resource($this->image_source))
		{ 
			imagedestroy($this->image_source);
		}
		
        if(is_resource($this->image_copy))
		{ 
			imagedestroy($this->image_copy);
		}
    }

    /*
    @ Fonctions d'information sur le fichier de l'image
    */
    public function getFileName()
    {
        return $this->fileName;
    }    
    
    /*
    @ Fonction qui détermine la largeur de l'image
    */
    public function getWidth()
    {
        $size = getimagesize($this->fileName);
        return $size[0];       
    }
    
    /*
    @ Fonction qui détermine la hauteur de l'image
    */
    public function getHeight()
    {
        $size = getimagesize($this->fileName);
        return $size[1];
    }
    
    /*
    @ Fonction qui détermine le type de l'image
    */
    public function getType()
    {
        $size = getimagesize($this->fileName);
        return $size[2]; 
    }

    /*
    @ Fonction qui détermine le chemin du fichier image
    */
    public function getPath()
    {
        $fileInfo = pathinfo($this->fileName);
        return $fileInfo['dirname'];
    }
    
    /*
    @ Fonction qui détermine le nom propre du fichier image
    */
    public function getName()
    {
        $fileInfo = pathinfo($this->fileName);
        return $fileInfo['basename'];
    }
    
    /*
    @ Fonction qui détermine l'extension du fichier image
    */
    public function getExtension()
    {
        $fileInfo = pathinfo($this->fileName);
        return $fileInfo['extension'];
    }
    
    /*
    @ Fonctions de création d'une ressource de travail pour l'image
    */
    private function getRessource()
    {
        switch($this->getType())
        {
            case 1: 
				return imagecreatefromgif($this->fileName);
			break;
			
            case 2:
				return imagecreatefromjpeg($this->fileName);
			break;
			
            case 3: 
				return imagecreatefrompng($this->fileName);
			break;
        }
    }

    /*
    @ Fonction qui détermine le type de header a utiliser
    */
    private function getHeader()
    {
        switch($this->getType())
        {
            case 1: 
				return 'Content-type: image/gif';
			break;
			
            case 2:
				return 'Content-type: image/jpeg';
			break;
			
            case 3: 
				return 'Content-type: image/png';
			break;
        }        
    }
	
	
/*
 * --------------------------------------------------------------------------------------------------------------------------------
 * --------------------------------------------------------------------------------------------------------------------------------
 */
	
	/*
	@ Fonction d'affichage de l'image
	*/
	public function resize($type_resize, $toFile = NULL)
	{
        // Déterminer la taille de redimensionnement
        switch (strtolower(trim($type_resize)))
        {
            case 'small': 
                $max_width = self::MAX_SMALL_WIDTH;
                $max_height = self::MAX_SMALL_HEIGHT;
				
				$coordonnee_x = self::TEXT_CORD_X_SMALL;
				$coordonnee_y = self::TEXT_CORD_Y_SMALL;
            break;
			
            case 'medium': 
                $max_width = self::MAX_MEDIUM_WIDTH;
                $max_height = self::MAX_MEDIUM_HEIGHT;

				$coordonnee_x = self::TEXT_CORD_X_MEDIUM;
				$coordonnee_y = self::TEXT_CORD_Y_MEDIUM;
            break;
			
            case 'big': 
                $max_width = self::MAX_BIG_WIDTH;
                $max_height = self::MAX_BIG_HEIGHT;

				$coordonnee_x = self::TEXT_CORD_X_BIG;
				$coordonnee_y = self::TEXT_CORD_Y_BIG;
            break;
			
            default: // taille normale
                $max_width = $this->getWidth();
                $max_height =  $this->getHeight();      
        }

       	// Sortie du résultat
        header($this->getHeader());
		
        // Créer une ressource de travail
        $this->image_source = $this->getRessource();
		
        // Copier + redimensionner l'image
        $this->image_copy = imagecreatetruecolor($max_width, $max_height);
        imagecopyresampled($this->image_copy, $this->image_source, 0, 0, 0, 0, $max_width, $max_height, $this->getWidth(), $this->getHeight());

        switch($this->getType())
        {    
            case 1: 
				imagegif($this->image_copy, $toFile); 
			break;
			
            case 2: 
				imagejpeg($this->image_copy, $toFile, self::QUALITY_JPEG); 
			break;
			
            case 3: 
				imagepng($this->image_copy, $toFile); 
			break;
        }		
	}

}

?>

Et voici comment je m'en sert.

// Déclaration de la classe
$img = new Image("image.jpeg");

// Affichage simple
$img->resize("small");
// $img->resize("medium");
// $img->resize("big");

// Affichage et copie d'image
// $img->resize("small", "image_small.jpeg");
// $img->resize("medium", "image_medium.jpeg");
// $img->resize("big", "image_big.jpeg");
exit;

Désolé d'avoir reposté à la suite mais c'était pour que ce soit plus clair.

Merci à Sadeq pour m'avoir bien dirigé et m'avoir montré que je ne fesais pas du tout comme il falait.

++