Subversion Repositories eFlore/Applications.cel

Rev

Rev 3786 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
591 aurelien 1 
<?php
2462 jpm 2 
// declare(encoding='UTF-8');
3 
/**
4 
 * Classe de manipulation des fichiers images JPEG.
5 
 *
6 
 * @internal   Mininum PHP version : 5.2
7 
 * @category   CEL
8 
 * @package    Services
9 
 * @subpackage Bibliothèques
10 
 * @version    0.1
11 
 * @author     Mathias CHOUET <mathias@tela-botanica.org>
12 
 * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>
13 
 * @author     Aurelien PERONNET <aurelien@tela-botanica.org>
14 
 * @license    GPL v3 <http://www.gnu.org/licenses/gpl.txt>
15 
 * @license    CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
16 
 * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>
17 
 */
632 aurelien 18 
Class ImageRecreation {
1154 jpm 19 
 
1883 mathias 20 
	private $droits = 0755;
1874 aurelien 21 
	private $formats = array('CRX2S','CRXS','CXS','CS','CRS','XS','S','M','L','XL','X2L','X3L');
632 aurelien 22 
	const MODE_GD = 'gd';
23 
	const MODE_IMAGEMAGICK = 'imagemagick';
24 
	private $mode;
1154 jpm 25 
 
632 aurelien 26 
	private $verbose = true;
591 aurelien 27 
 
672 jpm 28 
	public function __construct($config) {
29 
		$this->config = $config;
1154 jpm 30 
 
632 aurelien 31 
		if (extension_loaded('imagick')) {
32 
			$this->mode = self::MODE_IMAGEMAGICK;
1154 jpm 33 
		} else {
34 
			$this->mode = self::MODE_GD;
632 aurelien 35 
		}
591 aurelien 36 
	}
1154 jpm 37 
 
632 aurelien 38 
	public function recreerMiniaturesRecursivement() {
970 aurelien 39 
		$this->itererRecursivement($this->config['cel']['chemin_images']);
632 aurelien 40 
	}
1154 jpm 41 
 
632 aurelien 42 
	public function regenererMiniaturesIntervalle($params) {
43 
		$id_debut = $params[0];
44 
		$id_fin = $params[1];
45 
 
46 
		if (is_numeric($id_debut) && is_numeric($id_fin)) {
668 aurelien 47 
			for ($i = $id_debut; $i <= $id_fin; $i++) {;
632 aurelien 48 
			    $tab_param = array($i);
49 
			    $this->regenererMiniaturesPourId($tab_param);
50 
			}
51 
		}
591 aurelien 52 
	}
1154 jpm 53 
 
2939 mathias 54 
	/**
55 
	 * params[0] doit contenir un seul identifiant d'image; les miniatures
56 
	 * seront regénérée pour cette image
57 
	 */
632 aurelien 58 
	public function regenererMiniaturesPourId($params) {
59 
		$id = $params[0];
60 
 
61 
		if (!is_numeric($id)) {
2462 jpm 62 
			return;
632 aurelien 63 
		}
64 
 
65 
		$dossier_fichier = $this->obtenirDossierPourFormat($id, 'O');
66 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
1154 jpm 67 
 
632 aurelien 68 
		$chemin_fichier = $dossier_fichier.'/'.$nom_fichier;
69 
 
1154 jpm 70 
		if (file_exists($chemin_fichier)) {
632 aurelien 71 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
1154 jpm 72 
 
632 aurelien 73 
			// creation de miniatures pour chacuns des formats définis
1154 jpm 74 
			foreach ($this->formats as $format) {
632 aurelien 75 
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
668 aurelien 76 
			};
632 aurelien 77 
		}
621 aurelien 78 
	}
1154 jpm 79 
 
605 aurelien 80 
	public function itererRecursivement($dossier) {
591 aurelien 81 
		// on ne parse que le dossier des images originales
82 
		$dossiers_a_exclure = $this->getFormats();
1154 jpm 83 
 
591 aurelien 84 
		foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
632 aurelien 85 
			if ($fichier_ou_dossier->isDot()) {
591 aurelien 86 
				continue;
87 
			}
1154 jpm 88 
 
632 aurelien 89 
			if (in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
591 aurelien 90 
				continue;
91 
			}
1154 jpm 92 
 
2462 jpm 93 
			if ($fichier_ou_dossier->isDir()) {
94 
				$this->itererRecursivement($fichier_ou_dossier->getPathname());
95 
			} else {
96 
				$nom_fichier = $fichier_ou_dossier->getFilename();
1154 jpm 97 
 
591 aurelien 98 
				$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
2462 jpm 99 
				$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
1154 jpm 100 
 
2462 jpm 101 
				// creation de miniatures pour chacuns des formats définis
1154 jpm 102 
				foreach ($this->formats as $format) {
591 aurelien 103 
					$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
104 
				}
2462 jpm 105 
			}
591 aurelien 106 
		}
107 
	}
