Fonctions de redimensionnement d'images

Utilisation avec BD (redimensionner image + picto après upload) ou dans un dossier

Date de publication : 19 septembre 2008 , Date de mise à jour : 28 avril 2009

Par Jérôme Réaux (Pages de jreaux62)
 

Redimensionnement "à l'affichage", "physique" ("proportionnel", "non-proportionnel", "crop centré"), "signature" d'image...

16 commentaires · Donner une note à l'article (4)

               Version PDF (Miroir)   Version hors-ligne (Miroir)

I. Avant-Propos
II. Redimensionnement "à l'affichage"
III. Redimensionnement physique "proportionnel"
IV. Redimensionnement physique "non-proportionnel"
V. Redimensionnement physique "crop centré"
VI. "Signature" de l'image
VII. Utilisation avec base de données
VIII. Utilisation dans un dossier
IX. Conclusion


I. Avant-Propos

Quand on parle de "redimensionnement" d'image, il faut distinguer :
 
1- Redimensionnement "à l'affichage" :
ou comment afficher ses images à la taille d'affichage voulue ?
L'image elle-même n'est pas modifiée, seules ses dimensions d'affichage sont "recalculées".
- fonction fctaffichimage() : redimensionner des images "à l'affichage"
 
2- Redimensionnement "physique" :
modification du "poids" de l'image (nouvelle image aux dimensions spécifiées),
- fonction fctredimimage() : L'image finale est redimensionnée "en proportions".
- fonction fctdeformimage() : L'image finale est redimensionnée "sans proportions" (déformée).
- fonction fctcropimage() : L'image finale est "coupée" ("crop centré").
 
3- "Signature" d'image (petit "plus" !)
- fonction fcttexteimage() : "Signature" de l'image (ajout d'un texte à l'image : copyright, date, ou légende de l'image).
 
4- Utilisation :
- avec base de données : upload, traitement (redimensionner image + création picto), enregistrement.
- dans un dossier (répertoire) : redimensionner des images déjà présentes.
 
