Php - redimensionner image + picto après upload
Php - redimensionner image + picto après upload
Description
Quand on parle de "redimensionnement" d'image, il faut distinguer :
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 fct_affich_image.php : redimensionner des images à l'affichage
redimensionnement "physique" :
modification du "poids" de l'image (nouvelle image aux dimensions spécifiées),
- fonction fct_redim_image.php : L'image finale est redimensionnée "en proportions".
- fonction fct_crop_image.php : L'image finale est "coupée" ("crop centré").
- avec base de données : upload, traitement, enregistrement.
- dans un dossier (répertoire) : redimensionner des images déjà présentes.
Redimensionnement "à l'affichage"
La fonction
fct_affich_image($Wmax, $Hmax, $img_Src)
Les paramètres :
- $Wmax : LARGEUR maxi d'affichage ----> ou 0 : largeur libre
- $Hmax : HAUTEUR maxi d'affichage ----> ou 0 : hauteur libre
- $img_Src : NOM de l'image Source (+ chemin)
L'image source n'est pas modifiée, seules ses dimensions d'affichage sont "recalculées".
Le code php
fct_affich_image.php
<?php
// --------------------------------------------------------------------------------------------------
// fonction de redimensionnement A L'AFFICHAGE
// --------------------------------------------------------------------------------------------------
// La FONCTION : fct_affich_image($Wmax, $Hmax, $img_Src)
// Les paramètres :
// - $Wmax : LARGEUR maxi finale ----> ou 0 : largeur libre
// - $Hmax : HAUTEUR maxi finale ----> ou 0 : hauteur libre
// - $img_Src : NOM de l image Source
// --------------------------------------------------------------------------------------------------
// UTILISATION (exemple) :
// <img src="repimg/monimage.jpg" <?php fct_affich_image(100, 100, 'repimg/monimage.jpg') ?>>
// --------------------------------------------------------------------------------------------------
function fct_affich_image($Wmax, $Hmax, $img_Src) {
// ------------------------------------------------------------------
// Lit les dimensions de l'image
$sizeimg = GetImageSize($img_Src);
$Src_W = $sizeimg[0]; // largeur
$Src_H = $sizeimg[1]; // hauteur
// ------------------------------------------------------------------
// Teste les dimensions tenant dans la zone
$test_H = round(($Wmax / $Src_W) * $Src_H);
$test_W = round(($Hmax / $Src_H) * $Src_W);
// ------------------------------------------------------------------
// Si Height final non précisé (0)
if(!$Hmax) $Hmax = $test_H;
// Sinon si Width final non précisé (0)
elseif(!$Wmax) $Wmax = $test_W;
// Sinon teste quel redimensionnement tient dans la zone
elseif($test_H>$Hmax) $Wmax = $test_W;
else $Hmax = $test_H;
// ------------------------------------------------------------------
// (procédure : ne retourne aucune valeur mais ...)
// AFFICHE les dimensions optimales
echo 'width='.$Wmax.' height='.$Hmax;
}
// --------------------------------------------------------------------------------------------------
?>
Redimensionnement "physique proportionnel"
La fonction
fct_redim_image($Wmax, $Hmax, $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 libre)
C- "largeur" : image finale à LARGEUR maxi fixe (hauteur libre)
Retourne la valeur :
- 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu,
- sinon rien (false)
Les paramètres :
- $Wmax : LARGEUR maxi finale --> ou 0 : largeur libre
- $Hmax : HAUTEUR maxi finale --> ou 0 : hauteur libre
- $rep_Dst : répertoire de l'image de destination (déprotégé) --> ou '' : même répertoire
NB il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod ou via logiciel FTP)
- $img_Dst : NOM de l'image de destination --> ou '' : même nom
- $rep_Src : répertoire de l'image source (déprotégé)
- $img_Src : NOM de l'image source
Les 3 options :
A- $Wmax != 0 et $Hmax != 0 -> à LARGEUR maxi ET HAUTEUR maxi fixes
B- si $Wmax = 0 -> à LARGEUR maxi fixe
C- si $Hmax = 0 -> à HAUTEUR maxi fixe
NB :
- 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 !
- $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
Extensions acceptées (traitées ici) : .jpg , .jpeg , .png
Pour ajouter d'autres extensions :
voir la bibliothèque GD ou ImageMagick.
Le code php
fct_redim_image.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 : fct_redim_image($Wmax, $Hmax, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
// Les paramètres :
// - $Wmax : LARGEUR maxi finale ----> ou 0 : largeur libre
// - $Hmax : HAUTEUR maxi finale ----> ou 0 : hauteur libre
// - $rep_Dst : répertoire de l image de Destination (déprotégé) ----> ou '' : même répertoire
// il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod ou via logiciel FTP)
// - $img_Dst : NOM de l image de Destination ----> ou '' : même nom que l image Src
// - $rep_Src : répertoire de l image Source (déprotégé)
// - $img_Src : NOM de l image Source
// --------------------------------------------------------------------------------------------------
// si $rep_Dst = '' : $rep_Dst=$rep_Src (même répertoire)
// si $img_Dst = '' : $img_Dst=$img_Src (même nom)
// Attention : si $rep_Dst='' ET $img_Dst='' : on écrase (remplace) l image source ($img_Src) !
// NB : $img_Dst et $img_Src doivent avoir la même extension (même type mime) !
// --------------------------------------------------------------------------------------------------
// 3 options :
// A- $Wmax != 0 et $Hmax != 0 : a LARGEUR maxi ET HAUTEUR maxi fixes
// B- si $Wmax = 0 : image finale a LARGEUR maxi fixe (hauteur libre)
// C- si $Hmax = 0 : image finale a HAUTEUR maxi fixe (largeur libre)
// --------------------------------------------------------------------------------------------------
// Extensions acceptees (traitees ici) : .jpg , .jpeg , .png
// Pour ajouter d autres extensions : voir la bibliothèque GD ou ImageMagick
// (GD) NE FONCTIONNE PAS avec les GIF ANIMES ou a fond transparent !
// --------------------------------------------------------------------------------------------------
// UTILISATION (exemple) :
// $redimOK = fct_redim_image(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
// if ($redimOK == 1) { echo 'Redimensionnement OK !'; }
// --------------------------------------------------------------------------------------------------
function fct_redim_image($Wmax, $Hmax, $rep_Dst, $img_Dst, $rep_Src, $img_Src) {
// ------------------------------------------------------------------
$condition = 0;
// Si certains paramètres ont pour valeur '' :
if ($rep_Dst == '') { $rep_Dst = $rep_Src; } // (meme repertoire)
if ($img_Dst == '') { $img_Dst = $img_Src; } // (meme nom)
if ($Wmax == '') { $Wmax = 0; }
if ($Hmax == '') { $Hmax = 0; }
// ------------------------------------------------------------------
// si le fichier existe dans le répertoire, on continue...
if (file_exists($rep_Src.$img_Src) && ($Wmax!=0 || $Hmax!=0)) {
// ----------------------------------------------------------------
// extensions acceptées :
$ExtfichierOK = '" jpg jpeg png"'; // (l espace avant jpg est important)
// extension
$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) != '') {
// -------------------------------------------------------------
// récupération des dimensions de l image Src
$size = getimagesize($rep_Src.$img_Src);
$W_Src = $size[0]; // largeur
$H_Src = $size[1]; // hauteur
// -------------------------------------------------------------
// condition de redimensionnement et dimensions de l image finale
// -------------------------------------------------------------
// A- LARGEUR ET HAUTEUR maxi fixes
if ($Wmax != 0 && $Hmax != 0) {
$ratiox = $W_Src / $Wmax; // ratio en largeur
$ratioy = $H_Src / $Hmax; // 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- LARGEUR maxi fixe
if ($Hmax != 0 && $Wmax == 0) {
$H = $Hmax;
$W = $H * ($W_Src / $H_Src);
$condition = $H_Src > $Hmax; // 1 si vrai (true)
}
// -------------------------------------------------------------
// C- HAUTEUR maxi fixe
if ($Wmax != 0 && $Hmax == 0) {
$W = $Wmax;
$H = $W * ($H_Src / $W_Src);
$condition = $W_Src > $Wmax; // 1 si vrai (true)
}
// -------------------------------------------------------------
// on REDIMENSIONNE si la condition est vraie
// -------------------------------------------------------------
if ($condition == 1) {
// création de la ressource-image"Src" en fonction de l extension
// et on crée une ressource-image"Dst" vide aux dimensions finales
switch($extension) {
case 'jpg':
case 'jpeg':
$Ress_Src = imagecreatefromjpeg($rep_Src.$img_Src);
$Ress_Dst = ImageCreateTrueColor($W,$H);
break;
case 'png':
$Ress_Src = imagecreatefrompng($rep_Src.$img_Src);
$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, ré-echantillonne)
ImageCopyResampled($Ress_Dst, $Ress_Src, 0, 0, 0, 0, $W, $H, $W_Src, $H_Src);
// ----------------------------------------------------------
// ENREGISTREMENT dans le répertoire (avec la fonction appropriée)
switch ($extension) {
case 'jpg':
case 'jpeg':
ImageJpeg ($Ress_Dst, $rep_Dst.$img_Dst);
break;
case 'png':
imagepng ($Ress_Dst, $rep_Dst.$img_Dst);
break;
}
// ----------------------------------------------------------
// libération des ressources-image
imagedestroy ($Ress_Src);
imagedestroy ($Ress_Dst);
}
// -------------------------------------------------------------
}
}
// --------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// si le fichier a bien été créé
if ($condition == 1 && file_exists($rep_Dst.$img_Dst)) { return true; }
else { return false; }
}
// --------------------------------------------------------------------------------------------------
?>
Redimensionnement "physique crop centré"
La fonction
fct_crop_image($Wfin, $Hfin, $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 :
- $Wfin : LARGEUR finale ----> ou 0
- $Hfin : HAUTEUR finale ----> ou 0
- $rep_Dst : répertoire de l'image de destination (déprotégé) ----> ou '' (même répertoire)
NB il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod ou via logiciel FTP)
- $img_Dst : NOM de l'image de destination ----> ou '' (même nom)
- $rep_Src : répertoire de l'image source (déprotégé)
- $img_Src : NOM de l'image source
Les 4 options :
A- si $Wfin != 0 et $Hfin!= 0 : crop aux dimensions indiquées
B- si $Wfin = 0 et $Hfin != 0 : crop en HAUTEUR (même largeur que la source)
C- si $Wfin != 0 et $Hfin = 0 : crop en LARGEUR (même hauteur que la source)
D- si $Wfin= 0 et $Hfin = 0 : (cas spécial) crop "carré" à la plus petite dimension de l'image source
NB :
- 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 la bibliothèque GD ou ImageMagick
ASTUCE : picto carré (de 100 x 100 pixels)
--> Crop "carré", puis "proportionnel"
$redim = fct_crop_image(0,0,$repDest,$imageDest,$repSource,$imageSource);
$redim = fct_redim_image(100,0,'','',$repDest,$imageDest);
if ($redim==true) { echo 'picto carré créé !'; }
Le code php
ct_crop_image.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 : fct_crop_image($Wfin, $Hfin, $rep_Dst, $img_Dst, $rep_Src, $img_Src)
// Les parametres :
// - $Wfin : LARGEUR finale --> ou 0
// - $Hfin : HAUTEUR finale --> ou 0
// - $rep_Dst : repertoire de l image de Destination (deprotégé) --> ou ''
// il faut s'assurer que les droits en écriture ont été donnés au dossier (chmod ou via logiciel FTP)
// - $img_Dst : NOM de l image de Destination ----> ou ''
// - $rep_Src : repertoire de l image Source (deprotégé)
// - $img_Src : NOM de l image Source
// --------------------------------------------------------------------------------------------------
// 4 options :
// A- si $Wfin != 0 et $Hfin != 0 : crop aux dimensions indiquees
// B- si $Wfin = 0 et $Hfin != 0 : crop en HAUTEUR (meme largeur que la source)
// C- si $Wfin != 0 et $Hfin = 0 : crop en LARGEUR (meme hauteur que la source)
// D- si $Wfin = 0 et $Hfin = 0 : (cas special) crop "carre" a la plus petite dimension de l image source
// --------------------------------------------------------------------------------------------------
// - 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 = fct_crop_image(120,80,'reppicto/','monpicto.jpg','repimage/','monimage.jpg');
// if ($cropOK == 1) { echo 'Crop centré OK !'; }
// --------------------------------------------------------------------------------------------------
function fct_crop_image($Wfin, $Hfin, $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)
if ($Wfin == '') { $Wfin = 0; }
if ($Hfin == '') { $Hfin = 0; }
// ------------------------------------------------------------------
// 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
$size = getimagesize($rep_Src.$img_Src);
$W_Src = $size[0]; // largeur
$H_Src = $size[1]; // hauteur
// -------------------------------------------------------------
// condition de crop et dimensions de l image finale
// -------------------------------------------------------------
// A- crop aux dimensions indiquees
if ($Wfin != 0 && $Hfin != 0) {
$W = $Wfin;
$H = $Hfin;
}
// -------------------------------------------------------------
// B- crop en HAUTEUR (meme largeur que la source)
if ($Wfin == 0 && $Hfin != 0) {
$H = $Hfin;
$W = $W_Src;
}
// -------------------------------------------------------------
// C- crop en LARGEUR (meme hauteur que la source)
if ($Wfin != 0 && $Hfin == 0) {
$W = $Wfin;
$H = $H_Src;
}
// D- (cas special) crop "carre" a la plus petite dimension de l image source
if ($Wfin == 0 && $Hfin == 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 ($Wfin == 0) {
if ($Hfin == 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 ($Hfin == 0) {
if ($Wfin == 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);
}
// -------------------------------------------------------------
}
// --------------------------------------------------------------------------------------------------
// retourne : 1 (vrai) si le redimensionnement et l enregistrement ont bien eu lieu, sinon rien (false)
// si le fichier a bien ete cree
if ($condition == 1 && file_exists($rep_Dst.$img_Dst)) { return true; }
else { return false; }
}
// --------------------------------------------------------------------------------------------------
?>
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 a 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 après "upload" la taille des images à nos besoins (si nécessaire)
(gain de temps de chargement et d'espace disque).
- créer des images de prévisualisation (pictos) à la volée.
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")
- Traitement :
- gestion des erreurs,
- (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- Les fonctions de redimensionnement)
- fct_affich_image.php
- fct_redim_image.php
- fct_crop_image.php
_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");
?>
Création de la table MATABLE
Via PhpMyAdmin, ou requête SQL :
CREATE TABLE 'MATABLE' (
'NUM' INT( 11 ) NOT NULL AUTO_INCREMENT ,
'COMMENT1' VARCHAR( 255 ) ,
'PHOTO1' VARCHAR( 255 ) ,
'PICTO1' VARCHAR( 255 ) ,
PRIMARY KEY ( 'NUM' )
) TYPE = MYISAM ;
MONFICHIER_LISTE.php
dans cet exemple :
- affichage en ligne les pictos des photos présentes dans la table de la base de données,
- avec pour chacune des boutons "Modifier" et "Supprimer"
- et un bouton "Ajouter Nouveau"
<?php
// connexion a la base de donnees
include("_connexion.php");
// FONCTION de redimensionnement "à l affichage"
include("fct_affich_image.php");
// --------------------------------------------------------------------------------------------------
// La base de données (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 nécessaire en mode AJOUTER
// --------------------------------------------------------------------------------------------------
// mettre le nom de la table dans une variable :
$table = 'MATABLE';
// REMARQUE : on peut utiliser ce fichier pour PLUSIEURS TABLES (de même structure)
// $table = $_GET['CAT'];
// (préciser le nom de la table à l'appel du fichier : MONFICHIER_LISTE.php?CAT=MATABLE)
// --------------------------------------------------------------------------------------------------
// Les photos et pictos sont stockés dans un dossier déprotégé en écriture
$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());
?>
<html><head><title></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>
<a href="MONFICHIER_FORM.php?CAT=<?php echo $table; ?>
&TRAITER=SUPPRIMER&NUM=<?php echo $val['NUM']; ?>">
Supprimer</a><br/>
<?php if ($val[PICTO1] != "") { ?>
<img border="0" src="<?php echo $chemincourt.$val['PICTO1']; ?>"
<?php fct_affich_image(100, 100, $chemincourt.$val['PICTO1']) ?>>
<?php } ?>
</td>
<?php
} // fin while
// --------------------------------------------------------------------------------------------------
?>
</tr>
</table>
</div>
</center></body></html>
<?php // liberation de la ressource et deconnexion
mysql_free_result($result);
mysql_close();
?>
MONFICHIER_FORM.php
dans cet exemple : on affiche
- le bon formulaire en fonction de l'option choisie (ajouter, modifier, supprimer)
- la fiche concernée (photo et commentaire)
<?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);
}
// --------------------------------------------------------------------------------------------------
?>
<html><head><title></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 TYPE=FILE NAME="PHOTO1" size="50"><br/>
<a href="#" onclick="history.back()">ANNULER</a>
<INPUT type="submit" value="CONFIRMER" name="CONFIRMER">
<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 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>
<INPUT type="submit" value="CONFIRMER" name="CONFIRMER">
<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>
<INPUT type="submit" value="CONFIRMER" name="CONFIRMER"><br/>
<?php echo $val['COMMENT1']; ?>
<?php if ($val['PHOTO1'] != "") { ?>
<br/><img 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();
?>
MONFICHIER_TRAITER.php
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)
- PICTO ? (ex. : on veut 100 x 100 pixels maxi)
--> 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- suppression des photos et pictos concernés dans le répertoire.
<?php
// connexion a la base de donnees
include("_connexion.php");
// FONCTIONS de redimensionnement "physique"
include("fct_redim_image.php");
// include("fct_crop_image.php"); // (inutile ici)
// --------------------------------------------------------------------------------------------------
// 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') {
echo 'isset ? NON<br/>';
$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']=='') {
echo 'isset ? NON<br/>';
$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')) {
echo 'isset ? OUI<br/>';
// 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) {
echo 'TRAITEMENT OK<br/>';
// --------------------------------------------------------------------------------------------------
// TRAITEMENT du formulaire
// --------------------------------------------------------------------------------------------------
if ($TRAITER == 'AJOUTER') {
// recuperation des elements du formulaire
$COMMENT = addslashes($_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=$_POST['NUM'];
$COMMENT = addslashes($_POST['COMMENT1']);
// -------------------------------------------------------------
// ENREGISTREMENT dans la BASE DE DONNEES par UPDATE
$SQL = 'UPDATE '.$table.' SET COMMENT1=''.$COMMENT.'' WHERE NUM= '.$NUM;
mysql_query($SQL);
// -------------------------------------------------------------
$PHOTOavant = $_POST['PHOTO1avant'];
$PICTOavant = $_POST['PICTO1avant'];
// par defaut
$PHOTO = $PHOTOavant;
$PICTO = $PICTOavant;
}
// --------------------------------------------------------------------------------------------------
// 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 = fct_redim_image(600,0,'','',$chemincourt,$PHOTO);
// $redimPHOTOok =1 si OK
// -------------------------------------------------------------
// REDIMENSIONNEMENT et SAUVEGARDE du PICTO
// -------------------------------------------------------------
// on veut : un picto de 100 x 100 pixels maxi
// enregistrer en ajoutant 'picto_' devant le nom de la photo
// dans le meme repertoire que la photo
$redimPICTOok = fct_redim_image(100,100,'','picto_'.$PHOTO,$chemincourt,$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 ($PHOTOavant != '' && $PHOTOavant != $PHOTO && $PHOTOavant != $PICTO) {
unlink($cheminlong.$PHOTO1avant); // Suppression de la photo
}
if ($PICTOavant != '' && $PICTOavant != $PHOTO && $PICTOavant != $PICTO) {
unlink($cheminlong.$PICTOavant); // 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=$_POST['NUM'];
$PHOTOavant=$_POST['PHOTO1avant'];
$PICTOavant=$_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 ($PHOTOavant != '') {
unlink($cheminlong.$PHOTOavant); // Suppression de la photo
}
if ($PICTOavant != '' && $PICTOavant != $PHOTOavant) {
unlink($cheminlong.$PICTOavant); // Suppression du picto
}
}
// --------------------------------------------------------------------------------------------------
?>
<html><head><title></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 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(); ?>
Compléments
Utilisation dans un espace d'administration :
voir http://www.phpcs.com/tutoriaux/PHP-ADMINISTRER-LIGNE-PROTECTION-PAGES_882.aspx
Utilisation par les visiteurs (espace membre):
On doit d'abord récupérer l'IDvisiteur.
(le visiteur ne doit pas avoir accès à toute la base, mais seulement à ses propres photos !)
- soit il a ses propres tables (ex. IDvisiteur_MATABLE1, ...)
- soit vérifier ses droits d'accès avant ...
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
Utilisation avec un dossier
Hypothèse
Vous avez un dossier "repPHOTOS" contenant déjà des images.
Vous souhaitez créer des images de prévisualisation (pictos), de 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 ou via logiciel FTP)
Principe
- ouvrir le répertoire,
- lire les fichiers
- redimensionner (si nécessaire) en fonction des conditions requises
--> utilisation de la fonction fct_redim_image(...)
- enregistrer le picto dans le dossier de destination.
Remarque
Par défaut, la fonction fct_redim_image(...) 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 ...
MONDOSSIER_REDIM.php
<?php
// FONCTIONS de redimensionnement "physique"
include("fct_redim_image.php");
// include("fct_crop_image.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 ou via logiciel FTP)
// --------------------------------------------------------------------------------------------------
?>
<html><head><title></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 = fct_redim_image(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>
A voir également
- Php redimensionner image
- Redimensionner image php - Meilleures réponses
- Crop image php - Meilleures réponses
- Php table - Conseils pratiques -PHP
- Vectoriser une image photoshop ✓ - Forum Graphisme/design
- Inverser une image photoshop - Forum Graphisme/design
- "Php version 4.4.5" "build date" "server api" "php variables" ✓ - Forum PHP
- Php protected ✓ - Forum PHP
Ce document intitulé « Php - redimensionner image + picto après upload » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.