2462 jpm 108 
 
2083 aurelien 109 
	public function creerOuRenvoyerImage($id, $format) {
110 
		$dossier = $this->obtenirDossierPourFormat($id, $format);
111 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
2462 jpm 112 
		$chemin_image = $dossier.'/'.$nom_fichier;
1154 jpm 113 
 
2083 aurelien 114 
		$image = false;
2462 jpm 115 
		if (!file_exists($chemin_image)) {
2133 aurelien 116 
			$chemin_image_originale = $this->obtenirCheminImageOriginale($id);
117 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_image_originale);
2083 aurelien 118 
			if($infos_image_originale) {
2133 aurelien 119 
				// le verrou est là dans le (rare) cas où l'image est déjà en train
2462 jpm 120 
				// d'être générée par le script de création des miniatures ou bien
2133 aurelien 121 
				// un autre instance de cette classe appelée par le web service
122 
				$fp = fopen($chemin_image_originale, "r");
2462 jpm 123 
				// si le fichier est verrouillé, flock attendra qu'il se libère
2133 aurelien 124 
				$verrou = flock($fp, LOCK_EX);
125 
				if(!file_exists($chemin_image)) {
126 
					// si le fichier a été locké alors l'image était en train d'être générée
127 
					// et donc il n'est pas nécéssaire de la créer (d'où le 2eme test sur file exists)
128 
					$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
129 
				}
130 
				$verrou = flock($fp, LOCK_UN);
131 
				fclose($fp);
2083 aurelien 132 
				$image = file_get_contents($chemin_image);
133 
			}
3910 killian 134 
		 elseif ('O' === $format) {
135 
			$image = new Imagick($chemin_image);
136 
			$profiles = $image->getImageProfiles('icc', true);
137 
			$image->stripImage();
138 
			if (!empty($profile)) {
139 
				$image->profileImage('icc', $profiles['icc']);
140 
			}
141 
			$image = $image->getImageBlob();
2083 aurelien 142 
		} else {
143 
			$image = file_get_contents($chemin_image);
144 
		}
145 
		return $image;
146 
	}
147 
 
668 aurelien 148 
	public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
2238 mathias 149 
		$image_redimensionnee = false;
1154 jpm 150 
		if ($format == 'O') {
591 aurelien 151 
			// format original : rien à faire
152 
			$image_redimensionnee = $infos_image_originale['image'];
153 
		} else {
632 aurelien 154 
			 if ($this->estUnFormatRogne($format)) {
155 
			 	if ($this->mode == self::MODE_IMAGEMAGICK) {
156 
			 		// si l'on dispose de la librairie imageMagick
157 
			 		// on applique l'algorithme d'auto détection de sujets
158 
			 		// qui centre la miniature sur le sujet de l'image
159 
			 		$image_redimensionnee = $this->opticrop($infos_image_originale, $format);
2238 mathias 160 
			 	}
161 
			 	if ($image_redimensionnee === false) {
162 
			 		// si l'on ne dispose que de gd ou bien que Imagick a échoué
632 aurelien 163 
					// la minature est une image redimensionnée rognée au centre
1154 jpm 164 
					$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
165 
			 	}
632 aurelien 166 
			} else if ($this->estUnFormatCarre($format)) {
591 aurelien 167 
				// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
1154 jpm 168 
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
591 aurelien 169 
			} else {
1154 jpm 170 
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
591 aurelien 171 
			}
172 
		}
668 aurelien 173 
		return $image_redimensionnee;
174 
	}
2370 mathias 175 
 
176 
	/**
177 
	 * Déplace une image temporaire uploadée vers le répertoire de stockage d'images,
178 
	 * en enregistrant les métadonnées et tout le tintouin.
179 
	 * Si $conserverFichiersTemporaires vaut true, l'image est copiée et non déplacée.
2462 jpm 180 
	 *
2370 mathias 181 
	 * @param unknown $fichier
182 
	 * @param unknown $id
183 
	 * @param unknown $conserverFichiersTemporaires
184 
	 * @return Ambigous <multitype:, boolean>|boolean
185 
	 */
186 
	public function stockerFichierOriginal($fichier, $id, $conserverFichiersTemporaires=false) {
2083 aurelien 187 
		$chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier;
2462 jpm 188 
 
2704 mathias 189 
		$tailleFichierOrigine = filesize($chemin_fichier_origine);
190 
 
2083 aurelien 191 
		$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
192 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
2462 jpm 193 
 
2083 aurelien 194 
		$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
2462 jpm 195 
 
2370 mathias 196 
		$deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier, $conserverFichiersTemporaires);