NB :
La 4ème partie est à considérer comme un exercice (néanmoins parfaitement fonctionnel).
C'est une mise en pratique de différents éléments enseignés dans les tutoriaux :
- traitement (upload, gestion d'erreurs, enregistrement, ...),
- redimensionnement d'image,
- base de données (connexion, affichage, modification, ...),
- formulaire (text + file),
- lire / écrire dans un répertoire ...
 
Des pages claires, faciles à lire :
- un maximum d'explications et commentaires dans les scripts,
- des noms de variables explicites,
- des paragraphes bien séparés.
Ce qui signifie qu'elles peuvent bien entendu :
- être optimisées et améliorées !
- être adaptées à vos besoins.
 
Traitement d'image (PHP) :
Voir bibliothèque GD - bibliothèque ImageMagick
 
Les formats traités ici : .jpg , .jpeg , .png
 
Autres formats :
- images .gif
Il semble que GD ne traite pas les gifs animés ou à fond transparent.
- images .bmp
Une solution consiste à convertir d'abord l'image en .png (ou en .wbmp)
voir bmp2png / png2bmp -  imagecreatefromwbmp


II. Redimensionnement "à l'affichage"

- Pour afficher une image en HTML, on utilise les options width et height de la balise <img /> : 

   <img alt="" src="repimg/monimage.jpg" width="150" height="100" />

- Pour afficher l'image en conservant ses proportions de départ, on n'indique qu'un seul des deux paramètres, le navigateur se chargeant de calculer le deuxième : 

   <img alt="" src="repimg/monimage.jpg" width="150" />   ou   <img alt="" src="repimg/monimage.jpg" height="100" />

- Mais comment faire pour que l'image tienne au mieux dans une "case" de W_max sur H_max pixels ?
HTML ne suffit plus ... Il faut "calculer" les dimensions optimales.
L'image source n'est pas modifiée, seules ses dimensions d'affichage sont "recalculées".

 
La fonction : fctaffichimage($img_Src, $W_max, $H_max)
 
La fonction affiche :  src="..." width="..." height="..." pour la balise <img ... />
 
Les paramètres
- $img_Src : URL (chemin + NOM) de l'image Source
- $W_max : LARGEUR maxi d'affichage --> ou 0
- $H_max : HAUTEUR maxi d'affichage --> ou 0
 
- si l'image est plus petite que la zone --> on conserve les dimensions de l'image source
- si $W_max ET $H_max non définis --> on conserve les dimensions de l'image source
- si $W_max = 0 --> LARGEUR auto (libre)
- si $H_max = 0 --> HAUTEUR auto (libre)
- sinon : on adapte les dimensions
 

Utilisation :
   <img alt="" <?php fctaffichimage('repimg/monimage.jpg', 150, 100) ?> />
fctaffichimage.php

<?php
// ---------------------------------------------------------------------------------------
// fonction de redimensionnement A L'AFFICHAGE
// ---------------------------------------------------------------------------------------
// La FONCTION : fctaffichimage($img_Src, $W_max, $H_max)
// Les parametres :
// - $img_Src : URL (chemin + NOM) de l image Source
// - $W_max : LARGEUR maxi finale ----> ou 0 : largeur libre
// - $H_max : HAUTEUR maxi finale ----> ou 0 : hauteur libre
// ---------------------------------------------------------------------------------------
// Affiche : src="..." width="..." height="..." pour la balise img
// Utilisation :
// <img alt="" <?php fctaffichimage('repimg/monimage.jpg', 120, 100) ?> />
// ---------------------------------------------------------------------------------------
function fctaffichimage($img_Src, $W_max, $H_max) {
 if (file_exists($img_Src)) {
   // ----------------------------------------------------
   // Lit les dimensions de l'image source
   $img_size = GetImageSize($img_Src);  
   $W_Src = $img_size[0]; // largeur source
   $H_Src = $img_size[1]; // hauteur source
   // ----------------------------------------------------
   if(!$W_max) { $W_max = 0; }
   if(!$H_max) { $H_max = 0; }
   // ----------------------------------------------------
   // Teste les dimensions tenant dans la zone
   $W_test = round($W_Src * ($H_max / $H_Src));
   $H_test = round($H_Src * ($W_max / $W_Src));
   // ----------------------------------------------------
   // si l image est plus petite que la zone
   if($W_Src<$W_max && $H_Src<$H_max) {
      $W = $W_Src;
      $H = $H_Src; 
   // sinon si $W_max et $H_max non definis
   } elseif($W_max==0 && $H_max==0) { 
      $W = $W_Src;
      $H = $H_Src; 
   // sinon si $W_max libre
   } elseif($W_max==0) {
      $W = $W_test;
      $H = $H_max;
   // sinon si $H_max libre
   } elseif($H_max==0) {
      $W = $W_max;
      $H = $H_test;
   // sinon les dimensions qui tiennent dans la zone
   } elseif($H_test > $H_max) {
      $W = $W_test; 
      $H = $H_max;
   } else {
      $W = $W_max;
      $H = $H_test;
   }
   // ----------------------------------------------------
 } else { // si le fichier image n existe pas
      $W = 0;
      $H = 0;
 }
 // ----------------------------------------------------
 // AFFICHE les dimensions optimales
 echo ' src="'.$img_Src.'" width="'.$W.'" height="'.$H.'"';
}
// Affiche :  src="..." width="..." height="..." pour la balise img
// ---------------------------------------------------------------------------------------
?>

III. Redimensionnement physique "proportionnel"

 
La fonction : fctredimimage ($W_max, $H_max, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
 
Redimensionnement "physique "en proportions" (conserve les proportions de l'image)
3 options
A- "normal" : image finale à HAUTEUR ET LARGEUR maxi fixes.
B- "hauteur" : image finale à HAUTEUR maxi fixe (largeur auto)
C- "largeur" : image finale à LARGEUR maxi fixe (hauteur auto)
NB :
Si l'image Source est plus petite que les dimensions indiquées : PAS de redimensionnement.
Mais on peut "forcer" le redimensionnement en ajoutant : $condition = 1; (voir le code)
 
Retourne la valeur :
- 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu,
- sinon rien (false)
 
Les paramètres :
- $W_max : LARGEUR maxi finale --> ou 0
- $H_max : HAUTEUR maxi finale --> ou 0
- $rep_Dst : répertoire de l'image de destination (déprotégé) --> ou ''
- $img_Dst : NOM de l'image de destination --> ou ''
- $rep_Src : répertoire de l'image source (déprotégé)
- $img_Src : NOM de l'image source
 
Les 3 options
A- si $W_max != 0 et $H_max != 0 --> à a LARGEUR maxi ET HAUTEUR maxi fixes
B- si $H_max != 0 et $W_max == 0 --> à HAUTEUR maxi fixe (largeur auto)
C- si $W_max == 0 et $H_max != 0 --> à LARGEUR maxi fixe (hauteur auto)
NB :
$rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
- si $rep_Dst = '' --> $rep_Dst = $rep_Src (même répertoire que l'image Source)
- si $img_Dst = '' --> $img_Dst = $img_Src (même nom que l'image Source)
- si $rep_Dst='' ET $img_Dst='' --> on écrase (remplace) l'image Source !
 
Extensions :
- acceptées (traitées ici) : .jpg , .jpeg , .png
- $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
Pour ajouter d'autres extensions :
Voir bibliothèque GD - bibliothèque ImageMagick
Utilisation :

<?php
$redimOK = fctredimimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($redimOK == 1) { echo 'Redimensionnement OK !'; }
?>
fctredimimage.php

<?php
// -----------------------------------------------------------------------------------------------------
// fonction de REDIMENSIONNEMENT physique "PROPORTIONNEL" et Enregistrement
// -----------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
// La FONCTION : fctredimimage ($W_max, $H_max, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
// Les parametres :
// - $W_max : LARGEUR maxi finale --> ou 0
// - $H_max : HAUTEUR maxi finale --> ou 0
// - $rep_Dst : repertoire de l image de Destination (deprotégé) --> ou '' (meme repertoire)
// - $img_Dst : NOM de l image de Destination --> ou '' (meme nom que l image Source)
// - $rep_Src : repertoire de l image Source (deprotégé)
// - $img_Src : NOM de l image Source
// -----------------------------------------------------------------------------------------------------
// 3 options :
// A- si $W_max != 0 et $H_max != 0 : a LARGEUR maxi ET HAUTEUR maxi fixes
// B- si $H_max != 0 et $W_max == 0 : image finale a HAUTEUR maxi fixe (largeur auto)
// C- si $W_max == 0 et $H_max != 0 : image finale a LARGEUR maxi fixe (hauteur auto)
// Si l'image Source est plus petite que les dimensions indiquees : PAS de redimensionnement.
// -----------------------------------------------------------------------------------------------------
// $rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
// - si $rep_Dst = ''   : $rep_Dst = $rep_Src (meme repertoire que l image Source)
// - si $img_Dst = '' : $img_Dst = $img_Src (meme nom que l image Source)
// - si $rep_Dst='' ET $img_Dst='' : on ecrase (remplace) l image source !
// -----------------------------------------------------------------------------------------------------
// NB : $img_Dst et $img_Src doivent avoir la meme extension (meme type mime) !
// Extensions acceptees (traitees ici) : .jpg , .jpeg , .png
// Pour ajouter d autres extensions : voir la bibliotheque GD ou ImageMagick
// (GD) NE fonctionne PAS avec les GIF ANIMES ou a fond transparent !
// -----------------------------------------------------------------------------------------------------
// UTILISATION (exemple) :
// $redimOK = fctredimimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
// if ($redimOK == 1) { echo 'Redimensionnement OK !';  }
// -----------------------------------------------------------------------------------------------------
function fctredimimage($W_max, $H_max, $rep_Dst, $img_Dst, $rep_Src, $img_Src) {
 // ------------------------------------------------------------------
 $condition = 0;
 // Si certains parametres ont pour valeur '' :
   if ($rep_Dst == '') { $rep_Dst = $rep_Src; } // (meme repertoire)
   if ($img_Dst == '') { $img_Dst = $img_Src; } // (meme nom)
 // ------------------------------------------------------------------
 // si le fichier existe dans le répertoire, on continue...
 if (file_exists($rep_Src.$img_Src) && ($W_max!=0 || $H_max!=0)) { 
   // ----------------------------------------------------------------
   // extensions acceptees : 
   $ExtfichierOK = '" jpg jpeg png"'; // (l espace avant jpg est important)
   // extension fichier Source
   $tabimage = explode('.',$img_Src);
   $extension = $tabimage[sizeof($tabimage)-1]; // dernier element
   $extension = strtolower($extension); // on met en minuscule
   // ----------------------------------------------------------------
   // extension OK ? on continue ...
   if (strpos($ExtfichierOK,$extension) != '') {
      // -------------------------------------------------------------
      // recuperation des dimensions de l image Src
      $img_size = getimagesize($rep_Src.$img_Src);
      $W_Src = $img_size[0]; // largeur
      $H_Src = $img_size[1]; // hauteur
      // -------------------------------------------------------------
      // condition de redimensionnement et dimensions de l image finale
      // -------------------------------------------------------------
      // A- LARGEUR ET HAUTEUR maxi fixes
      if ($W_max != 0 && $H_max != 0) {
         $ratiox = $W_Src / $W_max; // ratio en largeur
         $ratioy = $H_Src / $H_max; // ratio en hauteur
         $ratio = max($ratiox,$ratioy); // le plus grand
         $W = $W_Src/$ratio;
         $H = $H_Src/$ratio;   
         $condition = ($W_Src>$W) || ($W_Src>$H); // 1 si vrai (true)
      }      // -------------------------------------------------------------
      // B- HAUTEUR maxi fixe
      if ($W_max == 0 && $H_max != 0) {
         $H = $H_max;
         $W = $H * ($W_Src / $H_Src);
         $condition = $H_Src > $H_max; // 1 si vrai (true)
      }
      // -------------------------------------------------------------
      // C- LARGEUR maxi fixe
      if ($W_max != 0 && $H_max == 0) {
         $W = $W_max;
         $H = $W * ($H_Src / $W_Src);         
         $condition = $W_Src > $W_max; // 1 si vrai (true)
      }
      // -------------------------------------------------------------
      // on REDIMENSIONNE si la condition est vraie
      // -------------------------------------------------------------
      // Par defaut : 
	  // Si l'image Source est plus petite que les dimensions indiquees :
	  // PAS de redimensionnement.
	  // Mais on peut "forcer" le redimensionnement en ajoutant ici :
	  // $condition = 1;
      if ($condition == 1) {
         // ----------------------------------------------------------
         // creation de la ressource-image "Src" en fonction de l extension
         switch($extension) {
         case 'jpg':
         case 'jpeg':
           $Ress_Src = imagecreatefromjpeg($rep_Src.$img_Src);
           break;
         case 'png':
           $Ress_Src = imagecreatefrompng($rep_Src.$img_Src);
           break;
         }
         // ----------------------------------------------------------
         // creation d une ressource-image "Dst" aux dimensions finales
         // fond noir (par defaut)
         switch($extension) {
         case 'jpg':
         case 'jpeg':
           $Ress_Dst = imagecreatetruecolor($W,$H);
           break;
         case 'png':
           $Ress_Dst = imagecreatetruecolor($W,$H);
           // fond transparent (pour les png avec transparence)
           imagesavealpha($Ress_Dst, true);
           $trans_color = imagecolorallocatealpha($Ress_Dst, 0, 0, 0, 127);
           imagefill($Ress_Dst, 0, 0, $trans_color);
           break;
         }
         // ----------------------------------------------------------
         // REDIMENSIONNEMENT (copie, redimensionne, re-echantillonne)
         imagecopyresampled($Ress_Dst, $Ress_Src, 0, 0, 0, 0, $W, $H, $W_Src, $H_Src); 
         // ----------------------------------------------------------
         // ENREGISTREMENT dans le repertoire (avec la fonction appropriee)
         switch ($extension) { 
         case 'jpg':
         case 'jpeg':
           imagejpeg ($Ress_Dst, $rep_Dst.$img_Dst);
           break;
         case 'png':
           imagepng ($Ress_Dst, $rep_Dst.$img_Dst);
           break;
         }
         // ----------------------------------------------------------
         // liberation des ressources-image
         imagedestroy ($Ress_Src);
         imagedestroy ($Ress_Dst);
      }
      // -------------------------------------------------------------
   }
 }
// -----------------------------------------------------------------------------------------------------
 // si le fichier a bien ete cree
 if ($condition == 1 && file_exists($rep_Dst.$img_Dst)) { return true; }
 else { return false; }
}
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
?>

IV. Redimensionnement physique "non-proportionnel"

 
La fonction : fctdeformimage ($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
 
Redimensionnement physique "non-proportionnel" (les proportions de l'image NE sont PAS conservées : elle sera donc déformée)
3 options
A- "normal" : image finale à HAUTEUR ET LARGEUR fixes.
B- "hauteur" : image finale à HAUTEUR fixe (largeur de la source)
C- "largeur" : image finale à LARGEUR fixe (hauteur de la source)
NB :
Dans TOUS les cas : redimensionnement non-proportionnel de l'image.
 
Retourne la valeur :
- 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu,
- sinon rien (false)
 
Les paramètres :
- $W_fin : LARGEUR finale --> ou 0
- $H_fin : HAUTEUR finale --> ou 0
- $rep_Dst : répertoire de l'image de destination (déprotégé) --> ou ''
- $img_Dst : NOM de l'image de destination --> ou ''
- $rep_Src : répertoire de l'image source (déprotégé)
- $img_Src : NOM de l'image source
 
Les 3 options
A- si $W_fin != 0 et $H_fin != 0 --> à LARGEUR ET HAUTEUR fixes
B- si $H_fin != 0 et $W_fin == 0 --> à HAUTEUR fixe (largeur de la source)
C- si $W_fin == 0 et $H_fin != 0 --> à LARGEUR fixe (hauteur de la source)
NB :
$rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
- si $rep_Dst = '' --> $rep_Dst = $rep_Src (même répertoire que l'image Source)
- si $img_Dst = '' --> $img_Dst = $img_Src (même nom que l'image Source)
- si $rep_Dst='' ET $img_Dst='' --> on écrase (remplace) l'image Source !
 
Extensions :
- acceptées (traitées ici) : .jpg , .jpeg , .png
- $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
Pour ajouter d'autres extensions :
Voir bibliothèque GD - bibliothèque ImageMagick
Utilisation :
<?php
$deformOK = fctdeformimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($deformOK == 1) { echo 'Redimensionnement OK !'; }
?>
fctdeformimage.php
<?php
// -----------------------------------------------------------------------------------------------------
// fonction de REDIMENSIONNEMENT physique "NON-PROPORTIONNEL" et Enregistrement
// -----------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
// La FONCTION : fctdeformimage ($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
// Les parametres :
// - $W_fin : LARGEUR finale --> ou 0
// - $H_fin : HAUTEUR finale --> ou 0
// - $rep_Dst : repertoire de l image de Destination (deprotégé) --> ou '' (meme repertoire)
// - $img_Dst : NOM de l image de Destination --> ou '' (meme nom que l image Source)
// - $rep_Src : repertoire de l image Source (deprotégé)
// - $img_Src : NOM de l image Source
// -----------------------------------------------------------------------------------------------------
// 3 options :
// A- si $W_fin != 0 et $H_fin != 0 : image finale a LARGEUR ET HAUTEUR fixes
// B- si $H_fin != 0 et $W_fin == 0 : image finale a HAUTEUR fixe (largeur auto)
// C- si $W_fin == 0 et $H_fin != 0 : image finale a LARGEUR fixe (hauteur auto)
// Dans TOUS les cas : redimensionnement non-proportionnel
// -----------------------------------------------------------------------------------------------------
// $rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
// - si $rep_Dst = ''   : $rep_Dst = $rep_Src (meme repertoire que l image Source)
// - si $img_Dst = '' : $img_Dst = $img_Src (meme nom que l image Source)
// - si $rep_Dst='' ET $img_Dst='' : on ecrase (remplace) l image source !
// -----------------------------------------------------------------------------------------------------
// NB : $img_Dst et $img_Src doivent avoir la meme extension (meme type mime) !
// Extensions acceptees (traitees ici) : .jpg , .jpeg , .png
// Pour ajouter d autres extensions : voir la bibliotheque GD ou ImageMagick
// (GD) NE fonctionne PAS avec les GIF ANIMES ou a fond transparent !
// -----------------------------------------------------------------------------------------------------
// UTILISATION (exemple) :
// $deformOK = fctredimimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
// if ($deformOK == 1) { echo 'Redimensionnement OK !';  }
// -----------------------------------------------------------------------------------------------------
function fctdeformimage($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src) {
 // ------------------------------------------------------------------
 // Si certains parametres ont pour valeur '' :
   if ($rep_Dst == '') { $rep_Dst = $rep_Src; } // (meme repertoire)
   if ($img_Dst == '') { $img_Dst = $img_Src; } // (meme nom)
 // ------------------------------------------------------------------
 // si le fichier existe dans le répertoire, on continue...
 if (file_exists($rep_Src.$img_Src) && ($W_fin!=0 || $H_fin!=0)) { 
   // ----------------------------------------------------------------
   // extensions acceptees : 
   $ExtfichierOK = '" jpg jpeg png"'; // (l espace avant jpg est important)
   // extension fichier Source
   $tabimage = explode('.',$img_Src);
   $extension = $tabimage[sizeof($tabimage)-1]; // dernier element
   $extension = strtolower($extension); // on met en minuscule
   // ----------------------------------------------------------------
   // extension OK ? on continue ...
   if (strpos($ExtfichierOK,$extension) != '') {
      // -------------------------------------------------------------
      // recuperation des dimensions de l image Src
      $img_size = getimagesize($rep_Src.$img_Src);
      $W_Src = $img_size[0]; // largeur
      $H_Src = $img_size[1]; // hauteur
      // -------------------------------------------------------------
      // condition de redimensionnement et dimensions de l image finale
      // Dans TOUS les cas : redimensionnement non-proportionnel
      // -------------------------------------------------------------
      // A- LARGEUR ET HAUTEUR fixes
      if ($W_fin != 0 && $H_fin != 0) {
         $W = $W_Src;
         $H = $H_Src;
      }
      // -------------------------------------------------------------
      // B- HAUTEUR fixe
      if ($W_fin == 0 && $H_fin != 0) {
         $W = $W_Src;
         $H = $H_fin;
      }
      // -------------------------------------------------------------
      // C- LARGEUR fixe
      if ($W_fin != 0 && $H_fin == 0) {
         $W = $W_fin;
         $H = $H_Src;
      }
      // -------------------------------------------------------------
      // REDIMENSIONNEMENT
      // ----------------------------------------------------------
      // creation de la ressource-image "Src" en fonction de l extension
      switch($extension) {
      case 'jpg':
      case 'jpeg':
        $Ress_Src = imagecreatefromjpeg($rep_Src.$img_Src);
        break;
      case 'png':
        $Ress_Src = imagecreatefrompng($rep_Src.$img_Src);
        break;
      }
      // ----------------------------------------------------------
      // creation d une ressource-image "Dst" aux dimensions finales
      // fond noir (par defaut)
      switch($extension) {
      case 'jpg':
      case 'jpeg':
        $Ress_Dst = imagecreatetruecolor($W,$H);
        break;
      case 'png':
        $Ress_Dst = imagecreatetruecolor($W,$H);
        // fond transparent (pour les png avec transparence)
        imagesavealpha($Ress_Dst, true);
        $trans_color = imagecolorallocatealpha($Ress_Dst, 0, 0, 0, 127);
        imagefill($Ress_Dst, 0, 0, $trans_color);
        break;
      }
      // ----------------------------------------------------------
      // REDIMENSIONNEMENT (copie, redimensionne, re-echantillonne)
      imagecopyresampled($Ress_Dst, $Ress_Src, 0, 0, 0, 0, $W, $H, $W_Src, $H_Src); 
      // ----------------------------------------------------------
      // ENREGISTREMENT dans le repertoire (avec la fonction appropriee)
      switch ($extension) { 
      case 'jpg':
      case 'jpeg':
        imagejpeg ($Ress_Dst, $rep_Dst.$img_Dst);
        break;
      case 'png':
        imagepng ($Ress_Dst, $rep_Dst.$img_Dst);
        break;
      }
      // ----------------------------------------------------------
      // liberation des ressources-image
      imagedestroy ($Ress_Src);
      imagedestroy ($Ress_Dst);
      }
      // -------------------------------------------------------------
   }
 }
// -----------------------------------------------------------------------------------------------------
 // si le fichier a bien ete cree
 if (file_exists($rep_Dst.$img_Dst)) { return true; }
 else { return false; }
}
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
?>

V. Redimensionnement physique "crop centré"

 
La fonction : fctcropimage ($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
 
Redimensionnement physique "crop centré" (l'image est "coupée" aux dimensions voulues)
4 options
A- "normal" : crop "centré" aux dimensions indiquées
B- "hauteur" : crop "centré" de la hauteur indiquée (même largeur que la source)
C- "largeur" : crop "centré" de la largeur indiquée (même hauteur que la source)
D- "cas spécial" : crop "carré" à la plus petite dimension de l'image source
 
Retourne la valeur :
- 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu,
- sinon rien (false)
 
Les paramètres :
- $W_fin : LARGEUR finale --> ou 0
- $H_fin : HAUTEUR finale --> ou 0
- $rep_Dst : répertoire de l'image de destination (déprotégé) --> ou ''
- $img_Dst : NOM de l'image de destination --> ou ''
- $rep_Src : répertoire de l'image source (déprotégé)
- $img_Src : NOM de l'image source
 
Les 4 options
A- si $W_fin != 0 et $H_fin != 0 --> crop aux dimensions indiquées
B- si $W_fin == 0 et $H_fin != 0 --> crop en HAUTEUR (même largeur que la source)
C- si $W_fin != 0 et $H_fin == 0 --> crop en LARGEUR (même hauteur que la source)
D- si $W_fin == 0 et $H_fin == 0 --> (cas spécial) crop "carré" à la plus petite dimension de l'image source
 
NB :
$rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
- si $rep_Dst = '' --> $rep_Dst = $rep_Src (même répertoire)
- si $img_Dst = '' --> $img_Dst = $img_Src (même nom)
- si $rep_Dst='' ET $img_Dst='' --> on écrase (remplace) l'image source !
 
Extensions :
- acceptées (traitées ici) : .jpg , .jpeg , .png
- $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
Pour ajouter d'autres extensions :
Voir bibliothèque GD - bibliothèque ImageMagick
Utilisation :
<?php
$cropOK = fctcropimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($cropOK == 1) { echo 'Crop centré OK !'; }
?>
ASTUCE : picto toujours carré
<?php
$redim = fctcropimage(0,0,$repDest,$imageDest,$repSource,$imageSource);
$redim = fctredimimage(100,0,'','',$repDest,$imageDest);
if ($redim==true) { echo 'picto carré créé !'; }
?>
fctcropimage.php
<?php
// -----------------------------------------------------------------------------------------------------
// fonction de REDIMENSIONNEMENT physique "CROP CENTRE" et Enregistrement
// -----------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
// La FONCTION : fctcropimage ($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
// Les parametres :
// - $W_fin : LARGEUR finale --> ou 0
// - $H_fin : HAUTEUR finale --> ou 0
// - $rep_Dst : repertoire de l image de Destination (déprotégé) --> ou ''
// - $img_Dst : NOM de l image de Destination --> ou ''
// - $rep_Src : repertoire de l image Source (déprotégé)
// - $img_Src : NOM de l image Source
// -----------------------------------------------------------------------------------------------------
// 4 options :
// A- si $W_fin != 0 et $H_fin != 0 : crop aux dimensions indiquees
// B- si $W_fin == 0 et $H_fin != 0 : crop en HAUTEUR (meme largeur que la source)
// C- si $W_fin != 0 et $H_fin == 0 : crop en LARGEUR (meme hauteur que la source)
// D- si $W_fin == 0 et $H_fin == 0 : (special) crop "carre" a la plus petite dimension de l image source
// -----------------------------------------------------------------------------------------------------
// $rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
// - si $rep_Dst = '' --> $rep_Dst = $rep_Src (meme repertoire que le repertoire Source)
// - si $img_Dst = '' --> $img_Dst = $img_Src (meme nom que l image Source)
// - si $rep_Dst = '' ET $img_Dst = '' --> on ecrase (remplace) l image source ($img_Src) !
// -----------------------------------------------------------------------------------------------------
// NB : $img_Dst et $img_Src doivent avoir la meme extension (meme type mime) !
// Extensions acceptees (traitees ici) : .jpg , .jpeg , .png
// Pour ajouter d autres extensions : voir la bibliotheque GD ou ImageMagick
// (GD) NE fonctionne PAS avec les GIF ANIMES ou a fond transparent !
// -----------------------------------------------------------------------------------------------------
// UTILISATION (exemple) :
// $cropOK = fctcropimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
// if ($cropOK == 1) { echo 'Crop centré OK !';  }
// -----------------------------------------------------------------------------------------------------
function fctcropimage($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src) {
 // ------------------------------------------------------------------
 $condition = 0;
 // Si certains parametres ont pour valeur '' :
   if ($rep_Dst == '') { $rep_Dst = $rep_Src; } // (meme repertoire)
   if ($img_Dst == '') { $img_Dst = $img_Src; } // (meme nom)
 // ------------------------------------------------------------------
 // si le fichier existe dans le répertoire, on continue...
 if (file_exists($rep_Src.$img_Src)) { 
   // ----------------------------------------------------------------
   // extensions acceptees : 
   $ExtfichierOK = '" jpg jpeg png"'; // (l espace avant jpg est important)
   // extension fichier Source
   $tabimage = explode('.',$img_Src);
   $extension = $tabimage[sizeof($tabimage)-1]; // dernier element
   $extension = strtolower($extension); // on met en minuscule
   // ----------------------------------------------------------------
   // extension OK ? on continue ...
   if (strpos($ExtfichierOK,$extension) != '') {
      // -------------------------------------------------------------
      $condition = 1;
      // -------------------------------------------------------------
      // recuperation des dimensions de l image Source
      $img_size = getimagesize($rep_Src.$img_Src);
      $W_Src = $img_size[0]; // largeur
      $H_Src = $img_size[1]; // hauteur
      // -------------------------------------------------------------
      // condition de crop et dimensions de l image finale
      // -------------------------------------------------------------
      // A- crop aux dimensions indiquees
      if ($W_fin != 0 && $H_fin != 0) {
         $W = $W_fin;
         $H = $H_fin;
      }      // -------------------------------------------------------------
      // B- crop en HAUTEUR (meme largeur que la source)
      if ($W_fin == 0 && $H_fin != 0) {
         $H = $H_fin;
         $W = $W_Src;
      }
      // -------------------------------------------------------------
      // C- crop en LARGEUR (meme hauteur que la source)
      if ($W_fin != 0 && $H_fin == 0) {
         $W = $W_fin;
         $H = $H_Src;         
      }
      // D- crop "carre" a la plus petite dimension de l image source
      if ($W_fin == 0 && $H_fin == 0) {
         if ($W_Src >= $H_Src) {
         $W = $H_Src;
         $H = $H_Src;
         } else {
         $W = $W_Src;
         $H = $W_Src;
         }   
      }
      // -------------------------------------------------------------
      // creation de la ressource-image "Src" en fonction de l extension
      switch($extension) {
      case 'jpg':
      case 'jpeg':
         $Ress_Src = imagecreatefromjpeg($rep_Src.$img_Src);
         break;
      case 'png':
         $Ress_Src = imagecreatefrompng($rep_Src.$img_Src);
         break;
      }
      // ----------------------------------------------------------
      // creation d une ressource-image "Dst" aux dimensions finales
      // fond noir (par defaut)
      switch($extension) {
      case 'jpg':
      case 'jpeg':
         $Ress_Dst = imagecreatetruecolor($W,$H);
         // fond blanc
         $blanc = imagecolorallocate ($Ress_Dst, 255, 255, 255);
         imagefill ($Ress_Dst, 0, 0, $blanc);
         break;
      case 'png':
         $Ress_Dst = imagecreatetruecolor($W,$H);
         // fond transparent (pour les png avec transparence)
         imagesavealpha($Ress_Dst, true);
         $trans_color = imagecolorallocatealpha($Ress_Dst, 0, 0, 0, 127);
         imagefill($Ress_Dst, 0, 0, $trans_color);
         break;
      }
      // -------------------------------------------------------------
      // CENTRAGE du crop
      // coordonnees du point d origine Scr : $X_Src, $Y_Src
      // coordonnees du point d origine Dst : $X_Dst, $Y_Dst
      // dimensions de la portion copiee : $W_copy, $H_copy
      // -------------------------------------------------------------
      // CENTRAGE en largeur
      if ($W_fin == 0) {
         if ($H_fin == 0 && $W_Src < $H_Src) {
            $X_Src = 0;
            $X_Dst = 0;
            $W_copy = $W_Src;
         } else {
            $X_Src = 0;
            $X_Dst = ($W - $W_Src) /2;
            $W_copy = $W_Src;
         }
      } else {
         if ($W_Src > $W) {
            $X_Src = ($W_Src - $W) /2;
            $X_Dst = 0;
            $W_copy = $W;
         } else {
            $X_Src = 0;
            $X_Dst = ($W - $W_Src) /2;
            $W_copy = $W_Src;
         }
      }
      // -------------------------------------------------------------
      // CENTRAGE en hauteur
      if ($H_fin == 0) {
         if ($W_fin == 0 && $H_Src < $W_Src) {
            $Y_Src = 0;
            $Y_Dst = 0;
            $H_copy = $H_Src;
         } else {
            $Y_Src = 0;
            $Y_Dst = ($H - $H_Src) /2;
            $H_copy = $H_Src;
         }
      } else {
         if ($H_Src > $H) {
            $Y_Src = ($H_Src - $H) /2;
            $Y_Dst = 0;
            $H_copy = $H;
         } else {
            $Y_Src = 0;
            $Y_Dst = ($H - $H_Src) /2;
            $H_copy = $H_Src;
         }
      }
      // -------------------------------------------------------------
      // CROP par copie de la portion d image selectionnee
      imagecopyresampled ($Ress_Dst, $Ress_Src, $X_Dst, $Y_Dst, $X_Src, $Y_Src, $W_copy, $H_copy, $W_copy, $H_copy);
      // ----------------------------------------------------------
      // ENREGISTREMENT dans le repertoire (avec la fonction appropriee)
      switch ($extension) { 
      case 'jpg':
      case 'jpeg':
         imagejpeg ($Ress_Dst, $rep_Dst.$img_Dst);
         break;
      case 'png':
         imagepng ($Ress_Dst, $rep_Dst.$img_Dst);
         break;
      }
      // ----------------------------------------------------------
      // liberation des ressources-image
      imagedestroy ($Ress_Src);
      imagedestroy ($Ress_Dst);
   }
   // -------------------------------------------------------------
 }
// -----------------------------------------------------------------------------------------------------
 // si le fichier a bien ete cree
 if ($condition == 1 && file_exists($rep_Dst.$img_Dst)) { return true; }
 else { return false; }
}
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
?>

VI. "Signature" de l'image

 
La fonction : fcttexteimage ($chaine, $rep_Dst, $img_Dst, $rep_Src, $img_Src, $position)
 
"Signature" de l'image (ajout d'un texte à l'image : copyright, date, ou légende de l'image)
Un petit "plus" !
 
Retourne la valeur :
- 1 (vrai) si le texte a bien été ajouté,
- sinon rien (false)
 
Les paramètres :
- $chaine : TEXTE à ajouter
- $rep_Dst : répertoire de l'image de Destination (deprotégé) --> ou '' (même répertoire)
- $img_Dst : NOM de l image de Destination --> ou '' (même nom que l'image Source)
- $rep_Src : répertoire de l'image Source (déprotégé)
- $img_Src : NOM de l'image Source
- $position : position du texte sur l'image
NB :
ATTENTION : si le texte est TROP long, il risque d'être tronqué ! (Privilégiez donc les textes courts)
 
Positionnement du texte sur l'image (valeurs possibles) :
- $position = 'HG' --> en Haut à Gauche (valeur par défaut)
- $position = 'HD' --> en Haut à Droite
- $position = 'HC' --> en Haut au Centre
- $position = 'BG' --> en Bas à Gauche
- $position = 'BD' --> en Bas à Droite
- $position = 'BC' --> en Bas au Centre
 
NB :
$rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
- si $rep_Dst = '' --> $rep_Dst = $rep_Src (même répertoire)
- si $img_Dst = '' --> $img_Dst = $img_Src (même nom)
- si $rep_Dst='' ET $img_Dst='' --> on écrase (remplace) l'image source !
 
Extensions :
- acceptées (traitées ici) : .jpg , .jpeg , .png
- $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
Pour ajouter d'autres extensions :
Voir bibliothèque GD - bibliothèque ImageMagick
Utilisation (copyright, date, ou legende de l'image) :
<?php
$texteOK = fcttexteimage('copyright : MOI','reppicto/','monpicto.jpg','repimage/','monimage.jpg','BG');
if ($texteOK == 1) { echo 'Ajout du texte OK !';  }
?>
fcttexteimage.php
<?php
// -----------------------------------------------------------------------------------------------------
// fonction d AJOUT DE TEXTE a une image et Enregistrement
// -----------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si l ajout de texte a bien ete ajoute, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
// La FONCTION : fcttexteimage ($chaine, $rep_Dst, $img_Dst, $rep_Src, $img_Src, $position)
// Les parametres :
// - $chaine : TEXTE a ajouter
// - $rep_Dst : repertoire de l image de Destination (deprotégé) --> ou '' (meme repertoire)
// - $img_Dst : NOM de l image de Destination --> ou '' (meme nom que l image Source)
// - $rep_Src : repertoire de l image Source (deprotégé)
// - $img_Src : NOM de l image Source
// - $position : position du texte sur l image
// -----------------------------------------------------------------------------------------------------
// ATTENTION : si le texte est TROP long, il risque d etre tronque !
// -----------------------------------------------------------------------------------------------------
// Position du texte sur l image (valeurs possibles) :
// $position = 'HG' --> en Haut a Gauche (valeur par defaut)
// $position = 'HD' --> en Haut a Droite
// $position = 'HC' --> en Haut au Centre
// $position = 'BG' --> en Bas a Gauche
// $position = 'BD' --> en Bas a Droite
// $position = 'BC' --> en Bas au Centre
// -----------------------------------------------------------------------------------------------------
// $rep_Dst : il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod)
// - si $rep_Dst = ''   : $rep_Dst = $rep_Src (meme repertoire que l image Source)
// - si $img_Dst = '' : $img_Dst = $img_Src (meme nom que l image Source)
// - si $rep_Dst='' ET $img_Dst='' : on ecrase (remplace) l image source !
// -----------------------------------------------------------------------------------------------------
// NB : $img_Dst et $img_Src doivent avoir la meme extension (meme type mime) !
// Extensions acceptees (traitees ici) : .jpg , .jpeg , .png
// Pour ajouter d autres extensions : voir la bibliotheque GD ou ImageMagick
// (GD) NE fonctionne PAS avec les GIF ANIMES ou a fond transparent !
// -----------------------------------------------------------------------------------------------------
// UTILISATION (exemple copyright, ou legende de l image) :
// $texteOK = fcttexteimage('copyright : MOI','reppicto/','monpicto.jpg','repimage/','monimage.jpg','BG');
// if ($texteOK == 1) { echo 'Ajout du texte OK !';  }
// -----------------------------------------------------------------------------------------------------
function fcttexteimage($chaine, $rep_Dst, $img_Dst, $rep_Src, $img_Src, $position) {
 $condition = 0;
 // ------------------------------------------------------------------
   $position = strtoupper($position); // on met en majuscule (par defaut)
 // Si certains parametres ont pour valeur '' :
   if ($rep_Dst == '') { $rep_Dst = $rep_Src; } // (meme repertoire)
   if ($img_Dst == '') { $img_Dst = $img_Src; } // (meme nom)
   if ($position == '') { $position = 'BG'; } // en Bas A Gauche (valeur par defaut)
 // ------------------------------------------------------------------
 // si le fichier existe dans le répertoire, on continue...
 if (file_exists($rep_Src.$img_Src) && $chaine!='') { 
   // ----------------------------------------------------------------
   // extensions acceptees : 
   $ExtfichierOK = '" jpg jpeg png"'; // (l espace avant jpg est important)
   // extension fichier Source
   $tabimage = explode('.',$img_Src);
   $extension = $tabimage[sizeof($tabimage)-1]; // dernier element
   $extension = strtolower($extension); // on met en minuscule
   // ----------------------------------------------------------------
   // extension OK ? on continue ...
   if (strpos($ExtfichierOK,$extension) != '') {
      // -------------------------------------------------------------
      // recuperation des dimensions de l image Src
      $img_size = getimagesize($rep_Src.$img_Src);
      $W_Src = $img_size[0]; // largeur
      $H_Src = $img_size[1]; // hauteur
      // -------------------------------------------------------------
      // creation de la ressource-image "Dst" en fonction de l extension
      // (a partir de l image source)
      switch($extension) {
      case 'jpg':
      case 'jpeg':
        $Ress_Dst = imagecreatefromjpeg($rep_Src.$img_Src);
        break;
      case 'png':
        $Ress_Dst = imagecreatefrompng($rep_Src.$img_Src);
        break;
      }
      // -------------------------------------------------------------
      // creation de l image TEXTE
      // -------------------------------------------------------------
      // dimension de l image "Txt" en fonction :
      // - de la longueur du texte a afficher
      // - des dimensions des caracteres (7x15 pixels par caractere)
      // ATTENTION : si le texte est TROP long, il risque d etre tronque !
      $W = strlen($chaine) * 7;
      if ($W > $W_Src) { $W = $W_Src; }
      $H = 15; // 15 pixels de haut (par defaut)
      // -------------------------------------------------------------
      // creation de la ressource-image "Txt" (en fonction de l extension)
      switch($extension) {
      case 'jpg':
      case 'jpeg':
      case 'png':
        $Ress_Txt = imagecreatetruecolor($W,$H);
        // Couleur du Fond : blanc
        $blanc = imagecolorallocate ($Ress_Txt, 255, 255, 255);
        imagefill ($Ress_Txt, 0, 0, $blanc);
        // Couleur du Texte : noir
        $textcolor = imagecolorallocate($Ress_Txt, 0, 0, 0);
        // Ecriture du TEXTE
        imagestring($Ress_Txt, 3, 0, 0, $chaine, $textcolor);
        break;
      }
      // -------------------------------------------------------------
      // positionnement du TEXTE sur l image
      // -------------------------------------------------------------
      if ($position == 'HG') {
         $X_Dest = 0;
         $Y_Dest = 0;
      }
      if ($position == 'HD') {
         $X_Dest = $W_Src - $W;
         $Y_Dest = 0;
      }
      if ($position == 'HC') {
         $X_Dest = ($W_Src - $W)/2;
         $Y_Dest = 0;
      }
      if ($position == 'BG') {
         $X_Dest = 0;
         $Y_Dest = $H_Src - $H;
      }
      if ($position == 'BD') {
         $X_Dest = $W_Src - $W;
         $Y_Dest = $H_Src - $H;
      }
      if ($position == 'BC') {
         $X_Dest = ($W_Src - $W)/2;
         $Y_Dest = $H_Src - $H;
      }
      // -------------------------------------------------------------
      // copie par fusion de l image "Txt" sur l image "Dst"
      // (avec transparence de 50%)
      // -------------------------------------------------------------
      imagecopymerge ($Ress_Dst, $Ress_Txt, $X_Dest, $Y_Dest, 0, 0, $W, $H, 50);
      // ----------------------------------------------------------
      // ENREGISTREMENT dans le repertoire (en fonction de l extension)
      switch ($extension) { 
      case 'jpg':
      case 'jpeg':
        imagejpeg ($Ress_Dst, $rep_Dst.$img_Dst);
        $condition = 1;
        break;
      case 'png':
        imagepng ($Ress_Dst, $rep_Dst.$img_Dst);
        $condition = 1;
        break;
      }
      // -------------------------------------------------------------
      // liberation des ressources-image
      imagedestroy ($Ress_Txt);
      imagedestroy ($Ress_Dst);
      // -------------------------------------------------------------
   }
 }
// -----------------------------------------------------------------------------------------------------
 // si le fichier a bien ete cree
 if ($condition == 1 && file_exists($rep_Dst.$img_Dst)) { return true; }
 else { return false; }
}
// retourne : 1 (vrai) si l ajout de texte a bien ete ajoute, sinon rien (false)
// -----------------------------------------------------------------------------------------------------
?>

VII. Utilisation avec base de données

But :
- Uploader des images sans se soucier de leur "poids", puisqu'on va les redimensionner pour s'adapter aux dimensions d'affichage final sur notre site (et créer des pictos à la volée). En effet, les visiteurs peuvent très bien charger des images "haute résolution", très gourmandes en "temps de chargement" et en espace disque.
- Adapter (si nécessaire) après "upload" la taille des images à nos besoins (gain de temps de chargement et d'espace disque),
- Créer des images de prévisualisation (pictos) à la volée.
- Enregistrer image et picto dans unrépertoire
- Enregistrer leurs noms (et un commentaire) dans la base de données.
 
3 étapes
1- Liste : liste des images présentes + options AJOUTER - MODIFIER - SUPPRIMER
2- Formulaire : affichage du formulaire (en fonction de l'option choisie)
3- Traitement : (faisant appel aux fonctions de redimensionnement "physique")

 
- gestion des erreurs (upload),
(options AJOUTER - MODIFIER) :
- vérification des dimensions de l'image "uploadée", et redimensionnement automatique,
- création automatique d'un picto,
- enregistrement des photo et picto dans un dossier (répertoire avec "droits en écriture"),
- enregistrement de leurs noms (et d'un commentaire) dans la table (base de données).
(option SUPPRIMER) :
- suppression de la fiche dans la table,
- suppression des photo et picto concernées dans le dossier.
 
On a donc besoin :
 
1- d'une base de données MySQL (MABASE),
dans laquelle est créée une table (MATABLE) contenant au moins les champs suivants :
- NUM (INT - 11 - auto-incrementé : clé primaire - NotNull)
- COMMENT1 (VARCHAR - 255 - Null)
- PHOTO1 (VARCHAR - 255 - Null)
- PICTO1 (VARCHAR - 255 - Null)
 
2- d'un dossier déprotégé (repIMAGES) (avec "droits en écriture").
 
3- des fichiers :
- _connexion.php : contient les paramètres de connexion à votre base
- MONFICHIER-LISTE.php
- MONFICHIER-FORM.php
- MONFICHIER-TRAITER.php
 
4- des fonctions de redimensionnement :
- fctaffichimage.php
- fctredimimage.php
- fctcropimage.php
Création de la table MATABLE
CREATE TABLE `MATABLE` (
`NUM` INT( 11 ) NOT NULL AUTO_INCREMENT ,
`COMMENT1` VARCHAR( 255 ) ,
`PHOTO1` VARCHAR( 255 ) ,
`PICTO1` VARCHAR( 255 ) ,
PRIMARY KEY ( `NUM` ) 
) TYPE = MYISAM ;
_connexion.php
<?php
// ---------------------------------------------------------------------------------------
// Paramètres persos
$host = "localhost"; // voir hébergeur
$user = "login"; // identifiant de votre BD (vide ou "root" en local)
$pass = "password"; // mot de passe de votre BD (vide en local)
$bdd = "MABASE"; // nom de la BD
// ---------------------------------------------------------------------------------------
// connexion
@mysql_connect($host,$user,$pass) or die("Impossible de se connecter");
@mysql_select_db("$bdd") or die("Impossible de se connecter");
// ---------------------------------------------------------------------------------------
?>
LISTE :
dans cet exemple :
- affichage en ligne des pictos des images présentes dans la table de la base de données,
- avec pour chacune des boutons "Modifier" et "Supprimer"
- et un bouton "Ajouter Nouveau"
MONFICHIER-LISTE.php
<?php
// connexion a la base de donnees
   include("_connexion.php");
// FONCTION de redimensionnement "a l affichage"
   include("fctaffichimage.php");
// -----------------------------------------------------------------------------------------------------
// La base de donnees (MABASE) avec une table (MATABLE)
// La table doit contenir (au moins) les champs suivants :
// - NUM      (INT - 11 - auto-incremente - NotNull)
// - COMMENT1 (VARCHAR - 255 - Null)
// - PHOTO1   (VARCHAR - 255 - Null))
// - PICTO1   (VARCHAR - 255 - Null)
// Important : conserver le champ COMMENT1, il est necessaire en mode AJOUTER
// -----------------------------------------------------------------------------------------------------
// mettre le nom de la table dans une variable :
   $table = 'MATABLE';
// REMARQUE : on peut utiliser ce fichier pour PLUSIEURS TABLES (de meme structure)
// $table = $_GET['CAT'];
// (preciser le nom de la table a l'appel du fichier : MONFICHIER-LISTE.php?CAT=MATABLE)
// -----------------------------------------------------------------------------------------------------
// Les photos et pictos sont stockes dans un dossier deprotege en ecriture
   $chemincourt = 'repIMAGES/';
// -----------------------------------------------------------------------------------------------------
// sélection de toutes les fiches de la table
   $query = 'SELECT * FROM '.$table.' WHERE PHOTO1<>"" ORDER BY NUM DESC'; 
   $result = mysql_query($query)  or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
    <title>MONFICHIER-LISTE.php</title>
</head>
<body><center>
<div>
   <?php echo 'TABLE '.$table; ?><br/>
   <a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=AJOUTER">AJOUTER NOUVEAU</a>
</div>
<div>     
<table border="1">
   <tr>
<?php
// -----------------------------------------------------------------------------------------------------
// AFFICHAGE tant qu'il y a des fiches
while ($val = mysql_fetch_array($result)) 
{ ?>
    <td>
      <a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=MODIFIER&NUM=<?php echo $val['NUM']; ?>">
      MODIFIER</a>&nbsp;
      <a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=SUPPRIMER&NUM=<?php echo $val['NUM']; ?>">
      Supprimer</a><br/>
      <?php echo $val[COMMENT1]; ?><br/>
      <?php if ($val[PICTO1] != "") { ?>
         <img alt="" <?php fctaffichimage($chemincourt.$val['PICTO1'], 100, 100) ?>>
      <?php } ?>
    </td>
<?php
} // fin while
// -----------------------------------------------------------------------------------------------------
?>
   </tr>      
</table>
</div>
</center></body></html>
<?php // liberation de la ressource et deconnexion
mysql_free_result($result);
mysql_close();
?>
FORMULAIRE :
dans cet exemple, on affiche :
- le bon formulaire en fonction de l'option choisie (ajouter, modifier, supprimer)
- la fiche concernée (photo et commentaire)
MONFICHIER-FORM.php
<?php
// connexion a la base de donnees
   include("_connexion.php");
// -----------------------------------------------------------------------------------------------------
// Répertoire des photos et pictos (déprotégé)
   $chemincourt = 'repIMAGES/';
// -----------------------------------------------------------------------------------------------------
// recuperation du nom de la TABLE
   $table=$_GET['CAT'];
// recuperation du mode de traitement (AJOUTER - MODIFIER - SUPPRIMER)
   $TRAITER=$_GET['TRAITER'];
// -----------------------------------------------------------------------------------------------------
   if ($TRAITER == 'MODIFIER' || $TRAITER == 'SUPPRIMER') {
      //on recupere aussi le numero de la fiche
      $NUM=$_GET['NUM'];
      // on recupere les donnees la fiche numero NUM
      $query = 'SELECT * FROM '.$table.' WHERE NUM = '. $NUM; 
      $result = mysql_query($query)  or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
      $val = mysql_fetch_array($result);
   }
// -----------------------------------------------------------------------------------------------------
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
    <title>MONFICHIER-FORM.php</title>
</head>
<body><center>
<?php
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'AJOUTER') {
?>   
<div>
   <form name="AJOUTER" method="post" enctype="multipart/form-data" action="MONFICHIER-TRAITER.php">
   <input type="hidden" name="CAT" value="<?php echo $table; ?>">
   <input type="hidden" name="TRAITER" value="<?php echo $TRAITER; ?>">
   AJOUTER<br/>
   Légende :<input type="text" name="COMMENT1" size="50"><br/>
   PHOTO :<input typeFILE name="PHOTO1" size="50"><br/>
   <a href="#" onclick="history.back()">ANNULER</a>&nbsp;
   <input type="submit" value="CONFIRMER" name="CONFIRMER">&nbsp;
   <input type="reset" value="Rétablir" name="B2">
</form>
</div>
<?php
} // fin if AJOUTER
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'MODIFIER') {
?>
<div>
<form name="MODIFIER" method="post" enctype="multipart/form-data" action="MONFICHIER-TRAITER.php">
   <input type="hidden" name="CAT" value="<?php echo $table; ?>" />
   <input type="hidden" name="TRAITER" value="<?php echo $TRAITER; ?>" />
   <input type="hidden" name="NUM" value="<?php echo $NUM; ?>" />
   <input type="hidden" name="PHOTO1avant" value="<?php echo $val['PHOTO1']; ?>" />
   <input type="hidden" name="PICTO1avant" value="<?php echo $val['PICTO1']; ?>" />
   MODIFIER<br/>
   Légende :<input type="text" name="COMMENT1" size="50" value="<?php echo $val['COMMENT1']; ?>" /><br/>
   <?php if ($val['PHOTO1'] != "") { ?>
       <img alt="" border="0" src="<?php echo $chemincourt.$val['PHOTO1']; ?>" /><br/>
   <?php } ?>
   PHOTO :<input type="file" name="PHOTO1" size="50" /><br/>
   <a href="#" onclick="history.back()">ANNULER</a>&nbsp;
   <input type="submit" value="CONFIRMER" name="CONFIRMER" />&nbsp;
   <input type="reset" value="Rétablir" name="B2" />
</form>
</div>
<?php
} // fin if MODIFIER
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'SUPPRIMER') {
?>
<div>
<form name="SUPPRIMER" method="post" enctype="multipart/form-data" action="MONFICHIER-TRAITER.php">
   <input type="hidden" name="CAT" value="<?php echo $table; ?>" />
   <input type="hidden" name="TRAITER" value="<?php echo $TRAITER; ?>" />
   <input type="hidden" name="NUM" value="<?php echo $NUM; ?>" />
   <input type="hidden" name="PHOTO1avant" value="<?php echo $val['PHOTO1']; ?>" />
   <input type="hidden" name="PICTO1avant" value="<?php echo $val['PICTO1']; ?>" />
   SUPPRIMER ? (ATTENTION : toute suppression est définitive !)<br/>
   <a href="#" onclick="history.back()">ANNULER</a>&nbsp;
   <input type="submit" value="CONFIRMER" name="CONFIRMER" /><br/>
   <?php echo $val['COMMENT1']; ?>
      <?php if ($val['PHOTO1'] != "") { ?>
      <br/><img alt="" border="0" src="<?php echo $chemincourt.$val['PHOTO1']; ?>">
   <?php } ?>
</form>
</div>
<?php
} // fin if SUPPRIMER
// -----------------------------------------------------------------------------------------------------
?>
</center>
</body></html>
<?php // liberation de la ressource et deconnexion
if (($TRAITER == 'MODIFIER') || ($TRAITER == 'SUPPRIMER')) { mysql_free_result($result); }
mysql_close();
?>
TRAITEMENT :
dans cet exemple, TRAITEMENT :
0- gestion des erreurs
- Restrictions sur les fichiers : jpg, jpeg, png ou gif - 1Mo maxi
 
Si "AJOUTER" ou MODIFIER"
1- TELECHARGER la photo dans le répertoire
- PHOTO : on enregistre en ajoutant NUM- devant le nom de l'image uploadée
NUM est le numéro auto -la CLE primaire- de la fiche dans la base de données
On associe donc l'image à la fiche concernée et on rend le nom de l'image unique.
(on évite ainsi toute confusion, même si on upload plus tard des images de même nom)
2- REDIMENSIONNEMENT (si nécessaire) :
(on utilise les fonctions de redimensionnement "physique")
- PHOTO ? (ex. : on veut une largeur maxi de 600 pixels, hauteur libre)
- PICTO ? (ex. : on veut un "carré" de 100 x 100 pixels --> crop centré)
--> Si oui : on renomme le PICTO = picto-PHOTO
--> Si non : PICTO = PHOTO
3- Enregistrement dans la base de données (noms des photo et picto),
4- Suppression des anciens photo et picto du répertoire

 
Si "SUPPRIMER"
1- suppression de la fiche concernée dans la base de données,
2- supression des photo et picto concernés dans le répertoire.
MONFICHIER-TRAITER.php
<?php
// connexion a la base de donnees
   include("_connexion.php");
// FONCTIONS de redimensionnement "physique"
   include("fctredimimage.php"); // ("proportionnel")
   include("fctcropimage.php"); // ("crop centre")
// -----------------------------------------------------------------------------------------------------
// Répertoire des photos et pictos (déprotégé)
   $cheminlong = realpath('repIMAGES').'\\';
   $chemincourt = 'repIMAGES/';
// -------------------------------------------------------------
// recuperation du nom de la TABLE
   $table=$_POST['CAT'];
// recuperation du mode de traitement (AJOUTER - MODIFIER - SUPPRIMER)
   $TRAITER=$_POST['TRAITER'];
// -------------------------------------------------------------
// Restrictions sur les fichiers :
   $FileSizeMax = 1000000;
   $ExtfichierOK = '" jpg jpeg png gif"'; // (NB : l espace avant .jpg est important)
// -----------------------------------------------------------------------------------------------------
// GESTION DES ERREURS (upload fichier)
// (ne concerne que les options "AJOUTER" et "MODIFIER")
// -----------------------------------------------------------------------------------------------------
$erreurfile = 0;
// si un fichier N a PAS ete poste
if ($_FILES['PHOTO1']['size']<=0 && $TRAITER == 'AJOUTER') {
     $erreurfile = 1;
     echo 'Erreur ! Pas de fichier IMAGE défini<br/>';
     echo '<a href="#" onclick="history.back()">Retour au formulaire</a>';
}
if ($_FILES['PHOTO1']['size']<=0 && $TRAITER == 'MODIFIER' && $_POST['PHOTO1avant']=='') {
     $erreurfile = 1;
     echo 'Erreur ! Pas de fichier IMAGE défini<br/>';
     echo '<a href="#" onclick="history.back()">Retour au formulaire</a>';
}
// -------------------------------------------------------------
// si un fichier a bien ete poste
if ($_FILES['PHOTO1']['size'] > 0 && ($TRAITER == 'AJOUTER' || $TRAITER == 'MODIFIER')) {
   // on verifie les restrictions sur les fichiers
   // extension
   $tabfile = explode('.',$_FILES['PHOTO1']['name']);
   $extension = $tabfile[sizeof($tabfile)-1]; // dernier element
   $extension = strtolower($extension); // on met en minuscule
   if (strpos($ExtfichierOK,$extension)=='') {
     $erreurfile = 1;
     echo 'Erreur ! Ce n\'est pas un fichier IMAGE (jpg, jpeg, png ou gif)<br/>';
     echo '<a href="#" onclick="history.back()">Retour au formulaire</a>';
   }
   // taille maxi autorisee
   elseif ($_FILES['PHOTO1']['size'] > $FileSizeMax) {
     $erreurfile = 1;
     echo 'Erreur ! Taille de fichier supérieure à la taille maxi autorisée ('.$FileSizeMax.' octets)<br/>';
     echo '<a href="#" onclick="history.back()">Retour au formulaire</a>';
   }
   elseif (UPLOAD_ERR_OK<>0 && UPLOAD_ERR_FORM_SIZE==2) {
     $erreurfile = 1;
     echo 'Erreur ! Taille de fichier trop important ('.$FileSizeMax.' octets)<br/>';
     echo '<a href="#" onclick="history.back()">Retour au formulaire</a>';
   }
}
// -----------------------------------------------------------------------------------------------------
// si PAS d ERREUR : traitement
if ($erreurfile == 0) {
// -----------------------------------------------------------------------------------------------------
// TRAITEMENT du formulaire
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'AJOUTER') {
   // recuperation des elements du formulaire
   $COMMENT = mysql_real_escape_string($_POST['COMMENT1']);
   // -------------------------------------------------------------
   // ENREGISTREMENT du COMMENT dans la BASE DE DONNEES par INSERT
   $listechamps = 'COMMENT1';
   $listevaleurs = '\''.$COMMENT.'\'';
   $queryNEW = 'INSERT INTO '.$table.'('.$listechamps.') VALUES('.$listevaleurs.')';
   $resultNEW = mysql_query($queryNEW)  or die('Erreur SQL ! '.$queryNEW.'<br/>'.mysql_error());
   // -------------------------------------------------------------
   // recuperation du NUM en selectionnant LA DERNIERE fiche cree
   $query = 'SELECT MAX(NUM) AS NUMmax FROM '.$table; 
   $result = mysql_query($query) or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
   $val_NUMmax = mysql_fetch_array($result);
   $NUM = $val_NUMmax['NUMmax'];
}
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'MODIFIER') {
   // recuperation des elements du formulaire
   $NUM = intval($_POST['NUM']);
   $COMMENT = mysql_real_escape_string($_POST['COMMENT1']);
   // -------------------------------------------------------------
   // ENREGISTREMENT dans la BASE DE DONNEES par UPDATE
      $SQL = 'UPDATE '.$table.' SET COMMENT1=\''.$COMMENT.'\' WHERE NUM= '.$NUM;
      mysql_query($SQL);
   // -------------------------------------------------------------
   $PHOTO_avant = $_POST['PHOTO1avant'];
   $PICTO_avant = $_POST['PICTO1avant'];
   // par defaut
   $PHOTO = $PHOTO_avant;
   $PICTO = $PICTO_avant;
}
// -----------------------------------------------------------------------------------------------------
// TRAITEMENT des champs FILE (PHOTOS et PICTOS)
// -----------------------------------------------------------------------------------------------------
if (($TRAITER == 'AJOUTER') || ($TRAITER == 'MODIFIER')) {
   if(isset($_FILES['PHOTO1']) && $_FILES['PHOTO1']['size'] > 0)
   {
      // -------------------------------------------------------------
      // upload de la PHOTO sous forme NUM_nomfichier
      // NUM etant la CLE primaire de la fiche, ce qui rend le nom UNIQUE
      $PHOTO = $NUM.'_'.$_FILES['PHOTO1']['name'];
      // -------------------------------------------------------------
      // pour eviter tout probleme par la suite, on remplace jpeg par jpg
      $PHOTO = str_replace('.JPEG','.jpg',$PHOTO);
      $PHOTO = str_replace('.jpeg','.jpg',$PHOTO);
      // autre modification : remplacement des caracteres genants (espaces)
      $PHOTO = str_replace(' ','-',$PHOTO);
      // -------------------------------------------------------------
      // extension
      $tabfile = explode('.',$PHOTO);
      $extension = $tabfile[sizeof($tabfile)-1]; // dernier element
      $extension = strtolower($extension); // on met en minuscule
      // -------------------------------------------------------------
      // enregistrement du fichier image dans le repertoire
      $tempfile = $_FILES['PHOTO1']['tmp_name'];
      move_uploaded_file($tempfile, $chemincourt.$PHOTO);
      // -------------------------------------------------------------
      // REDIMENSIONNEMENT et SAUVEGARDE de la PHOTO (si necessaire)
      // -------------------------------------------------------------
      // on veut : une photo de 600 pixels maxi de large
      // ecraser (remplacer) la photo (meme rep, meme nom)
      $redimPHOTOOK = fctredimimage(600,0,'','',$chemincourt,$PHOTO);
      // $redimPHOTOok =1 si OK
      // -------------------------------------------------------------
      // REDIMENSIONNEMENT et SAUVEGARDE du PICTO
      // -------------------------------------------------------------
      // on veut : un picto toujours carre de 100 x 100 pixels (avec crop)
      // enregistrer en ajoutant 'picto_' devant le nom de la photo
      // dans le meme repertoire que la photo
      $redimPICTOok = fctcropimage(0,0,'','picto_'.$PHOTO,$chemincourt,$PHOTO);
      $redimPICTOok = fctredimimage(100,100,'','',$chemincourt,'picto_'.$PHOTO);
      // $redimPICTOok =1 si OK
      // nom du picto pour la BD
      if ($redimPICTOok == 1) {
         $PICTO = 'picto_'.$PHOTO;
      } else {
         $PICTO = $PHOTO;
      }
      // -------------------------------------------------------------
      // SUPPRESSION des anciennes PHOTOS dans le repertoire
      if ($TRAITER == 'MODIFIER') {
         if ($PHOTO_avant != '' && $PHOTO_avant != $PHOTO && $PHOTO_avant != $PICTO) {
         unlink($cheminlong.$PHOTO1avant); // Suppression de la photo
         }
         if ($PICTO_avant != '' && $PICTO_avant != $PHOTO && $PICTO_avant != $PICTO) {
            unlink($cheminlong.$PICTO_avant); // Suppression du picto
         }
      }
      // -------------------------------------------------------------
   } 
   // ----------------------------------------------------------------
   // enregistrement dans la table par UPDATE
   $SQL = 'UPDATE '.$table.' SET PHOTO1=\''.$PHOTO.'\' WHERE NUM= '.$NUM;
   mysql_query($SQL);
   $SQL = 'UPDATE '.$table.' SET PICTO1=\''.$PICTO.'\' WHERE NUM= '.$NUM;
   mysql_query($SQL);
}
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'SUPPRIMER') {
   // recuperation des elements du formulaire
   $NUM = intval($_POST['NUM']);
   $PHOTO_avant=$_POST['PHOTO1avant'];
   $PICTO_avant=$_POST['PICTO1avant'];
   // -------------------------------------------------------------
   // SUPPRESSION de la fiche numero NUM dans la BD
   $query = 'DELETE FROM '.$table.' WHERE NUM = '.$NUM ;
   $result = mysql_query($query)  or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
   // -------------------------------------------------------------
   // SUPPRESSION des PHOTOS dans le repertoire
   if ($PHOTO_avant != '') {
      unlink($cheminlong.$PHOTO_avant); // Suppression de la photo
   }
   if ($PICTO_avant != '' && $PICTO_avant != $PHOTO_avant) {
      unlink($cheminlong.$PICTO_avant); // Suppression du picto
   }
}
// -----------------------------------------------------------------------------------------------------
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
    <title>MONFICHIER-TRAITER.php</title>
</head>
<body><div align="center">
<?php
// -----------------------------------------------------------------------------------------------------
// AFFICHAGE
// -----------------------------------------------------------------------------------------------------
if (($TRAITER == 'AJOUTER') || ($TRAITER == 'MODIFIER')) {
   // -------------------------------------------------------------
   // recuperation des donnees de la nouvelle fiche pour reaffichage
   $query = 'SELECT * FROM '.$table.' WHERE NUM = '. $NUM; 
   $result = mysql_query($query)  or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
   $val = mysql_fetch_array($result);
   // -------------------------------------------------------------
   if ($TRAITER == 'AJOUTER') { echo 'LA PHOTO a été AJOUTEE.<br/>'; }
   if ($TRAITER == 'MODIFIER') { echo 'LA PHOTO a été MODIFIEE.<br/>'; } 
?>
   <a href="MONFICHIER-LISTE.php?CAT=<?php echo $table; ?>">RETOUR</a><br/><br/>
   <?php echo $val['COMMENT1']; ?><br/>
   <?php if ($val['PHOTO1'] != "") { ?>
      <img alt="" border="0" src="<?php echo $chemincourt.$val['PHOTO1']; ?>">
   <?php } ?>
<?php
}
// -----------------------------------------------------------------------------------------------------
if ($TRAITER == 'SUPPRIMER') {
?>   
   LA PHOTO a été SUPPRIMEE.<br/>
   <a href="MONFICHIER-LISTE.php?CAT=<?php echo $table; ?>">RETOUR</a>
<?php
}
// -----------------------------------------------------------------------------------------------------
} // fin du traitement si PAS d ERREUR
?>
</div>
</body></html>
<?php // Déconnexion
mysql_close();
?>
COMPLEMENTS :
 
Utilisation dans un espace d'administration :
Nécessite une protection des pages
 
Utilisation par les visiteurs (membres ?) :
Le visiteur ne doit pas avoir accès à toute la base, mais seulement à ses propres photos !
On doit d'abord récupérer l'IDvisiteur.
- soit il a ses propres tables (ex. IDvisiteur_MATABLE1, ...)
- soit vérifier ses droits d'accès avant ... (ajouter un champ IDvisiteur à la table MATABLE)
 
Traitement de plusieurs tables :
Déja prévu : le nom de la table étant enregistré dans la variable "$table", il est simple de changer de table :
Dans le fichier MONFICHIER-LISTE.php
Au lieu de :
$table = 'MATABLE';
On met :
$table = $_GET['CAT'];
En précisant à l'appel du fichier :
MONFICHIER-LISTE.php?CAT=MATABLE
 
Nombre de photos :
On peut gérer la saisie simultanée de plusieurs photos.
voirTélécharger plusieurs fichiers simultanément
ou
Pour les formulaires :
PHOTO1, PHOTO2, ... PHOTOn (et COMMENT1, COMMENT2, ... COMMENTn)
Adapter aussi pour le traitement et pour l'enregistrement dans la BD.
 


VIII. Utilisation dans un dossier

Hypothèse :
Un dossier "repPHOTOS" contenant déjà des images.
Vous souhaitez créer des images de prévisualisation (pictos) (ex. 150 x 100 pixels maxi),
et les enregistrer dans le dossier "repPHOTOS/repPICTOS".
NB :
S'assurer que les droits en écriture ont été donnés aux dossiers (chmod)
 
Principe :
- ouvrir le répertoire,
- lire les fichiers
- redimensionner (si nécessaire) en fonction des conditions requises
--> utilisation de la fonction fctredimimage()
- enregistrer le picto dans le dossier de destination.
 
NB :
Par défaut, la fonction fctredimimage() ne redimensionne pas les images plus petites que les dimensions spécifiées.
Pour créer des pictos, pas de problème.
Sinon, une adaptation de la fonction pourrait être nécessaire.
("forcer" le redimensionnement : $condition=1)
MONDOSSIER-REDIM.php
<?php
// FONCTIONS de redimensionnement "physique"
   include("fctredimimage.php");
//   include("fctcropimage.php"); // (inutile ici)
// -----------------------------------------------------------------------------------------------------
// repertoire Source
$rep_Src = "repPHOTOS/";
// repertoire de Destination
$rep_Dst = "repPHOTOS/repPICTOS/";
// S'assurer que les droits en écriture ont été donnés aux dossiers (chmod)
// -----------------------------------------------------------------------------------------------------
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
    <title>MONDOSSIER-REDIM.php</title>
</head>
<body><center>
<?php
// -----------------------------------------------------------------------------------------------------
// Ouverture du dossier Source
$ouvredir = opendir($rep_Src);
// -----------------------------------------------------------------------------------------------------
// pour chaque fichier du repertoire ...
while ($img_Src = readdir($ouvredir)) {
   // si le fichier existe
   if(is_file($rep_Src.$img_Src)) {
      // -------------------------------------------------------------
      // CHOIX de redimensionnement : picto de 150 x 100 pixels maxi
      // nom du picto : pict-(nom photo)
      $img_Dst = 'pict-'.$img_Src;
      // -------------------------------------------------------------
      // REDIMENSIONNEMENT (si les conditions sont correctes)
      $RedimOK = fctredimimage(150, 100, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
      // -------------------------------------------------------------
      if ($RedimOK == 1 ) {
         // Affichage de confirmation d'écriture
         echo 'Picto créé : '.$rep_Dst.$img_Dst.'...<br/>';
      }
   } // fin si existe
} // fin while
// -----------------------------------------------------------------------------------------------------
// Fermeture du dossier
closedir($ouvredir);
// -----------------------------------------------------------------------------------------------------
echo '<br/>Les pictos se trouvent dans le dossier '.$rep_Dst.'<br/>';
?>
</center>
</body></html>

IX. Conclusion

Les fonctions proposées ici devraient répondre à la plupart des cas de redimensionnement !
Redimensionnement à l'affichage

Fonction : fctaffichimage($img_Src, $W_max, $H_max)

Utilisation :
   <img alt="" src="repimg/monimage.jpg" <?php fctaffichimage('repimg/monimage.jpg', 150, 100) ?> />
Redimensionnement physique proportionnel

Fonction : fctredimimage($W_max, $H_max, $rep_Dst, $img_Dst, $rep_Src, $img_Src)

Utilisation :
<?php
   $redimOK = fctredimimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
   if ($redimOK == 1) { echo 'Redimensionnement OK !'; }
?>
Redimensionnement physique non-proportionnel

Fonction : fctdeformimage($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)

Utilisation :
<?php   $deformOK = fctdeformimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
        if ($deformOK == 1) { echo 'Redimensionnement OK !'; } ?>
Redimensionnement physique crop centré

Fonction : fctcropimage($W_fin, $H_fin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)

Utilisation :
<?php
   $cropOK = fctcropimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
   if ($cropOK == 1) { echo 'Crop centré OK !'; }
?>
Astuce - picto toujours carré avec crop

<?php
   $redim = fctcropimage(0,0,$repDest,$imageDest,$repSource,$imageSource);
   $redim = fctredimimage(100,0,'','',$repDest,$imageDest);
   if ($redim==true) { echo 'picto carré créé !'; }
?>
Astuce - picto toujours carré déformé

<?php
   $redim = fctdeformimage(100,100,$repDest,$imageDest,$repSource,$imageSource);
   if ($redim==true) { echo 'picto carré créé !'; }
?>
Signature d'une image

Fonction : fcttexteimage ($chaine, $rep_Dst, $img_Dst, $rep_Src, $img_Src, $position)

Utilisation (copyright, date, ou legende de l'image) :
<?php
   $texteOK = fcttexteimage('copyright : MOI','reppicto/','monpicto.jpg','repimage/','monimage.jpg','BG');
   if ($texteOK == 1) { echo 'Ajout du texte OK !';  }  ?>
 
 
 
Toutes remarques, corrections, ajouts, permettant d'améliorer ou d'étoffer ce tutoriel seront les bienvenus.
16 commentaires · Donner une note à l'article (4)



               Version PDF (Miroir)   Version hors-ligne (Miroir)

Valid XHTML 1.0 TransitionalValid CSS!

Les sources présentées sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2008 Jérôme Réaux. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Droits de diffusion permanents accordés à developpez LLC. Cette page est déposée à la SACD.

Vos questions techniques : forum d'entraide PHP - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2010 www.developpez.com - Legal informations.