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 : 12 avril 2012.

Par Jérôme Réaux Site personnel

 

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

17 commentaires Donner une note à l'article (4)

Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites      



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="120" 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="120" />   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
 

Exemple : <img alt="" <?php fctaffichimage('repimg/monimage.jpg', 120, 100) ?> />
Redimensionnement "à l'affichage"
Original-paysage Original-portrait
Original-paysage-120x80 Original-portrait-120x80
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
// Exemple :
// <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
Exemple :

<?php
$redimOK = fctredimimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($redimOK == 1) { echo 'Redimensionnement OK !'; }
?>
Redimensionnement physique "proportionnel"
Original-paysage Original-portrait
Original-paysage-120x80 Original-portrait-120x80
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
Exemple :
<?php
$deformOK = fctdeformimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($deformOK == 1) { echo 'Redimensionnement OK !'; }
?>
Redimensionnement physique "non-proportionnel"
Original-paysage Original-portrait
Original-paysage-120x80non Original-portrait-120x80non
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
Exemple :
<?php
$cropOK = fctcropimage(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
if ($cropOK == 1) { echo 'Crop centré OK !'; }
?>
Redimensionnement physique "crop centré"
Original-paysage Original-portrait
Original-paysage-crop Original-portrait-crop
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éé !'; }
?>
Picto toujours carré
Original-paysage-carre Original-portrait-carre
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
Exemple (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 !';  }
?>
"Signature" de l'image
Original-signature-HG Original-signature-HD
Original-signature-BG Original-signature-BD
Original-signature-HC Original-signature-BC
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

info Pour voir un exemple fonctionnel complet, voir : PHP - Système de Gestion-Affichage de Nouvelles (avec photo et fichier joint)
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 - 10 - auto-incrementé : clé primaire - NotNull)
- COMMENT1 (TEXT - Null)
- PHOTO1 (VARCHAR - 150 - Null)
- PICTO1 (VARCHAR - 150 - 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( 10 ) NOT NULL AUTO_INCREMENT ,
`COMMENT1` TEXT ,
`PHOTO1` VARCHAR( 150 ) ,
`PICTO1` VARCHAR( 150 ) ,
PRIMARY KEY ( `NUM` ) 
) TYPE = MYISAM ;
_connexion.php
<?php
// ---------------------------------------------------------------------------------------
// Paramètres de connection a la Base de Données sur le serveur
$connexion_hostname 	= "localhost"; 	// voir hébergeur
$connexion_database 	= "MABASE"; 	// nom de la BD
$connexion_username 	= "login"; 		// identifiant de votre BD (vide ou "root" en local)
$connexion_password 	= "password"; 	// mot de passe de votre BD (vide en local)
// connexion a la base de donnees
$connexion = mysql_pconnect($connexion_hostname, $connexion_username, $connexion_password) or trigger_error(mysql_error(),E_USER_ERROR); 
mysql_connect($connexion_hostname, $connexion_username, $connexion_password);
mysql_select_db($connexion_database);
// ---------------------------------------------------------------------------------------
?>
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 UTILE : "redimensionnement a l affichage"
   include("./fctaffichimage.php");
// 	---------------------------------------------------------------
// mettre le nom de la table dans une variable :
   $table = 'MATABLE';
// OU : on peut utiliser ce fichier pour PLUSIEURS TABLES (de meme structure)
// (preciser le nom de la table a l'appel du fichier -> MONFICHIER-LISTE.php?CAT=MATABLE)
// $table = mysql_real_escape_string($_GET['CAT']);
// 	---------------------------------------------------------------
// Les photos et pictos sont stockes dans un dossier deprotege en ecriture
   $repPhotos = 'repIMAGES/';
// 	---------------------------------------------------------------
?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    <title>MONFICHIER-LISTE.php</title>
</head>
<body>

<div>
	<h4>TABLE <?php echo $table; ?></h4>
	<p><a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=AJOUTER">AJOUTER NOUVEAU</a></p>
</div>
<div>	  
	<table border="1">
	<thead>
		<tr>
			<th>suppr.</th>
			<th>Commentaire</th>
			<th>Picto</th>
			<th>modif.</th>
		</tr>
	</thead>
	<tbody>
<?php
// 	---------------------------------------------------------------
// sélection de toutes les fiches de la table
	$query = "SELECT * FROM ".$table." ORDER BY NUM DESC;"; 
	$result = mysql_query($query)  or die('Erreur SQL ! '.$query.'<br/>'.mysql_error());
// AFFICHAGE tant qu'il y a des fiches
while ($val = mysql_fetch_array($result)) 
{
?>
		<tr>
			<td>
				<a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=SUPPRIMER&NUM=<?php echo $val['NUM']; ?>">
				Supprimer</a>
			</td>
			<td>
				<?php echo $val['COMMENT1']; ?>
			</td>
			<td>
				<?php if ($val['PICTO1'] != "") { ?>
					<img alt="" <?php fctaffichimage($repPhotos.$val['PICTO1'], 100, 100) ?>>
				<?php } ?>
			 </td>
			<td>
				<a href="MONFICHIER-FORM.php?CAT=<?php echo $table; ?>&TRAITER=MODIFIER&NUM=<?php echo $val['NUM']; ?>">
				Modifier</a>
			</td>
		</tr>
<?php
} // fin while
// 	---------------------------------------------------------------
?>
	</tbody>
	</table>
</div>

</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é)
	$repPhotos = 'repIMAGES/';