2704 mathias 197 
		if ($tailleFichierOrigine == 0) {
198 
			$erreur =  'ERREUR : fichier image original [' . $chemin_fichier . '] de taille nulle (0) \n' ;
199 
			$this->logger('CEL_bugs',$erreur);
200 
			return false;
201 
		}
2462 jpm 202 
 
2083 aurelien 203 
		if ($deplacement_fichier) {
204 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
205 
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
2462 jpm 206 
 
2704 mathias 207 
			$ecritureOK = true;
2083 aurelien 208 
			if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) {
2704 mathias 209 
				$ecritureOK = $this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression);
2083 aurelien 210 
			}
1154 jpm 211 
 
2704 mathias 212 
			if ($ecritureOK) {
213 
				return $infos_image_originale;
214 
			} else {
215 
				$erreur =  'ERREUR : probleme durant la recompression du fichier image original \n' ;
216 
				$this->logger('CEL_bugs',$erreur);
217 
				return false ;
218 
			}
2083 aurelien 219 
		} else {
2704 mathias 220 
			$erreur =  'ERREUR : probleme durant le déplacement du fichier temporaire \n' ;
2083 aurelien 221 
			$this->logger('CEL_bugs',$erreur);
222 
			return false ;
223 
		}
224 
	}
2462 jpm 225 
 
2083 aurelien 226 
	public function stockerFichierEtCreerMiniatures($fichier, $id) {
227 
		$infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id);
2462 jpm 228 
		if ($infos_image_originale_stockee) {
2083 aurelien 229 
			$formats = $this->getFormats();
2462 jpm 230 
 
2083 aurelien 231 
			// creation de miniatures pour chacuns des formats définis
232 
			foreach($formats as $format) {
233 
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
234 
			}
235 
		} else {
236 
			$erreur =  'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ;
237 
			$this->logger('CEL_bugs',$erreur);
238 
			return false ;
239 
		}
240 
		return true ;
241 
	}
242 
 
668 aurelien 243 
	public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
244 
		$image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format);
591 aurelien 245 
		$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
246 
		$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
247 
		return true;
248 
	}
1154 jpm 249 
 
591 aurelien 250 
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
251 
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
1154 jpm 252 
 
253 
		imagecopyresampled($image_redimensionnee,
254 
			$infos_image_originale['image'],
255 
			0, 0,
256 
			0, 0,
257 
			$largeur_redimension,
258 
			$hauteur_redimension,
259 
			$infos_image_originale['largeur'],
672 jpm 260 
			$infos_image_originale['hauteur']
591 aurelien 261 
		);
262 
		return $image_redimensionnee;
263 
	}
1154 jpm 264 
 
591 aurelien 265 
	public function creerMiniature($informations_images, $format) {
266 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
1154 jpm 267 
 
591 aurelien 268 
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
269 
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
1154 jpm 270 
 
591 aurelien 271 
		return $image_redimensionnee;
272 
	}
1154 jpm 273 
 
591 aurelien 274 
	public function creerMiniatureCarree($informations_image, $format) {
275 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
276 
		$cote_carre = $taille_reference_pour_format['largeur'];
1154 jpm 277 
 
591 aurelien 278 
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
279 
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
1154 jpm 280 
 
281 
		if ($this->estPaysage($informations_image)) {
672 jpm 282 
			$debut_largeur_a_copier = 0 ;
1154 jpm 283 
			$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
591 aurelien 284 
		} else {
672 jpm 285 
			$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
1154 jpm 286 
			$debut_hauteur_a_copier = 0 ;
591 aurelien 287 
		}
1154 jpm 288 
 
591 aurelien 289 
		$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
1154 jpm 290 
 
591 aurelien 291 
		imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
672 jpm 292 
			$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
293 
			$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
591 aurelien 294 
		);
295 
 
296 
		return $image_carre_blanc_cible;
297 
	}
1154 jpm 298 
 
