Rev 2462 | Rev 2702 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
<?php
// declare(encoding='UTF-8');
/**
* Classe de manipulation des fichiers images JPEG.
*
* @internal Mininum PHP version : 5.2
* @category CEL
* @package Services
* @subpackage Bibliothèques
* @version 0.1
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
Class ImageRecreation {
private $droits = 0755;
private $formats = array('CRX2S','CRXS','CXS','CS','CRS','XS','S','M','L','XL','X2L','X3L');
const MODE_GD = 'gd';
const MODE_IMAGEMAGICK = 'imagemagick';
private $mode;
private $verbose = true;
public function __construct($config) {
$this->config = $config;
if (extension_loaded('imagick')) {
$this->mode = self::MODE_IMAGEMAGICK;
} else {
$this->mode = self::MODE_GD;
}
}
public function recreerMiniaturesRecursivement() {
$this->itererRecursivement($this->config['cel']['chemin_images']);
}
public function regenererMiniaturesIntervalle($params) {
$id_debut = $params[0];
$id_fin = $params[1];
if (is_numeric($id_debut) && is_numeric($id_fin)) {
for ($i = $id_debut; $i <= $id_fin; $i++) {;
$tab_param = array($i);
$this->regenererMiniaturesPourId($tab_param);
}
}
}
public function regenererMiniaturesPourId($params) {
$id = $params[0];
if (!is_numeric($id)) {
return;
}
$dossier_fichier = $this->obtenirDossierPourFormat($id, 'O');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
$chemin_fichier = $dossier_fichier.'/'.$nom_fichier;
if (file_exists($chemin_fichier)) {
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
// creation de miniatures pour chacuns des formats définis
foreach ($this->formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
};
}
}
public function itererRecursivement($dossier) {
// on ne parse que le dossier des images originales
$dossiers_a_exclure = $this->getFormats();
foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
if ($fichier_ou_dossier->isDot()) {
continue;
}
if (in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
continue;
}
if ($fichier_ou_dossier->isDir()) {
$this->itererRecursivement($fichier_ou_dossier->getPathname());
} else {
$nom_fichier = $fichier_ou_dossier->getFilename();
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
// creation de miniatures pour chacuns des formats définis
foreach ($this->formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
}
}
}
}
public function creerOuRenvoyerImage($id, $format) {
$dossier = $this->obtenirDossierPourFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
$chemin_image = $dossier.'/'.$nom_fichier;
$image = false;
if (!file_exists($chemin_image)) {
$chemin_image_originale = $this->obtenirCheminImageOriginale($id);
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_image_originale);
if($infos_image_originale) {
// le verrou est là dans le (rare) cas où l'image est déjà en train
// d'être générée par le script de création des miniatures ou bien
// un autre instance de cette classe appelée par le web service
$fp = fopen($chemin_image_originale, "r");
// si le fichier est verrouillé, flock attendra qu'il se libère
$verrou = flock($fp, LOCK_EX);
if(!file_exists($chemin_image)) {
// si le fichier a été locké alors l'image était en train d'être générée
// et donc il n'est pas nécéssaire de la créer (d'où le 2eme test sur file exists)
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
}
$verrou = flock($fp, LOCK_UN);
fclose($fp);
$image = file_get_contents($chemin_image);
}
} else {
$image = file_get_contents($chemin_image);
}
return $image;
}
public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
$image_redimensionnee = false;
if ($format == 'O') {
// format original : rien à faire
$image_redimensionnee = $infos_image_originale['image'];
} else {
if ($this->estUnFormatRogne($format)) {
if ($this->mode == self::MODE_IMAGEMAGICK) {
// si l'on dispose de la librairie imageMagick
// on applique l'algorithme d'auto détection de sujets
// qui centre la miniature sur le sujet de l'image
$image_redimensionnee = $this->opticrop($infos_image_originale, $format);
}
if ($image_redimensionnee === false) {
// si l'on ne dispose que de gd ou bien que Imagick a échoué
// la minature est une image redimensionnée rognée au centre
$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
}
} else if ($this->estUnFormatCarre($format)) {
// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
} else {
$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
}
}
return $image_redimensionnee;
}
/**
* Déplace une image temporaire uploadée vers le répertoire de stockage d'images,
* en enregistrant les métadonnées et tout le tintouin.
* Si $conserverFichiersTemporaires vaut true, l'image est copiée et non déplacée.
*
* @param unknown $fichier
* @param unknown $id
* @param unknown $conserverFichiersTemporaires
* @return Ambigous <multitype:, boolean>|boolean
*/
public function stockerFichierOriginal($fichier, $id, $conserverFichiersTemporaires=false) {
$chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier;
$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
$deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier, $conserverFichiersTemporaires);
if ($deplacement_fichier) {
$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) {
$this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression);
}
return $infos_image_originale;
} else {
$erreur = 'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
$this->logger('CEL_bugs',$erreur);
return false ;
}
}
public function stockerFichierEtCreerMiniatures($fichier, $id) {
$infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id);
if ($infos_image_originale_stockee) {
$formats = $this->getFormats();
// creation de miniatures pour chacuns des formats définis
foreach($formats as $format) {
$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
}
} else {
$erreur = 'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ;
$this->logger('CEL_bugs',$erreur);
return false ;
}
return true ;
}
public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
$image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format);
$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
return true;
}
public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
imagecopyresampled($image_redimensionnee,
$infos_image_originale['image'],
0, 0,
0, 0,
$largeur_redimension,
$hauteur_redimension,
$infos_image_originale['largeur'],
$infos_image_originale['hauteur']
);
return $image_redimensionnee;
}
public function creerMiniature($informations_images, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
return $image_redimensionnee;
}
public function creerMiniatureCarree($informations_image, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
$cote_carre = $taille_reference_pour_format['largeur'];
$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
if ($this->estPaysage($informations_image)) {
$debut_largeur_a_copier = 0 ;
$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
} else {
$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
$debut_hauteur_a_copier = 0 ;
}
$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
);
return $image_carre_blanc_cible;
}
public function creerMiniatureCarreeRognee($informations_image, $format) {
$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
$cote_carre = $taille_reference_pour_format['largeur'];
$cote_carre_non_redimensionne = 0;
if ($this->estPaysage($informations_image)) {
$cote_carre_non_redimensionne = $informations_image['hauteur'];
$debut_largeur_a_copier = ($informations_image['largeur'] / 2) - ($informations_image['hauteur'] / 2);
$debut_hauteur_a_copier = 0;
if($debut_largeur_a_copier <= 0) {
$debut_largeur_a_copier = 0;
}
$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
} else {
$cote_carre_non_redimensionne = $informations_image['largeur'];
$debut_largeur_a_copier = 0 ;
$debut_hauteur_a_copier = ($informations_image['hauteur'] / 2) - ($informations_image['largeur'] / 2);
if($debut_hauteur_a_copier <= 0) {
$debut_hauteur_a_copier = 0;
}
$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
}
$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
imagecopyresampled($image_carre_temporaire,
$informations_image['image'],
0, 0,
$debut_largeur_a_copier,
$debut_hauteur_a_copier,
$cote_carre_non_redimensionne,
$cote_carre_non_redimensionne,
$nb_pixels_largeur_a_copier,
$nb_pixels_hauteur_a_copier
);
$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
imagecopyresampled($image_redimensionnee,
$image_carre_temporaire,
0, 0,
0, 0,
$cote_carre,
$cote_carre,
$cote_carre_non_redimensionne,
$cote_carre_non_redimensionne
);
return $image_redimensionnee;
}
/**
* Déplace un fichier temporaire vers une destination donnée. Si
* $conserverFichiersTemporaires vaut true, le fichier est copié et non déplacé.
*
* @param unknown $chemin_fichier_temp
* @param unknown $chemin_destination
* @param string $conserverFichiersTemporaires
* @return boolean
*/
public function stockerImageExterne($chemin_fichier_temp, $chemin_destination, $conserverFichiersTemporaires=false) {
if ($conserverFichiersTemporaires === true) {
// copie du fichier
$deplacement = copy($chemin_fichier_temp, $chemin_destination);
} else {
if (is_uploaded_file($chemin_fichier_temp)) {
$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
} else {
$deplacement = rename($chemin_fichier_temp, $chemin_destination);
}
}
return $deplacement;
}
public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format);
if (!file_exists($chemin_sur_serveur_final)) {
umask(0);
if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) {
$erreur = 'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
$this->logger('CEL_bugs', $erreur);
return false;
}
}
return $chemin_sur_serveur_final;
}
public function obtenirDossierPourFormat($id, $format) {
$chemin_base = $this->config['cel']['chemin_images'];
$chemin_sur_serveur = $chemin_base;
$id = sprintf('%09s', $id);
$id = wordwrap($id, 3 , '_', true);
list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
return $chemin_sur_serveur_final;
}
public function obtenirCheminImageOriginale($id_image) {
$nom = $this->convertirIdBddVersNomFichier($id_image, 'O');
$dossier = $this->obtenirDossierPourFormat($id_image,'O');
return $dossier.'/'.$nom;
}
public function obtenirImageEtInfosPourId($id_image) {
$chemin_image_o = $this->obtenirCheminImageOriginale($id_image);
return $this->obtenirImageEtInfosPourChemin($chemin_image_o);
}
public function obtenirImageEtInfosPourChemin($chemin_fichier) {
$image_et_infos = false;
if (file_exists($chemin_fichier)) {
$image_et_infos = array();
list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
$image_et_infos['poids_octets'] = filesize($chemin_fichier);
// @TODO Se protéger contre les images vides, non-JPEG, ou invalides / incomplètes
$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
$image_et_infos['chemin'] = $chemin_fichier;
}
return $image_et_infos;
}
public function obtenirDimensionsPourFormat($format) {
$dimensions = array('largeur' => 0, 'hauteur' => 0);
if (isset($this->config['cel']['format_'.$format])) {
list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', $this->config['cel']['format_'.$format]);
}
return $dimensions;
}
public function calculerTailleImage($informations_images, $taille_max) {
$HL_redimension = array();
if ($this->estPaysage($informations_images)) {
$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
$HL_redimension['largeur'] = round($taille_max) ;
$HL_redimension['hauteur'] = round($taille_max*$rapport) ;
} else {
// protection contre division par 0 - prob. symptôme d'un autre pb : image vide ou mal transmise,
// voir TODO dans obtenirImageEtInfosPourChemin()
$rapport = $informations_images['hauteur'] == 0 ? 0 : $informations_images['largeur'] / $informations_images['hauteur'];
$HL_redimension['hauteur'] = round($taille_max) ;
$HL_redimension['largeur'] = round($taille_max*$rapport) ;
}
return $HL_redimension;
}
public function getFormats() {
return $this->formats;
}
public function estUnFormatCarre($format) {
return (strpos($format,'C') === 0);
}
public function estUnFormatRogne($format) {
return (strpos($format,'R') === 1);
}
public function estPaysage($informations_images) {
return $informations_images['largeur'] > $informations_images['hauteur'];
}
public function estPortait($informations_images) {
return $informations_images['largeur'] < $informations_images['hauteur'];
}
public function renvoyerTauxCompressionPourPoids($poids_octets) {
$poids_max_octets = $this->config['cel']['taille_max'];
$ratio_compression = 100 ;
if ($poids_octets >= $poids_max_octets) {
$ratio_compression = 75 ;
}
return $ratio_compression;
}
public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
// creation du format original
$id_avec_zeros = sprintf('%09s', $id) ;
$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
return $nom_fichier;
}
public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
foreach ($formats as $format) {
$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
}
$id_image = str_replace('_', '', $nom_fichier_sans_extension);
// suppression des 0 devant
$id_image += 0;
return $id_image;
}
public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
umask(0);
$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
}
// attention, ceci ne preserve pas les metadonnées
imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
}
public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
$img = new Imagick($chemin_image_a_stocker);
// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
$img->setformat('jpeg');
$img->setImageCompression(imagick::COMPRESSION_JPEG);
$img->setCompressionQuality($compression);
$img->writeImage($chemin_image_a_stocker);
$img->destroy();
chmod($chemin_image_a_stocker, $this->droits);
}
public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
$image_blanche = imagecreatetruecolor($cote, $cote);
$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
return $image_blanche;
}
public function detruireImageEnMemoire($image) {
imagedestroy($image);
}
/**
* Supprime une image du disque, ainsi que tous les formats générés
*
* @param Integer $id
* @return boolean true si tous les formats y compris l'original ont été détruits, false s'il en reste au moins un
*/
public function detruireImageSurDisque($id) {
$formats = $this->getFormats();
// on detruit aussi l'image originale
$formats[] = 'O';
$destruction_formats_fichier = true;
// destructions de chacun des formats définis
foreach($formats as $format) {
$dossier_format = $this->obtenirDossierPourFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
if (file_exists($dossier_format.'/'.$nom_fichier)) {
$detruit = unlink($dossier_format.'/'.$nom_fichier);
$destruction_formats_fichier = ($destruction_formats_fichier && $detruit);
}
}
return $destruction_formats_fichier;
}
// recopie de Cel->logger() (pas d'extends pour ça)
public function logger($index,$chaine) {
if (!class_exists('Log')) {
Log::getInstance();
}
Log::setCheminLog($this->config['log']['cheminlog']);
Log::setTimeZone($this->config['log']['timezone']);
Log::setTailleMax($this->config['log']['taillemax']);
Log::ajouterEntree($index,$chaine);
}
/*
* edge-maximizing crop
* determines center-of-edginess, then tries different-sized crops around it.
* picks the crop with the highest normalized edginess.
* see documentation on how to tune the algorithm
*
* $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
* $format - le format (ex. : CS, XS, XL, CRS)
*/
public function opticrop($informations_image, $format) {
umask(0);
$erreur_ecriture = false;
$nom_temp = md5(time());
$chemin_temp =
$out = $this->config['cel']['chemin_stockage_temp'].'/'.$nom_temp;
$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
$largeur_vignette = $dimension_vignettes['largeur'];
$hauteur_vignette = $dimension_vignettes['hauteur'];
// source dimensions
$largeur_image_originale = $informations_image['largeur'];
$hauteur_image_originale = $informations_image['hauteur'];
$chemin_image = $informations_image['chemin'];
// parameters for the edge-maximizing crop algorithm
$r = 1; // radius of edge filter
$nk = 9; // scale count: number of crop sizes to try
$gamma = 0.2; // edge normalization parameter -- see documentation
$ar = $largeur_vignette/$hauteur_vignette; // target aspect ratio (AR)
$ar0 = $largeur_image_originale/$hauteur_image_originale; // original aspect ratio (AR)
//echo("$chemin_image: $largeur_image_originale x $hauteur_image_originale => $largeur_vignette x $hauteur_vignette");
$img = new Imagick($chemin_image);
$imgcp = clone $img;
// compute center of edginess
$img->edgeImage($r);
$img->modulateImage(100,0,100); // grayscale
$img->blackThresholdImage("#0f0f0f");
$retour_ecriture_img = $img->writeImage($out);
if ($retour_ecriture_img !== true) {
error_log("Erreur d'écriture Imagick : [" . $chemin_image . "] vers [" . $out . "]");
$erreur_ecriture = true;
}
// use gd for random pixel access
$im = ImageCreateFromJpeg($out);
if ($im === false) {
error_log("GD ne peut pas lire l'image créée par Imagick : [" . $chemin_image . "] vers [" . $out . "]");
$erreur_ecriture = true;
}
if (! $erreur_ecriture) {
$xcenter = 0;
$ycenter = 0;
$sum = 0;
$n = 100000;
for ($k=0; $k<$n; $k++) {
$i = mt_rand(0,$largeur_image_originale-1);
$j = mt_rand(0,$hauteur_image_originale-1);
$val = imagecolorat($im, $i, $j) & 0xFF;
$sum += $val;
$xcenter += ($i+1)*$val;
$ycenter += ($j+1)*$val;
}
$xcenter /= $sum;
$ycenter /= $sum;
// crop source img to target AR
if ($largeur_image_originale/$hauteur_image_originale > $ar) {
// source AR wider than target
// crop width to target AR
$wcrop0 = round($ar*$hauteur_image_originale);
$hcrop0 = $hauteur_image_originale;
} else {
// crop height to target AR
$wcrop0 = $largeur_image_originale;
$hcrop0 = round($largeur_image_originale/$ar);
}
// crop parameters for all scales and translations
$params = array();
// crop at different scales
$hgap = $hcrop0 - $hauteur_vignette;
$hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
$wgap = $wcrop0 - $largeur_vignette;
$winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
// find window with highest normalized edginess
$n = 10000;
$maxbetanorm = 0;
$maxfile = '';
$maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
for ($k = 0; $k < $nk; $k++) {
$hcrop = round($hcrop0 - $k*$hinc);
$wcrop = round($wcrop0 - $k*$winc);
$xcrop = $xcenter - $wcrop / 2;
$ycrop = $ycenter - $hcrop / 2;
//echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
if ($xcrop < 0) $xcrop = 0;
if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
if ($ycrop < 0) $ycrop = 0;
if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
$beta = 0;
for ($c=0; $c<$n; $c++) {
$i = mt_rand(0,$wcrop-1);
$j = mt_rand(0,$hcrop-1);
$beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
}
$area = $wcrop * $hcrop;
$betanorm = $beta / ($n*pow($area, $gamma-1));
// echo("beta: $beta; betan: $betanorm");
// echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
// best image found, save it
if ($betanorm > $maxbetanorm) {
$maxbetanorm = $betanorm;
$maxparam['w'] = $wcrop;
$maxparam['h'] = $hcrop;
$maxparam['x'] = $xcrop;
$maxparam['y'] = $ycrop;
// $maxfile = $currfile;
}
}
// écrasement de l'image par la version "croppée"
$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
$imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
$imgcp->writeImage($out);
// return image
chmod($out, 0777);
$img->destroy();
$imgcp->destroy();
$image_sortie = ImageCreateFromJpeg($out);
} else {
// image n'a pas pu être croppée - on retourne l'originale
//$image_sortie = ImageCreateFromJpeg($chemin_image);
$image_sortie = false;
}
// destruction fichier temporaire dans tous les cas
unlink($out);
return $image_sortie;
}
}