// 	---------------------------------------------------------------
// recuperation du nom de la TABLE
	$table = mysql_real_escape_string($_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 = mysql_real_escape_string($_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>
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
	 <meta http-equiv="content-type" content="text/html; charset=utf-8" />
	 <title>MONFICHIER-FORM.php</title>
</head>
<body>

<?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; ?>">
	<h4>AJOUTER</h4>
	<p>
		<label for="idCOMMENT1">Légende :</label>
		<input id="idCOMMENT1" name="COMMENT1" type="text" size="50" value="" />
	</p>
	<p>
		<label for="idPHOTO1">Photo :</label>
		<input id="idPHOTO1" name="PHOTO1" type="file" size="50" />
	</p>
	<p>
		<a href="#" onclick="history.back();">ANNULER</a>&nbsp;
		<input type="submit" name="CONFIRMER" value="CONFIRMER" />
	</p>
</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']; ?>" />
	<h4>MODIFIER</h4>
	<p>
		<label for="idCOMMENT1">Légende :</label>
		<input id="idCOMMENT1" name="COMMENT1" type="text" size="50" value="<?php echo $val['COMMENT1']; ?>" />
	</p>
	<p>
		<label for="idPHOTO1">Photo :</label>
<?php	if ($val['PHOTO1'] != "") { ?>
		<img src="<?php echo $repPhotos.$val['PHOTO1']; ?>" alt="" /><br/>
<?php	} ?>
		<input id="idPHOTO1" name="PHOTO1" type="file" size="50" />
	</p>
	<p>
		<a href="#" onclick="history.back();">ANNULER</a>&nbsp;
		<input type="submit" name="CONFIRMER" value="CONFIRMER" />
	</p>
	<p>
		<a href="#" onclick="history.back();">ANNULER</a>&nbsp;
		<input type="submit" name="CONFIRMER" value="CONFIRMER" />
	</p>
</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']; ?>" />
	<h4>SUPPRIMER ?</h4>
	<p>
		<label>Légende :</label><?php echo $val['COMMENT1']; ?>
	</p>
	<p>
		<label>Photo :</label>
<?php	if ($val['PHOTO1'] != "") { ?>
		<img src="<?php echo $repPhotos.$val['PHOTO1']; ?>" alt="" />
<?php	} ?>
	</p>
	<p>(ATTENTION : toute suppression est définitive !)</p>
	<p>
		<a href="#" onclick="history.back();">ANNULER</a>&nbsp;
		<input type="submit" name="CONFIRMER" value="CONFIRMER" />
	</p>
</form>
</div>
<?php
} // fin if SUPPRIMER
// 	---------------------------------------------------------------
?>

</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 (doit etre déprotégé en écriture)
	$repPhotos = 'repIMAGES/';
// -------------------------------
// recuperation du nom de la TABLE
	$table = mysql_real_escape_string($_POST['CAT']);
// recuperation du mode de traitement (AJOUTER - MODIFIER - SUPPRIMER)
	$TRAITER = $_POST['TRAITER'];
// -------------------------------
// Restrictions sur les fichiers :
	$FileSizeMax = 2000000; // 2 Mo
	$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')) {
	// extension (en minuscule)
	$extension = strtolower(pathinfo($_FILES['PHOTO1']['name'],PATHINFO_EXTENSION));
	// on verifie les restrictions sur les fichiers
	if (strpos($ExtfichierOK,$extension)=='') {
	  $erreurfile = 1;
	  echo 'Erreur ! Ce n\'est pas un fichier IMAGE ('.$ExtfichierOK.')<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 du formulaire
// ---------------------------------------------------------------
if ($erreurfile == 0) 
{
// ------------------------------
if ($TRAITER == 'AJOUTER') {
	// recuperation des elements du formulaire
	$COMMENT 	= stripslashes($_POST['COMMENT1']);
	// ------------------------------
	// ENREGISTREMENT du COMMENT dans la BASE DE DONNEES par INSERT
	$queryNEW 	= "INSERT INTO ".$table." ".
				"(".
				" COMMENT1 ".
				") VALUES (".
				" '".mysql_real_escape_string($COMMENT)."' ".
				");";
	$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 		= $_POST['NUM'];
	$COMMENT 	= stripslashes($_POST['COMMENT1']);
	// ------------------------------
	// ENREGISTREMENT dans la BASE DE DONNEES par UPDATE
		$query 	= "UPDATE ".$table." ".
				" SET ".
				" COMMENT1 = '".mysql_real_escape_string($COMMENT)."' ".
				" WHERE NUM = '".mysql_real_escape_string($NUM)."';";
		mysql_query($query);
	// ------------------------------
	$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);
		// en minuscule + remplacement des caracteres accentues
		$sans_accent = "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÒÓÔÕÖŒØÙÚÛÜÝàáâãäåæçèéêëìíîïðòóôõöùúûüýÿÑñŠšœ ";
		$avec_accent = "AAAAAAACEEEEIIIIOOOOOOOUUUUYaaaaaaaceeeeiiiioooooouuuuyynnsso-";
		$PHOTO 	= strtolower(stripslashes(trim($PHOTO)));
		$PHOTO 	= strtr($PHOTO, $sans_accent, $avec_accent);
		// ------------------------------
		// extension (en minuscule)
		$extension = strtolower(pathinfo($_FILES['PHOTO1']['name'],PATHINFO_EXTENSION));
		// ------------------------------
		// enregistrement du fichier image dans le repertoire
		$tempfile = $_FILES['PHOTO1']['tmp_name'];
		move_uploaded_file($tempfile, $repPhotos.$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,'','',$repPhotos,$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,$repPhotos,$PHOTO);
		$redimPICTOok = fctredimimage(100,100,'','',$repPhotos,'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($repPhotos.$PHOTO1avant); // Suppression de la photo
			}
			if ($PICTO_avant != '' && $PICTO_avant != $PHOTO && $PICTO_avant != $PICTO) {
				unlink($repPhotos.$PICTO_avant); // Suppression du picto
			}
		}
	} 
	// ------------------------------
	// enregistrement dans la table par UPDATE
	$query 		= "UPDATE ".$table." ".
				" SET ".
				" PHOTO1 = '".$PHOTO."', ".
				" PICTO1 = '".$PICTO."' ".
				" WHERE NUM = '".$NUM."';";
	mysql_query($query);
}