591 aurelien 299 
	public function creerMiniatureCarreeRognee($informations_image, $format) {
300 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
301 
		$cote_carre = $taille_reference_pour_format['largeur'];
302 
		$cote_carre_non_redimensionne = 0;
1154 jpm 303 
 
304 
		if ($this->estPaysage($informations_image)) {
305 
			$cote_carre_non_redimensionne = $informations_image['hauteur'];
2238 mathias 306 
			$debut_largeur_a_copier = ($informations_image['largeur'] / 2) - ($informations_image['hauteur'] / 2);
672 jpm 307 
			$debut_hauteur_a_copier = 0;
1154 jpm 308 
 
672 jpm 309 
			if($debut_largeur_a_copier <= 0) {
310 
				$debut_largeur_a_copier = 0;
311 
			}
1154 jpm 312 
 
672 jpm 313 
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
314 
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
315 
		} else {
316 
			$cote_carre_non_redimensionne = $informations_image['largeur'];
317 
			$debut_largeur_a_copier = 0 ;
2238 mathias 318 
			$debut_hauteur_a_copier = ($informations_image['hauteur'] / 2) - ($informations_image['largeur'] / 2);
1154 jpm 319 
 
672 jpm 320 
			if($debut_hauteur_a_copier <= 0) {
591 aurelien 321 
				$debut_hauteur_a_copier = 0;
672 jpm 322 
			}
1154 jpm 323 
 
672 jpm 324 
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
325 
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
591 aurelien 326 
		}
1154 jpm 327 
 
591 aurelien 328 
		$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
1154 jpm 329 
 
330 
		imagecopyresampled($image_carre_temporaire,
331 
			$informations_image['image'],
332 
			0, 0,
672 jpm 333 
			$debut_largeur_a_copier,
1154 jpm 334 
			$debut_hauteur_a_copier,
335 
			$cote_carre_non_redimensionne,
336 
			$cote_carre_non_redimensionne,
337 
			$nb_pixels_largeur_a_copier,
672 jpm 338 
			$nb_pixels_hauteur_a_copier
591 aurelien 339 
		);
1154 jpm 340 
 
591 aurelien 341 
		$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
1154 jpm 342 
 
343 
		imagecopyresampled($image_redimensionnee,
344 
			$image_carre_temporaire,
345 
			0, 0,
346 
			0, 0,
347 
			$cote_carre,
348 
			$cote_carre,
349 
			$cote_carre_non_redimensionne,
672 jpm 350 
			$cote_carre_non_redimensionne
591 aurelien 351 
		);
352 
 
353 
		return $image_redimensionnee;
354 
	}
1154 jpm 355 
 
2370 mathias 356 
	/**
357 
	 * Déplace un fichier temporaire vers une destination donnée. Si
358 
	 * $conserverFichiersTemporaires vaut true, le fichier est copié et non déplacé.
2462 jpm 359 
	 *
2370 mathias 360 
	 * @param unknown $chemin_fichier_temp
361 
	 * @param unknown $chemin_destination
362 
	 * @param string $conserverFichiersTemporaires
363 
	 * @return boolean
364 
	 */
365 
	public function stockerImageExterne($chemin_fichier_temp, $chemin_destination, $conserverFichiersTemporaires=false) {
366 
		if ($conserverFichiersTemporaires === true) {
367 
			// copie du fichier
368 
			$deplacement = copy($chemin_fichier_temp, $chemin_destination);
632 aurelien 369 
		} else {
2370 mathias 370 
			if (is_uploaded_file($chemin_fichier_temp)) {
371 
				$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
372 
			} else {
373 
				$deplacement = rename($chemin_fichier_temp, $chemin_destination);
374 
			}
632 aurelien 375 
		}
1154 jpm 376 
 
632 aurelien 377 
		return $deplacement;
378 
	}
1154 jpm 379 
 
591 aurelien 380 
	public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
672 jpm 381 
		$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format);
1154 jpm 382 
 
672 jpm 383 
		if (!file_exists($chemin_sur_serveur_final)) {
668 aurelien 384 
			umask(0);
672 jpm 385 
			if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) {
591 aurelien 386 
				$erreur =  'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
672 jpm 387 
				$this->logger('CEL_bugs', $erreur);
591 aurelien 388 
				return false;
389 
			}
390 
		}
1154 jpm 391 
 
591 aurelien 392 
		return $chemin_sur_serveur_final;
393 
	}
1154 jpm 394 
 
591 aurelien 395 
	public function obtenirDossierPourFormat($id, $format) {
970 aurelien 396 
		$chemin_base = $this->config['cel']['chemin_images'];
1154 jpm 397 
 
672 jpm 398 
		$chemin_sur_serveur = $chemin_base;
1154 jpm 399 
 
672 jpm 400 
		$id = sprintf('%09s', $id);
401 
		$id = wordwrap($id, 3 , '_', true);
1154 jpm 402 
 
672 jpm 403 
		list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
1154 jpm 404 
 
591 aurelien 405 
		$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
1154 jpm 406 
 
591 aurelien 407 
		return $chemin_sur_serveur_final;
408 
	}
1154 jpm 409 
 
