Nécessite PHP5 et GD2
Création et manipulation d'images grâce à la librairie GD2 et PHP5, attention pensez à activer GD2 !
Permet la manipulation d'image (rogner, filtres etc) et leur sauvegarde sans altérer le fichier source.
Cette class permet :
- Créer une nouvelle image.
- Ouvrir une image (sans spécifier le type)
- Conversion d'image
- De fusionner des images (pour ajouter un watermark a vos images par ex)
- De redimensionner des images (selon la hauteur, largeur, taille fixe)
- De rogner une image
- D'afficher une image dans le navigateur
- D'ajouter des filtres sur une image (à la photoshop)
- Ajouter un masque d'opacité (canal alpha) sur vos images (pour mettre des angles arrondis par exemples)
- Ajouter un motif à une image
- De sauvegarder les traitements sans altérer l'image d'origine
- De manipuler les fichiers BMP
Source / Exemple :
<?php
/**
- Fichier à inclure inc.class.pics.php5
*
- LICENSE: Paternité Pas d'Utilisation Commerciale
*
/**
- Création et manipulation d'images
*
- Création et manipulation d'images grâce à la librairie GD2 et PHP5, attention pensez à activer GD2 !
- Permet la manipulation d'image (rogner, filtres etc) et leur sauvegarde sans altérer le fichier source.
*
*
- MIXED __construct() : 1 si instanciation réussie sinon lance exception
- MIXED newPics() : Ressource si création de l'image réussie sinon lance exception
- MIXED open() : Ressource si l'image est ouverte correctement sinon lance exception
- STRING name : Retourne le nom d'un fichier sans son extension
- ARRAY info : Retourne la largeur et la hauteur d'une image
- MIXED merge() : 0 si les images n'existent pas, sinon renvoi la resource image de deux images fusionnées
- MIXED resize() : 0 si les images n'existent pas, sinon renvoi la resource image redimensionnée
- MIXED crop() : 0 si les images n'existent pas, sinon renvoi la resource image de deux images rognée
- RESOURCE filter() : RESOURCE image avec un filtre appliqué
- RESOURCE mask() : RESOURCE image avec un masque d'opacité appliqué sinon 0
- RESOURCE pattern() : 1 si motif appliqué sur une image sinon exception
- RESOURCE display() : Affiche une ressource image dans le navigateur
- RESOURCE imagecreatefrombmp() : Création d'une ressource GD à partir d'une image au format BMP
- BOOL save() : 1 si la sauvegarde s"est correctement déroulée, sauvegarde la ressource courante sous forme d'un fichier image
- BOOL saveByActions() : Sauvegarde les traitements dans un fichier
- BOOL loadByActions() : Charge des traitements
- VOID reset : Vide la pile courante de traitement éffectués sur la ressource image
- STRING __tostring : Infos sur l'objet courant
- /
/**
- Définition des flags nécessaires.
- /
// Type
define ('PNG', 'PNG');
define ('JPEG', 'JPEG');
define ('GIF', 'GIF');
define ('JPG', 'JPEG');
define ('BMP', 'BMP');
// Palette
define ('TRUE_COLOR', 'TRUE_COLOR');
define ('INDEXED', 'INDEXED');
// New filter
define ('IMG_FILTER_SEPIA', 'IMG_FILTER_SEPIA');
// Position CROP
define ('TOP_LEFT','TOP_LEFT');
define ('TOP', 'TOP');
define ('TOP_RIGHT','TOP_RIGHT');
define ('RIGHT', 'RIGHT');
define ('BOTTOM_RIGHT', 'BOTTOM_RIGHT');
define ('BOTTOM', 'BOTTOM');
define ('BOTTOM_LEFT', 'BOTTOM_LEFT');
define ('LEFT', 'LEFT');
define ('CENTER', 'CENTER');
define ('CUSTOM', 'CUSTOM');
// Alpha
define ('RESIZE_TO_MASK_SIZE', 'RESIZE_TO_MASK_SIZE');
define ('RESIZE_TO_PICTURES_SIZE', 'RESIZE_TO_PICTURES_SIZE');
// Save
define ( 'NEW_FILE', 'NEW_FILE' );
define ( 'REPLACE_FILE', 'REPLACE_FILE' );
define ( 'STACK', 'STACK' );
// Type instance
define ( 'LOAD_FILE', 'LOAD_FILE');
define ( 'NEW_GD', 'NEW_GD');
class Pics {
// Ressource GD courante
public $_gdPics;
public $height;
public $width;
public $picsType;
public $src;
// Pile de traitement faits sur l'image courante
public $stack;
// getters
public function getHeight() {
return $this->height;
}
public function getWidth() {
return $this->width;
}
public function getPicsType() {
return $this->type;
}
public function getGdPics() {
return $this->_gdPics;
}
/**
- Instanciation de la class ouverture d'une image existante $nameOrLength
- Ou création d'une nouvelle ressource image de longueur $nameOrLength
- et de hauteur $height.
*
- @arguments $nameOrLength STRING Chemin d'accès d'une image
- INT Largeur d'une nouvelle image
*
- @arguments $height NULL Si $nameOrLength est une chaine
- INT Hauteur d'une nouvelle image
*
*
- @return TRUE Si la nouvelle ressource image est crée avec succès
*
- @throw EXCEPTION Si $nameOrLength n'est pas un chemin d'accès valide
- Ou si $nameOrLength et $height ne sont pas des entiers
- /
public function __construct( $nameOrLength, $height = NULL ) {
$this->stack = array();
if ( !extension_loaded( 'gd' ) ) {
throw new Exception('GD2 disabled');
}
if( is_file( $nameOrLength ) && $height === NULL ) {
$this->_gdPics = $this->open( $nameOrLength ) ;
$this->src = $nameOrLength ;
$this->type = LOAD_FILE ;
$this->height = imagesy($this->_gdPics) ;
$this->width = imagesx($this->_gdPics) ;
}
elseif( is_int( $nameOrLength ) && is_int( $height ) ) {
// Demande une nouvelle ressource image
$this->_gdPics = $this->newPics( $nameOrLength, $height ) ;
$this->width = $nameOrLength ;
$this->height = $height ;
$this->type = NEW_GD ;
}
else {
throw new Exception('Missing ressource or pics doesn\'t exist');
}
$this->stack[] = array( __FUNCTION__, func_get_args() );
return TRUE;
}
/**
- Créer une nouvelle ressource image, de largeur $largeur, de hauteur $hauteur, avec comme nombre de couleur
- $flag, de couleur RGB $R, $G, $B, et comme opacité $alpha
*
*
- @arguments INT $largeur, largeur en pixel
- INT $hauteur, hauteur en pixel
- STRING $flag DEFAULT TRUE_COLOR image 32 bits
- INDEXED image 1 bits
- INT $alpha opacite 0 : opacite complete, 127 transparence complete
- @return RESOURCE images
- /
public function newPics( $largeur, $hauteur, $flag = TRUE_COLOR, $R = '255', $G = '255', $B = '255', $alpha = '127' ) {
switch ($flag) {
case TRUE_COLOR :
$pictures = imagecreatetruecolor($largeur, $hauteur);
$fond = imagecolorallocatealpha($pictures, $R, $G, $B, $alpha);
imagefill($pictures, 0, 0, $fond);
imagesavealpha($pictures, true);
break;
case INDEXED :
$pictures = imagecreate($largeur, $hauteur);
$fond = imagecolorallocatea($pictures, $R, $G, $B);
imagefill($pictures, 0, 0, $fond);
break;
default :
throw new Exception ('Bad $flag, try : TRUE_COLOR, INDEXED');
break;
}
$this->stack[] = array(__FUNCTION__, func_get_args() );
return $pictures;
}
/**
- Creation d'une ressource image gd
*
- @arguments STRING $pictures chemin d'accés à une image
- @return BOOL 0 si une erreur est survenuee
- RESOURCE images
- /
public function open( $pictures ) {
if( !is_file($pictures) ) { return FALSE; }
$pictures_param = $this->infos( $pictures );
switch( $pictures_param['mime'] ) {
case 'image/png' :
return imagecreatefrompng($pictures);
break;
case 'image/jpeg' :
return imagecreatefromjpeg($pictures);
break;
case 'image/gif' :
return imagecreatefromgif($pictures);
break;
case 'image/x-ms-bmp' :
case 'image/bmp' :
return $this->imagecreatefrombmp($pictures);
break;
default :
return FALSE;
break;
}
}
/**
- Retourne une ressource GD à partir d'une image BMP
*
private function imagecreatefrombmp($filename) {
// Ouverture du fichier en mode binaire
if (! $f1 = fopen($filename,"rb")){ return FALSE; }
//1 : Chargement des entêtes FICHIER
$FILE = unpack( "vfile_type/Vfile_size/Vreserved/Vbitmap_offset", fread( $f1, 14 ) );
if ($FILE['file_type'] != 19778){ return FALSE; }
//2 : Chargement des entêtes BMP
$BMP = unpack( 'Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel'.
'/Vcompression/Vsize_bitmap/Vhoriz_resolution'.
'/Vvert_resolution/Vcolors_used/Vcolors_important', fread( $f1, 40 ) );
$BMP['colors'] = pow( 2, $BMP['bits_per_pixel'] );
if ( $BMP['size_bitmap'] == 0 ) {
$BMP['size_bitmap'] = $FILE['file_size'] - $FILE['bitmap_offset'];
}
$BMP['bytes_per_pixel'] = $BMP['bits_per_pixel'] / 8;
$BMP['bytes_per_pixel2'] = ceil( $BMP['bytes_per_pixel'] );
$BMP['decal'] = ( $BMP['width'] * $BMP['bytes_per_pixel'] / 4 );
$BMP['decal'] -= floor( $BMP['width']*$BMP['bytes_per_pixel'] / 4 );
$BMP['decal'] = 4 - ( 4 * $BMP['decal'] );
if ( $BMP['decal'] == 4 ){
$BMP['decal'] = 0;
}
//3 : Chargement des couleurs de la palette
$PALETTE = array();
if ( $BMP['colors'] < 16777216 && $BMP['colors'] != 65536 ) {
$PALETTE = unpack('V' . $BMP['colors'], fread( $f1, $BMP['colors'] * 4 ) );
}
//4 : Création de l'image
$IMG = fread( $f1, $BMP['size_bitmap'] );
$VIDE = chr( 0 );
$res = imagecreatetruecolor( $BMP['width'], $BMP['height'] );
$P = 0;
$Y = $BMP['height'] - 1;
while ( $Y >= 0 ) {
$X = 0;
while ( $X < $BMP['width'] ) {
if ($BMP['bits_per_pixel'] == 24) {
$COLOR = unpack("V",substr($IMG,$P,3).$VIDE);
}
elseif ( $BMP['bits_per_pixel'] == 16 ) {
$COLOR = unpack( "n", substr( $IMG, $P, 2 ) );
$COLOR[1] = $PALETTE[ $COLOR[1] + 1 ];
}
elseif ( $BMP['bits_per_pixel'] == 8 ) {
$COLOR = unpack( "n", $VIDE . substr( $IMG, $P, 1 ) );
$COLOR[1] = $PALETTE[$COLOR[1]+1];
}
elseif ( $BMP['bits_per_pixel'] == 4 ) {
$COLOR = unpack("n",$VIDE.substr($IMG,floor($P),1));
if (($P*2)%2 == 0) $COLOR[1] = ($COLOR[1] >> 4) ; else $COLOR[1] = ($COLOR[1] & 0x0F);
$COLOR[1] = $PALETTE[$COLOR[1]+1];
}
elseif ( $BMP['bits_per_pixel'] == 1 ) {
$COLOR = unpack("n",$VIDE.substr($IMG,floor($P),1));
if(($P*8)%8 == 0) $COLOR[1] = $COLOR[1] >>7;
elseif (($P*8)%8 == 1) $COLOR[1] = ($COLOR[1] & 0x40)>>6;
elseif (($P*8)%8 == 2) $COLOR[1] = ($COLOR[1] & 0x20)>>5;
elseif (($P*8)%8 == 3) $COLOR[1] = ($COLOR[1] & 0x10)>>4;
elseif (($P*8)%8 == 4) $COLOR[1] = ($COLOR[1] & 0x8)>>3;
elseif (($P*8)%8 == 5) $COLOR[1] = ($COLOR[1] & 0x4)>>2;
elseif (($P*8)%8 == 6) $COLOR[1] = ($COLOR[1] & 0x2)>>1;
elseif (($P*8)%8 == 7) $COLOR[1] = ($COLOR[1] & 0x1);
$COLOR[1] = $PALETTE[$COLOR[1]+1];
}
elseif ($BMP['bits_per_pixel'] == 16) {
$COLOR = unpack("v",substr($IMG,$P,2));
$blue = (($COLOR[1] & 0x001f) << 3) + 7;
$green = (($COLOR[1] & 0x03e0) >> 2) + 7;
$red = (($COLOR[1] & 0xfc00) >> 7) + 7;
$COLOR[1] = $red * 65536 + $green * 256 + $blue;
}
else { return FALSE; }
imagesetpixel($res,$X,$Y,$COLOR[1]);
$X++;
$P += $BMP['bytes_per_pixel'];
}
$Y--;
$P+=$BMP['decal'];
}
//Fermeture du fichier
fclose($f1);
return $res;
}
/**
- Retourne un nom de fichier $fichier sans son extension, utile pour PHP < 5.2.0
*
- @arguments STRING $fichier nom de fichier avec son extension
- @return STRING nom de fichier sans son extension
- /
protected function name( $fichier ) {
return basename ( $fichier, strrchr( $fichier, '.' ) );
}
/**
- Renvoie les propriétés d'une image $pictures voir function getimagesize()
- dans le manuel PHP
*
- @arguments STRING $pictures chemin d'accès à une image ou une ressource
- @return BOOL FALSE si une erreur est survenuee
- TRUE en cas de succès
- /
protected function infos( $pictures ) {
if( !is_resource($pictures) ) {
return getimagesize( $pictures ) ;
}
else {
$values["Width"] = imagesx( $pictures );
$values["Height"] = imagesy( $pictures );
return $values;
}
}
/**
- Copie une image $picturestomerge avec comme opacité $picturestomergeopacity dans la ressource GD
- courante dans une zone prédéfinie $flag avec une marge $margin , ou à l'endroit souhaité avec
- comme coordonnées ($x_origin, $y_origin).
*
- @arguments STRING $picturestomerge l'image à inserer dans $pictures
- INT $picturestomergeopacity 0 : opaque, 127 transparent
- CONST $flag voir set_crop_pics()
- INT $x_origin coordonnée x de l'image à coller
- INT $y_origin coordonnée y de l'image à coller
- INT $margin marge souhaitée en pixel
- @return BOOL 1 en cas de succès
-
- /
public function merge( $picturestomerge, $flag = CENTER, $picturestomergeopacity = 99, $x_origin = NULL, $y_origin = NULL, $margin = NULL ) {
// var_dump($picturestomerge);
if( is_object( $picturestomerge ) ) {
$pictures = $picturestomerge->_gdPics ;
$picsToMergeWidth = $picturestomerge->getWidth();
$picsToMergeHeight = $picturestomerge->getHeight();
}
elseif( is_string( $picturestomerge ) ) {
$temp = new Pics($picturestomerge);
$pictures = $temp->_gdPics;
$picsToMergeWidth = $temp->getWidth();
$picsToMergeHeight = $temp->getHeight();
}
elseif( is_resource( $picturestomerge ) ) {
$pictures = $picturestomerge;
$picsToMergeWidth = imagesx($picturestomerge);
$picsToMergeHeight = imagesy($picturestomerge);
}
static $x ;
static $y ;
switch ($flag) {
case TOP_LEFT:
$x = 0 + $margin;
$y = 0 + $margin ;
break;
case TOP:
$x = ($this->getWidth() - $picsToMergeWidth) / 2;
$y = 0 + $margin;
break;
case TOP_RIGHT:
$x = ($dest_im[0] - $src_im[0]) - $margin;
$y = 0 - $margin;
break;
case RIGHT:
$x = ($dest_im[0] - $src_im[0]) - $margin;
$y = ($dest_im[1] - $src_im[1]) / 2;
break;
case BOTTOM_RIGHT:
$x = ($dest_im[0] - $src_im[0]) - $margin;
$y = ($dest_im[1] - $src_im[1]) - $margin;
break;
case BOTTOM:
$x = ($dest_im[0] - $src_im[0]) / 2;
$y = ($dest_im[1] - $src_im[1]) - $margin;
break;
case BOTTOM_LEFT :
$x = 0 + $margin;
$y = ($dest_im[1] - $src_im[1]) - $margin;
break;
case LEFT :
$x = 0 + $margin;
$y = ($dest_im[1] - $src_im[1]) / 2;
break;
case CENTER :
$x = floor( ( $this->getWidth() - $picsToMergeWidth ) / 2);
$y = floor( ( $this->getHeight() - $picsToMergeHeight ) / 2);
break;
case CUSTOM :
$x = $x_origin;
$y = $y_origin;
break;
default :
throw new Exception ('Bad $flag, try : TOP_LEFT, TOP, TOP_RIGHT, RIGHT, BOTTOM_RIGHT, BOTTOM, BOTTOM_LEFT, LEFT, CENTER, CUSTOM');
break;
}
imagecopymerge( $this->_gdPics, $temp->_gdPics, $x, $y, 0, 0, $picsToMergeWidth, $picsToMergeHeight , $picturestomergeopacity );
$this->stack[] = array(__FUNCTION__, func_get_args() );
unset($temp);
return true;
}
/**
- Redimensionne l'image courante, avec proportionalité sur la hauteur $new_width, largeur $new_height
- ou selon une taille prédéfinie ($new_width, $new_height)
*
- @arguments INT $new_width taille en pixel de la largeur voulue
- INT $new_height taille en pixel de la hauteur voulue
-
- @return BOOL 0 si une erreur est survenue
- RESOURCE images
- /
public function resize( $new_width = NULL, $new_height = NULL ) {
if( $this->type == LOAD_FILE ) {
$pics_param = self::infos( $this->src ) ;
$pictures_origin = self::open( $this->src ) ;
// $pictures_origin = $this->_gdPics ;
}
else {
$pics_param[0] = $this->width ;
$pics_param[1] = $this->height ;
}
// Resize fixed width and height
if( isset( $new_width ) && isset( $new_height ) ) {
$width = $new_width;
$height = $new_height;
}
// Resize by new width
elseif( isset( $new_width ) && is_null( $new_height ) ) {
// Ratio by width
if( $new_width > $pics_param[0] ) {
$ratio = $new_width / $pics_param[0] ;
$width = $new_width ;
$height = round( $pics_param[1] * $ratio ) ;
}
else {
$ratio = $pics_param[0] / $new_width ;
$width = $new_width ;
$height = round( $pics_param[1] / $ratio ) ;
}
}
// Resize by new height
elseif( isset( $new_height ) && is_null( $new_width ) ) {
// Ratio by height
if( $new_height > $pics_param[1] ) {
$ratio = $new_height / $pics_param[1] ;
$width = round( $pics_param[0] * $ratio ) ;
$height = $new_height ;
}
else {
$ratio = $pics_param[1] / $new_height ;
$width = round( $pics_param[0] / $ratio ) ;
$height = $new_height ;
}
}
$image_mini = imagecreatetruecolor( $width, $height ) ;
ImageAlphaBlending( $image_mini, false );
ImageSaveAlpha( $image_mini, true );
imagecopyresampled( $image_mini, $this->_gdPics, 0, 0, 0, 0, $width, $height, $pics_param[0], $pics_param[1] ) ;
$this->_gdPics = $image_mini;
unset($image_mini);
$this->stack[] = array(__FUNCTION__, func_get_args());
return TRUE;
}
/**
- Rogne l'image courante de largeur $width_cropt et de hauteur $height_crop a l'endroit prédéfinie $flag, ou selon les
- coordonnées prédefinies ($x_origin, $y_origin) si $flag = custom
*
- @arguments STRING $image_saved nom de l'image à sauvegarder
- INT $width_crop taille en pixel de la largeur voulue finale
- INT $height_crop taille en pixel de la hauteur voulue finale
- CONT $flag TOP_LEFT, TOP, TOP_RIGHT, RIGHT, BOTOM_RIGHT, BOTTOM, BOTTOM_LEFT, CENTER
- CUSTOM
- INT $x_origin Coordonée de l'origin x si $flag = CUSTOM
- INT $y_origin Coordonée de l'origin y si $flag = CUSTOM
-
- @return BOOL 1 En cas de succès sinon 0
- /
public function crop( $width_crop, $height_crop, $flag = CENTER, $x_origin = '', $y_origin = '' ) {
if( $this->type === LOAD_FILE ) {
$pics_param = self::infos( $this->src ) ;
}
else {
$pics_param[0] = $this->width ;
$pics_param[1] = $this->height ;
}
if( $width_crop >= $pics_param[0] || $height_crop >= $pics_param[1] ) {
return FALSE ;
}
else {
$pictures_origin = self::open( $this->src ) ;
$image_mini = imagecreatetruecolor( $width_crop, $height_crop ) ;
if( $x_origin != '' && $y_origin != '' && $flag = CUSTOM ) {
ImageAlphaBlending( $image_mini, false );
ImageSaveAlpha( $image_mini, true );
imagecopyresampled( $image_mini, $this->_gdPics, 0, 0, $x_origin, $y_origin, $width_crop, $height_crop, $width_crop, $height_crop);
$this->_gdPics = $image_mini;
}
else {
static $x;
static $y;
switch ($flag) {
case TOP_LEFT:
$x = 0;
$y = 0;
break;
case TOP:
$x = ($pics_param[0] - $width_crop) / 2;
$y = 0;
break;
case TOP_RIGHT:
$x = ($pics_param[0] - $width_crop);
$y = 0;
break;
case RIGHT:
$x = ($pics_param[0] - $width_crop);
$y = ($pics_param[1] - $height_crop) / 2;
break;
case BOTTOM_RIGHT:
$x = ($pics_param[0] - $width_crop);
$y = ($pics_param[1] - $height_crop);
break;
case BOTTOM:
$x = ($pics_param[0] - $width_crop) / 2;
$y = ($pics_param[1] - $height_crop);
break;
case BOTTOM_LEFT :
$x = 0;
$y = ($pics_param[1] - $height_crop);
break;
case LEFT :
$x = 0;
$y = ($pics_param[1] - $height_crop) / 2;
break;
case CENTER :
$x = ($pics_param[0] - $width_crop) / 2;
$y = ($pics_param[1] - $height_crop) / 2;
break;
default :
throw new Exception ('Bad $flag, try : TOP_LEFT, TOP, TOP_RIGHT, RIGHT, BOTTOM_RIGHT, BOTTOM, BOTTOM_LEFT, LEFT, CUSTOM');
break;
}
ImageAlphaBlending( $image_mini, false );
ImageSaveAlpha( $image_mini, true );
imagecopyresampled( $image_mini, $this->_gdPics, 0, 0, $x, $y, $width_crop, $height_crop, $width_crop, $height_crop);
$this->_gdPics = $image_mini;
unset($image_mini);
}
}
$this->stack[] = array( __FUNCTION__, func_get_args() );
return TRUE;
}
/**
- Applique un filtre $filtre sur l'image courante
*
- @arguments RESSOURCE $ressource une ressource image
- CONST $filtre IMG_FILTER_NEGATE Negatif de $pictures
- IMG_FILTER_GRAYSCALE Supprime les couleurs
- IMG_FILTER_BRIGHTNESS Luminosité de l'image
- INT $filtre_param_1 obligatoire 255 : Eclaircir l'image avec un maximum vers le blanc (effet de brillance)
- 0 : Couleurs inchangées
- -255 : Assombrir l'image au maximum vers le noir (effet sombre)
- IMG_FILTER_CONTRAST Contraste de l'image
- INT $filtre_param_1 obligatoire 255 : Eclaircir l'image avec un maximum vers le blanc (effet de brillance)
- 0 : Couleur inchangées
- -255 : Assombrir l'image au maximum vers le noir (effet sombre)
- IMG_FILTER_COLORIZE Modifie les tendances de couleurs (RGB)
- INT $filtre_param_1 obligatoire Valeur R [-255, 255]
- INT $filtre_param_2 obligatoire Valeur G [-255, 255]
- INT $filtre_param_3 obligatoire Valeur B [-255, 255]
- INT $filtre_param_4 obligatoire Valeur Alpha [-255, 255]
- IMG_FILTER_EDGEDETECT utilise la détection des bords pour les mettre en évidence dans l'image.
- IMG_FILTER_EMBOSS grave l'image en relief
- IMG_FILTER_GAUSSIAN_BLUR brouille l'image en utilisant la méthode gaussienne.
- IMG_FILTER_SELECTIVE_BLUR brouille l'image
- IMG_FILTER_MEAN_REMOVAL son utilisation signifie le déplacement pour réaliser un effet "peu précis"
- IMG_FILTER_SMOOTH rend l'image lissée (smooth). Utilisez le paramètre args1 pour définir le degré de lissoir [-8, 8]
- IMG_FILTER_PIXELATE applique un effet de pixelisation à l'image; utilise arg1 pour indiquer la taille de bloc, et arg2 pour indiquer le mode de pixelisation.
-
- @return BOOL 0 si une erreur est survenue
- RESOURCE images
- /
public function filter( $filtre, $filtre_param_1 = '', $filtre_param_2 = '', $filtre_param_3 = '', $filtre_param_4 = '' ) {
switch( $filtre ) {
case IMG_FILTER_NEGATE :
case IMG_FILTER_GRAYSCALE :
case IMG_FILTER_EDGEDETECT :
case IMG_FILTER_EMBOSS :
case IMG_FILTER_GAUSSIAN_BLUR :
case IMG_FILTER_SELECTIVE_BLUR :
case IMG_FILTER_MEAN_REMOVAL :
$this->stack[] = array( __FUNCTION__,func_get_args() );
return imagefilter( $this->_gdPics, $filtre ) ;
break;
case IMG_FILTER_BRIGHTNESS :
case IMG_FILTER_CONTRAST :
case IMG_FILTER_SMOOTH :
$this->stack[] = array( __FUNCTION__,func_get_args() );
return imagefilter( $this->_gdPics, $filtre, $filtre_param_1 );
break;
case IMG_FILTER_COLORIZE :
$this->stack[] = array( __FUNCTION__,func_get_args() );
return imagefilter( $this->_gdPics, IMG_FILTER_CONTRAST, $filtre_param_1, $filtre_param_2, $filtre_param_3, $filtre_param_4 );
break;
case IMG_FILTER_PIXELATE :
$this->stack[] = array( __FUNCTION__,func_get_args() );
return imagefilter( $this->_gdPics, IMG_FILTER_PIXELATE, $filtre_param_1, $filtre_param_2 );
break;
case IMG_FILTER_SEPIA :
$this->stack[] = array( __FUNCTION__,func_get_args() );
imagefilter( $this->_gdPics, IMG_FILTER_GRAYSCALE );
return imagefilter( $this->_gdPics, IMG_FILTER_COLORIZE, 100, 50, 0);
break;
default :
return $this->_gdPics;
break;
}
}
/**
- Applique un masque d'opacité $mask sur l'image courante
- Attention $mask DOIT être une image PNG avec canal ALPHA (png 24 bits)
*
- @arguments RESSOURCE $pictures chemin d'accès d'une image
- $mask chemin d'accès d'une image png
- CONST $flag RESIZE_TO_PICTURES_SIZE Les dimensions de $mask seront adaptées aux dimensions de $pictures defaut
- RESIZE_TO_MASK_SIZE Les dimensions de $pictures seront adaptées aux dimensions de $mask
-
- @return BOOL 1 En cas de succès
*
- @throw EXCEPTION si $flag n'est pas reconnu
- /
public function mask( $mask, $flag = RESIZE_TO_PICTURES_SIZE ) {
if( ( self::open( $mask ) ) === FALSE ) {
return FALSE;
}
else {
switch ($flag) {
case RESIZE_TO_PICTURES_SIZE :
$srcpicsproperties = array($this->width, $this->height);
$srcpics = $this->_gdPics;
imagealphablending ($srcpics, FALSE);
$srcoriginmask = self::open ( $mask );
$srcoriginmasksize = getimagesize( $mask );
$srcmask = imagecreatetruecolor ($srcpicsproperties[0], $srcpicsproperties[1]);
imagealphablending ( $srcmask, FALSE );
imagecopyresized ( $srcmask, $srcoriginmask, 0, 0, 0, 0, $srcpicsproperties[0], $srcpicsproperties[1], $srcoriginmasksize[0], $srcoriginmasksize[1]);
break;
case RESIZE_TO_MASK_SIZE :
$srcpicsproperties = getimagesize( $mask );
$srcpics = self::resize($this->_gdPics, $srcpicsproperties[0], $srcpicsproperties[1]);
$srcmask = self::open( $mask );
break;
default :
throw new Exception ('Bad $flag, try : RESIZE_TO_PICTURES_SIZE, RESIZE_TO_MASK_SIZE');
break;
}
}
for ($i=0; $i < $srcpicsproperties[0]; ++$i) {
for ($j=0; $j < $srcpicsproperties[1]; ++$j) {
$pxl_alpha = imagecolorsforindex ( $srcmask, imagecolorat ($srcmask, $i, $j));
$pxl_color = imagecolorsforindex ( $srcpics, imagecolorat ($srcpics, $i, $j));
$color = imagecolorallocatealpha (
$srcpics,
$pxl_color['red'],
$pxl_color['green'],
$pxl_color['blue'],
$pxl_alpha['alpha']);
imagesetpixel ($srcpics, $i, $j, $color);
}
}
$this->stack[] = array( __FUNCTION__, func_get_args() );
imagesavealpha ($srcpics, TRUE);
$this->_gdPics = $srcpics;
return TRUE;
}
/**
- Applique un pattern (motif) sur toute la surface de l'image
- Attention $pattern DOIT être une image PNG avec canal ALPHA (png 24 bits)
*
- @arguments $pattern chemin d'accès d'une image PNG
-
- @return BOOL 1 En cas de succès
*
- @throw EXCEPTION si $pattern n'est pas reconnu
- /
public function pattern( $pattern ) {
if( $this->type == LOAD_FILE ) {
$pictures = $this->src ;
}
else {
$pictures = $this->_gdPics ;
}
if( !is_file( $pattern ) ) {
throw new Exception("Pattern $pattern not found.");
}
static $x = 0 ;
static $y = 0 ;
$propretiesSRC = array($this->width, $this->height);
$propretiesPattern = $this->infos( $pattern );
$nbrColumn = floor( $propretiesSRC[0] / $propretiesPattern[0] ) ;
$nbrRow = floor( $propretiesSRC[1] / $propretiesPattern[1] ) ;
try {
$temp = self::open( $pattern );
}
catch (exception $e) {
echo $e;
}
// Pour chaque ligne
for( $i = 0 ; $i <= $nbrRow ; $i++ ) {
for( $j = 0 ; $j <= $nbrColumn ; $j++ ) {
imagecopy( $this->_gdPics, $temp, $x, $y, 0, 0, $propretiesPattern[0], $propretiesPattern[1] );
$x += $propretiesPattern[0] ;
}
$x = 0;
$y += $propretiesPattern[1] ;
}
$this->stack[] = array( __FUNCTION__, func_get_args() );
return true;
}
/**
- Affiche l'image courante dans le naviguateur
*
- @arguments CONST $flag PNG
- JPEG
- JPG (alias JPEG)
- GIF
-
- @return RESOURCE images
- /
public function display( $flag = PNG ) {
switch ( $flag ) {
case PNG:
header( 'Content-Type: image/' . $flag );
imagepng( $this->_gdPics );
imagedestroy( $this->_gdPics );
break;
case JPG:
header( 'Content-Type: image/jpeg' );
imagejpeg( $this->_gdPics );
imagedestroy( $this->_gdPics );
break;
case JPEG:
header('Content-Type: image/' . $flag);
imagejpeg($this->_gdPics);
imagedestroy($this->_gdPics);
break;
case GIF:
header('Content-Type: image/' . $flag);
imagegif($this->_gdPics);
imagedestroy($this->_gdPics);
break;
default:
header('Content-Type: image/' . $flag);
imagepng($this->_gdPics);
imagedestroy($this->_gdPics);
break;
}
}
/**
- Sauvegarde de la ressource image courante _gdPics sous forme de fichier $savedpictures au format $format de de qualité $quality
*
- @arguments CONST $format format de sortie de l'image, PNG, JPEG, JPG, GIF
*
- STRING $savedpictures Chemin d'accés pour l'image de sortie
*
- INT $quality Qualité de l'image de sortie (compression)
- PNG : 0 pas de compression à 9
- JPG : de 0 (pire qualité, petit fichier) et 100 (meilleure qualité, gros fichier)
- GIF : NULL
-
- @return BOOL 1 En cas de succès
*
- @throw EXCEPTION si $flag n'est pas reconnu
- /
public function save( $format = PNG, $savedpictures = NULL, $quality = 5 ) {
if( is_null( $savedpictures ) ) {
throw new Exception ("Path $savedpictures is null, please specify target saved files.") ;
}
else {
$saved_pics_name = pathinfo( $savedpictures );
}
switch ( $format ) {
case PNG :
if( is_int( $quality ) && $quality >= 0 && $quality <= 9 ) {
imagepng($this->_gdPics, $saved_pics_name['dirname'] . '/' . self::name($savedpictures) . '.png', $quality);
return TRUE;
}
else {
return FALSE;
}
break;
case JPG :
case JPEG :
if( is_int($quality) && $quality >= 0 && $quality <= 100 ) {
imagejpeg($this->_gdPics, $saved_pics_name['dirname'] . '/' . self::name($savedpictures) . '.jpg', $quality);
return TRUE;
}
else {
return FALSE;
}
break;
case GIF :
if( imagegif( $this->_gdPics, $saved_pics_name['dirname'] . '/' . self::name($savedpictures) . '.gif' ) === TRUE ) {
return TRUE;
}
else {
return FALSE;
}
break ;
default :
throw new Exception ("Unknown format $format, please try PNG, JPG, GIF");
break ;
}
}
/**
- Sauvegarde des differents traitement éffectués sur l'image MAIS ne modifie pas l'image source.
*
- @arguments STRING $file Chemin d'un fichier pour sauvegarder les traitements
*
-
- @return BOOL 1 En cas de succès de la sauvegarde
*
- @throw EXCEPTION si $file n'est pas disponible en écriture
- /
public function saveByActions( $file ) {
if ( !is_writable( $file ) && !fopen( $file , "w" ) ) {
throw new Exception("$file is not writable");
}
$string = "";
$compteur = 1;
foreach( $this->stack as $value ) {
$string.= serialize($value) . "\n";
++$compteur;
}
$fp = fopen( $file, 'w+' );
fwrite( $fp, utf8_encode ( $string ) );
fclose( $fp );
return TRUE;
}
/**
- Charge une série de traitement à éffectués sur une image, ATTENTION le fichier sauvegardé DOIT
- être dans le même dossier que l'image source.
*
- @arguments STRING $path Chemin d'accès pour charger les traitements
*
-
- @return OBJECT Un nouvel objet Pics
*
public function loadByActions( $path ) {
$lines = file($path);
$compteur = 0;
foreach ($lines as $content) {
$temp = unserialize($content);
// Juste le nom de la méthode à appliquée
$methode = $temp[0];
array_shift($temp);
// Si ce n'est pas le constructeur
if( $compteur != 0 ) {
call_user_func_array( array($ret, $methode), $temp[0]);
}
// Si c'est le constructeur nous utilisons la reflectivité pour passer des arguments à la méthode __construct
// chose impossible avec call_user_func_array()
else {
// Les arguments doivent être sous forme de chaine et non pas de tableau
$callArgs = '';
foreach($temp as $args) {
$callArgs .= $args;
}
$reflect = new ReflectionClass( get_class() );
$ret = $reflect->newInstanceArgs( $args );
}
$compteur++;
}
return $ret;
}
/**
- Vide la pile de traitement de la ressource courante
- /
public function reset() {
$this->stack = array();
}
}
?>
Conclusion :
- Merci aKheNathOn & neigedhiver pour vos précieux conseils !
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.