// ---------------------------------------------------------------
if ($TRAITER == 'SUPPRIMER') {
	// recuperation des elements du formulaire
	$NUM 		= mysql_real_escape_string($_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 PHOTO et PICTO 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>
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
	 <meta http-equiv="content-type" content="text/html; charset=utf-8" />
	 <title>MONFICHIER-TRAITER.php</title>
</head>
<body>

<?php // RE-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') { ?><p>La PHOTO a été AJOUTEE.</p><?php }
	if ($TRAITER == 'MODIFIER') { ?><p>La PHOTO a été MODIFIEE.</p><?php } 
?>
	<p><a href="MONFICHIER-LISTE.php?CAT=<?php echo $table; ?>">RETOUR</a></p>
	<p>Légende : <?php echo $val['COMMENT1']; ?></p>
	<p>Photo : 
<?php 	if ($val['PHOTO1'] != "") { ?>
		<img src="<?php echo $repPhotos.$val['PHOTO1']; ?>" alt="" />
<?php 	} ?>
<?php
}
// ---------------------------------------------------------------
if ($TRAITER == 'SUPPRIMER') {
?>	
	<p>La PHOTO a été SUPPRIMEE.</p>
	<p><a href="MONFICHIER-LISTE.php?CAT=<?php echo $table; ?>">RETOUR</a></p>
<?php
}
// ---------------------------------------------------------------
} // fin du traitement si PAS d ERREUR
?>

</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>
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr">
<head>
	 <meta http-equiv="content-type" content="text/html; charset=utf-8" />
	 <title>MONDOSSIER-REDIM.php</title>
</head>
<body>

<?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)
		// ------------------------------
		// (facultatif) Affichage de confirmation d'écriture
		if ($RedimOK == 1 ) {
			echo '<p>Picto créé : '.$rep_Dst.$img_Dst.'...</p>';
		}
	} // fin si existe
} // fin while
// ------------------------------
// Fermeture du dossier
closedir($ouvredir);
?>
<p>Les pictos se trouvent dans le dossier <?php echo $rep_Dst; ?></p>

</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)

Exemple :
	<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)

Exemple :
<?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)

Exemple :
<?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)

Exemple :
<?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)

Exemple (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 !';  }  ?>
idea Un grand remerciement à tous pour vos conseils :
yogui, kerod, sayrus, loka,

Special Thanks à ma chienne Candy, qui a posé pour les photos !

Toutes remarques, corrections, ajouts, permettant d'améliorer ou d'étoffer ce tutoriel seront les bienvenus.
17 commentaires Donner une note à l'article (4)



               Version PDF   Version hors-ligne   Version eBooks

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 œuvre intellectuelle protégée par les droits d'auteur. 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'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC. Cette page est déposée.

 
 
Developpez.com

Nous contacter

Participez

Informations légales

 
Services

Forum PHP

Blogs

Hébergement

 
Partenaires

Hébergement Web