668 aurelien 410 
	public function obtenirCheminImageOriginale($id_image) {
411 
		$nom = $this->convertirIdBddVersNomFichier($id_image, 'O');
412 
		$dossier = $this->obtenirDossierPourFormat($id_image,'O');
1154 jpm 413 
 
668 aurelien 414 
		return $dossier.'/'.$nom;
415 
	}
1154 jpm 416 
 
668 aurelien 417 
	public function obtenirImageEtInfosPourId($id_image) {
418 
		$chemin_image_o = $this->obtenirCheminImageOriginale($id_image);
419 
		return $this->obtenirImageEtInfosPourChemin($chemin_image_o);
420 
	}
1154 jpm 421 
 
591 aurelien 422 
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
668 aurelien 423 
		$image_et_infos = false;
1154 jpm 424 
 
425 
		if (file_exists($chemin_fichier)) {
668 aurelien 426 
			$image_et_infos = array();
3460 killian 427 
			list($image_et_infos['largeur'], $image_et_infos['hauteur'], $image_et_infos['imagetype']) = getimagesize($chemin_fichier);
668 aurelien 428 
			$image_et_infos['poids_octets'] = filesize($chemin_fichier);
429 
			$image_et_infos['chemin'] = $chemin_fichier;
3460 killian 430 
 
431 
			switch (image_type_to_mime_type($image_et_infos['imagetype'])) {
432 
				case 'image/jpeg':
433 
					$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
434 
					break;
435 
				case 'image/png':
436 
					$image_et_infos['image'] = imagecreatefrompng($chemin_fichier);
437 
					break;
438 
				default:
439 
					// ni jpeg ni png donc pas supporté, ça dégage
440 
					return false;
441 
			}
668 aurelien 442 
		}
591 aurelien 443 
		return $image_et_infos;
444 
	}
1154 jpm 445 
 
591 aurelien 446 
	public function obtenirDimensionsPourFormat($format) {
672 jpm 447 
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
1154 jpm 448 
 
970 aurelien 449 
		if (isset($this->config['cel']['format_'.$format])) {
450 
			list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', $this->config['cel']['format_'.$format]);
591 aurelien 451 
		}
1154 jpm 452 
 
591 aurelien 453 
		return $dimensions;
454 
	}
1154 jpm 455 
 
591 aurelien 456 
	public function calculerTailleImage($informations_images, $taille_max) {
2462 jpm 457 
		$HL_redimension = array();
1154 jpm 458 
 
2462 jpm 459 
		if ($this->estPaysage($informations_images)) {
460 
			$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
461 
			$HL_redimension['largeur'] = round($taille_max) ;
462 
			$HL_redimension['hauteur'] = round($taille_max*$rapport) ;
1154 jpm 463 
 
2462 jpm 464 
		} else {
2662 mathias 465 
			// protection contre division par 0 - prob. symptôme d'un autre pb : image vide ou mal transmise,
466 
			// voir TODO dans obtenirImageEtInfosPourChemin()
467 
			$rapport = $informations_images['hauteur'] == 0 ? 0 : $informations_images['largeur'] / $informations_images['hauteur'];
2462 jpm 468 
			$HL_redimension['hauteur'] = round($taille_max) ;
469 
			$HL_redimension['largeur'] = round($taille_max*$rapport) ;
470 
		}
1154 jpm 471 
 
2462 jpm 472 
		return $HL_redimension;
591 aurelien 473 
	}
1154 jpm 474 
 
591 aurelien 475 
	public function getFormats() {
476 
		return $this->formats;
477 
	}
1154 jpm 478 
 
591 aurelien 479 
	public function estUnFormatCarre($format) {
1154 jpm 480 
		return (strpos($format,'C') === 0);
591 aurelien 481 
	}
1154 jpm 482 
 
591 aurelien 483 
	public function estUnFormatRogne($format) {
1154 jpm 484 
		return (strpos($format,'R') === 1);
591 aurelien 485 
	}
1154 jpm 486 
 
591 aurelien 487 
	public function estPaysage($informations_images) {
488 
		return $informations_images['largeur'] > $informations_images['hauteur'];
489 
	}
1154 jpm 490 
 
591 aurelien 491 
	public function estPortait($informations_images) {
492 
		return $informations_images['largeur'] < $informations_images['hauteur'];
493 
	}
1154 jpm 494 
 
591 aurelien 495 
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
970 aurelien 496 
		$poids_max_octets = $this->config['cel']['taille_max'];
1154 jpm 497 
 
591 aurelien 498 
		$ratio_compression = 100 ;
1154 jpm 499 
 
2462 jpm 500 
		if ($poids_octets >= $poids_max_octets) {
501 
			$ratio_compression = 75 ;
502 
		}
1154 jpm 503 
 
2462 jpm 504 
		return $ratio_compression;
591 aurelien 505 
	}
1154 jpm 506 
 
591 aurelien 507 
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
672 jpm 508 
		// creation du format original
3459 killian 509 
		$id_avec_zeros = sprintf('%09s', $id);
510 
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true);
1154 jpm 511 
 
3459 killian 512 
		// déterminationnage de l'extension
513 
		$path = $this->obtenirDossierPourFormat($id, $format);
3786 killian 514 
		foreach(['jpg', 'JPG', 'jpeg', 'JPEG', 'png', 'PNG'] as $ext) {
3459 killian 515 
			if (file_exists($path.'/'.$id_avec_zeros_underscores.'_'.$format.'.'.$ext)) {
516 
				$extension = $ext;
517 
				break;
518 
			}
519 
		}
520 
 
591 aurelien 521 
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
1154 jpm 522 
 
591 aurelien 523 
		return $nom_fichier;
524 
	}
1154 jpm 525 
 
591 aurelien 526 
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
527 
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
1154 jpm 528 
 
2462 jpm 529 
		foreach ($formats as $format) {
591 aurelien 530 
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
531 
		}
532 
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
1154 jpm 533 
 
591 aurelien 534 
		// suppression des 0 devant
535 
		$id_image += 0;
1154 jpm 536 
 
591 aurelien 537 
		return $id_image;
538 
	}
1154 jpm 539 
 
632 aurelien 540 
	public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
591 aurelien 541 
		umask(0);
1154 jpm 542 
 
591 aurelien 543 
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
544 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
1154 jpm 545 
 
632 aurelien 546 
		if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
591 aurelien 547 
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
548 
		}
1154 jpm 549 
 
668 aurelien 550 
		// attention, ceci ne preserve pas les metadonnées
632 aurelien 551 
		imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
591 aurelien 552 
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
553 
	}
1154 jpm 554 
 
555 
	public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
2704 mathias 556 
		try {
557 
			$img = new Imagick($chemin_image_a_stocker);
1154 jpm 558 
 
2704 mathias 559 
			// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
560 
			$img->setformat('jpeg');
561 
			$img->setImageCompression(imagick::COMPRESSION_JPEG);
562 
			$img->setCompressionQuality($compression);
563 
			$img->writeImage($chemin_image_a_stocker);
564 
			$img->destroy();
565 
 
566 
			chmod($chemin_image_a_stocker, $this->droits);
567 
			return true;
568 
		} catch (ImagickException $e) {
569 
			return false;
570 
		}
591 aurelien 571 
	}
1154 jpm 572 
 
591 aurelien 573 
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
1154 jpm 574 
		$image_blanche = imagecreatetruecolor($cote, $cote);
591 aurelien 575 
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
576 
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
577 
		return $image_blanche;
578 
	}
1154 jpm 579 
 
580 
	public function detruireImageEnMemoire($image) {
591 aurelien 581 
		imagedestroy($image);
582 
	}
1154 jpm 583 
 
2370 mathias 584 
	/**
585 
	 * Supprime une image du disque, ainsi que tous les formats générés
2462 jpm 586 
	 *
2370 mathias 587 
	 * @param Integer $id
588 
	 * @return boolean true si tous les formats y compris l'original ont été détruits, false s'il en reste au moins un
589 
	 */
591 aurelien 590 
	public function detruireImageSurDisque($id) {
591 
		$formats = $this->getFormats();
592 
		// on detruit aussi l'image originale
593 
		$formats[] = 'O';
1154 jpm 594 
 
2370 mathias 595 
		$destruction_formats_fichier = true;
596 
		// destructions de chacun des formats définis
591 aurelien 597 
		foreach($formats as $format) {
598 
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
599 
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
1154 jpm 600 
 
632 aurelien 601 
			if (file_exists($dossier_format.'/'.$nom_fichier)) {
2370 mathias 602 
				$detruit = unlink($dossier_format.'/'.$nom_fichier);
603 
				$destruction_formats_fichier = ($destruction_formats_fichier && $detruit);
621 aurelien 604 
			}
591 aurelien 605 
		}
1154 jpm 606 
 
621 aurelien 607 
		return $destruction_formats_fichier;
591 aurelien 608 
	}
1154 jpm 609 
 
1755 raphael 610 
	// recopie de Cel->logger() (pas d'extends pour ça)
611 
	public function logger($index,$chaine) {
2462 jpm 612 
		if (!class_exists('Log')) {
1755 raphael 613 
			Log::getInstance();
614 
		}
615 
 
616 
		Log::setCheminLog($this->config['log']['cheminlog']);
617 
		Log::setTimeZone($this->config['log']['timezone']);
618 
		Log::setTailleMax($this->config['log']['taillemax']);
619 
 
620 
		Log::ajouterEntree($index,$chaine);
621 
	}
622 
 
1154 jpm 623 
	/*
632 aurelien 624 
	 * edge-maximizing crop
1154 jpm 625 
	 * determines center-of-edginess, then tries different-sized crops around it.
632 aurelien 626 
	 * picks the crop with the highest normalized edginess.
627 
	 * see documentation on how to tune the algorithm
628 
	 *
629 
	 * $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
630 
	 * $format - le format (ex. : CS, XS, XL, CRS)
631 
	*/
672 jpm 632 
	public function opticrop($informations_image, $format) {
632 aurelien 633 
		umask(0);
2238 mathias 634 
		$erreur_ecriture = false;
1154 jpm 635 
 
632 aurelien 636 
		$nom_temp = md5(time());
1154 jpm 637 
		$chemin_temp =
638 
 
970 aurelien 639 
		$out = $this->config['cel']['chemin_stockage_temp'].'/'.$nom_temp;
1154 jpm 640 
 
632 aurelien 641 
		$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
1154 jpm 642 
 
632 aurelien 643 
		$largeur_vignette = $dimension_vignettes['largeur'];
644 
		$hauteur_vignette = $dimension_vignettes['hauteur'];
1154 jpm 645 
 
2462 jpm 646 
		// source dimensions
647 
		$largeur_image_originale = $informations_image['largeur'];
648 
		$hauteur_image_originale = $informations_image['hauteur'];
1154 jpm 649 
 
2462 jpm 650 
		$chemin_image = $informations_image['chemin'];
1154 jpm 651 
 
2462 jpm 652 
		// parameters for the edge-maximizing crop algorithm
653 
		$r = 1;         // radius of edge filter
654 
		$nk = 9;        // scale count: number of crop sizes to try
655 
		$gamma = 0.2;   // edge normalization parameter -- see documentation
656 
		$ar = $largeur_vignette/$hauteur_vignette;    // target aspect ratio (AR)
657 
		$ar0 = $largeur_image_originale/$hauteur_image_originale;    // original aspect ratio (AR)
1154 jpm 658 
 
2462 jpm 659 
		//echo("$chemin_image: $largeur_image_originale x $hauteur_image_originale => $largeur_vignette x $hauteur_vignette");
2698 mathias 660 
		try {
661 
			$img = new Imagick($chemin_image); // ce machin jette une ImagickException si le fichier est vide
2702 mathias 662 
			$imgcp = clone $img;
2698 mathias 663 
			// compute center of edginess
664 
			$img->edgeImage($r);
665 
			$img->modulateImage(100,0,100); // grayscale
666 
			$img->blackThresholdImage("#0f0f0f");
667 
			$retour_ecriture_img = $img->writeImage($out);
3056 mathias 668 
 
2698 mathias 669 
			if ($retour_ecriture_img !== true) {
670 
				error_log("Erreur d'écriture Imagick : [" . $chemin_image . "] vers [" . $out . "]");
671 
				$erreur_ecriture = true;
672 
			}
673 
			// use gd for random pixel access
674 
			$im = ImageCreateFromJpeg($out);
675 
 
676 
			if ($im === false) {
677 
				error_log("GD ne peut pas lire l'image créée par Imagick : [" . $chemin_image . "] vers [" . $out . "]");
678 
				$erreur_ecriture = true;
679 
			}
680 
		} catch (ImagickException $e) {
681 
			// En principe si on se trouve ici c'est que l'image est vide
2462 jpm 682 
			$erreur_ecriture = true;
2698 mathias 683 
			$image_sortie = false;
2462 jpm 684 
		}
2238 mathias 685 
 
2462 jpm 686 
		if (! $erreur_ecriture) {
687 
			$xcenter = 0;
688 
			$ycenter = 0;
689 
			$sum = 0;
690 
			$n = 100000;
691 
			for ($k=0; $k<$n; $k++) {
692 
				$i = mt_rand(0,$largeur_image_originale-1);
693 
				$j = mt_rand(0,$hauteur_image_originale-1);
694 
				$val = imagecolorat($im, $i, $j) & 0xFF;
695 
				$sum += $val;
696 
				$xcenter += ($i+1)*$val;
697 
				$ycenter += ($j+1)*$val;
698 
			}
699 
			$xcenter /= $sum;
700 
			$ycenter /= $sum;
1154 jpm 701 
 
2462 jpm 702 
			// crop source img to target AR
703 
			if ($largeur_image_originale/$hauteur_image_originale > $ar) {
704 
				// source AR wider than target
705 
				// crop width to target AR
706 
				$wcrop0 = round($ar*$hauteur_image_originale);
707 
				$hcrop0 = $hauteur_image_originale;
708 
			} else {
3056 mathias 709 
				// source AR wider than target
2462 jpm 710 
				// crop height to target AR
711 
				$wcrop0 = $largeur_image_originale;
712 
				$hcrop0 = round($largeur_image_originale/$ar);
713 
			}
1154 jpm 714 
 
2462 jpm 715 
			// crop parameters for all scales and translations
716 
			$params = array();
1154 jpm 717 
 
2462 jpm 718 
			// crop at different scales
719 
			$hgap = $hcrop0 - $hauteur_vignette;
720 
			$hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
721 
			$wgap = $wcrop0 - $largeur_vignette;
722 
			$winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
723 
 
724 
			// find window with highest normalized edginess
725 
			$n = 10000;
726 
			$maxbetanorm = 0;
727 
			$maxfile = '';
728 
			$maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
729 
 
730 
			for ($k = 0; $k < $nk; $k++) {
731 
				$hcrop = round($hcrop0 - $k*$hinc);
732 
				$wcrop = round($wcrop0 - $k*$winc);
733 
				$xcrop = $xcenter - $wcrop / 2;
734 
				$ycrop = $ycenter - $hcrop / 2;
735 
				//echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
736 
 
737 
				if ($xcrop < 0) $xcrop = 0;
738 
				if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
739 
				if ($ycrop < 0) $ycrop = 0;
740 
				if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
741 
 
742 
				$beta = 0;
743 
				for ($c=0; $c<$n; $c++) {
744 
					$i = mt_rand(0,$wcrop-1);
745 
					$j = mt_rand(0,$hcrop-1);
746 
					$beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
747 
				}
748 
				$area = $wcrop * $hcrop;
749 
				$betanorm = $beta / ($n*pow($area, $gamma-1));
750 
				// echo("beta: $beta; betan: $betanorm");
751 
				// echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
752 
				// best image found, save it
753 
 
754 
				if ($betanorm > $maxbetanorm) {
755 
 
756 
					$maxbetanorm = $betanorm;
757 
					$maxparam['w'] = $wcrop;
758 
					$maxparam['h'] = $hcrop;
759 
					$maxparam['x'] = $xcrop;
760 
					$maxparam['y'] = $ycrop;
761 
					// $maxfile = $currfile;
762 
				}
763 
			}
764 
 
765 
			// écrasement de l'image par la version "croppée"
766 
			$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
3056 mathias 767 
			// retailler correctement si au moins une des dimensions de l'image produite est
768 
			// inférieure aux dimensions demandées
769 
			$geo = $imgcp->getImageGeometry();
770 
			$ratio_la = $geo['width'] / $largeur_vignette;
771 
			$ratio_ha = $geo['height'] / $hauteur_vignette;
772 
			if ($ratio_la < 1 || $ratio_ha < 1) {
773 
				// cas kipu - on agrandit au max la dimension ayant le ratio le plus faible
774 
				// (= le plus d'écart avec la taille attendue)
775 
				if ($ratio_la < $ratio_ha) {
776 
					$imgcp->scaleImage($largeur_vignette, 0);
777 
				} else {
778 
					$imgcp->scaleImage(0, $hauteur_vignette);
779 
				}
780 
				// puis on recoupe en centrant à l'arrache - bizarre que le script ne fasse pas ça de base :-/
781 
				$geo = $imgcp->getImageGeometry();
782 
				$imgcp->cropImage($largeur_vignette, $hauteur_vignette, max(0, floor($geo['width'] / 2 - $largeur_vignette / 2)), max(0, floor($geo['height'] / 2 - $hauteur_vignette / 2)));
783 
			} else {
784 
				// cas général
785 
				$imgcp->scaleImage($largeur_vignette, $hauteur_vignette, false);
786 
			}
2462 jpm 787 
			$imgcp->writeImage($out);
788 
 
789 
			// return image
790 
			chmod($out, 0777);
791 
			$img->destroy();
792 
			$imgcp->destroy();
793 
			$image_sortie = ImageCreateFromJpeg($out);
794 
		} else {
795 
			// image n'a pas pu être croppée - on retourne l'originale
796 
			//$image_sortie = ImageCreateFromJpeg($chemin_image);
797 
			$image_sortie = false;
798 
		}
799 
 
800 
		// destruction fichier temporaire dans tous les cas
801 
		unlink($out);
802 
 
803 
		return $image_sortie;
632 aurelien 804 
	}
3056 mathias 805 
}