Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2119 aurelien 1 
<?php
2414 jpm 2 
// declare(encoding='UTF-8');
3 
/**
4 
 * Cette classe est un quasi copier-coller de la classe éponyme dans
5 
 * le dossier lib de jrest mais pas de mécanisme commun pour les classes
6 
 *
7 
 * @category   CEL
8 
 * @package    Scripts
9 
 * @subpackage Génération Images
10 
 * @author     Mathias CHOUET <mathias@tela-botanica.org>
11 
 * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>
12 
 * @author     Aurelien PERONNET <aurelien@tela-botanica.org>
13 
 * @license    GPL v3 <http://www.gnu.org/licenses/gpl.txt>
14 
 * @license    CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
15 
 * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>
16 
 */
17 
// TODO: utiliser la même classe pour jrest ainsi que les scripts => créer un projet cel-commun (même principe que del-commun)
2119 aurelien 18 
Class ImageRecreation {
19 
 
20 
	private $droits = 0755;
21 
	private $formats = array('CRX2S','CRXS','CXS','CS','CRS','XS','S','M','L','XL','X2L','X3L');
22 
	const MODE_GD = 'gd';
23 
	const MODE_IMAGEMAGICK = 'imagemagick';
24 
	private $mode;
25 
 
26 
	private $verbose = true;
27 
 
28 
	public function __construct() {
29 
		if (extension_loaded('imagick')) {
30 
			$this->mode = self::MODE_IMAGEMAGICK;
31 
		} else {
32 
			$this->mode = self::MODE_GD;
33 
		}
34 
	}
35 
 
36 
	public function recreerMiniaturesRecursivement() {
37 
		$this->itererRecursivement(Config::get('dossierImages'));
38 
	}
39 
 
40 
	public function regenererMiniaturesIntervalle($params) {
41 
		$id_debut = $params[0];
42 
		$id_fin = $params[1];
43 
 
44 
		if (is_numeric($id_debut) && is_numeric($id_fin)) {
45 
			for ($i = $id_debut; $i <= $id_fin; $i++) {;
2414 jpm 46 
				$tab_param = array($i);
47 
				$this->regenererMiniaturesPourId($tab_param);
2119 aurelien 48 
			}
49 
		}
50 
	}
51 
 
52 
	public function regenererMiniaturesPourId($params) {
53 
		$id = $params[0];
54 
 
55 
		if (!is_numeric($id)) {
56 
		      return;
57 
		}
58 
 
59 
		$dossier_fichier = $this->obtenirDossierPourFormat($id, 'O');
60 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
61 
 
62 
		$chemin_fichier = $dossier_fichier.'/'.$nom_fichier;
63 
 
64 
		if (file_exists($chemin_fichier)) {
65 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
2134 aurelien 66 
			// obtention d'un verrou sur le fichier original pour empecher d'autres scripts
67 
			// d'effectuer la création des miniatures
68 
			$fp = fopen($chemin_fichier, "r");
69 
			$verrou = flock($fp, LOCK_EX);
2119 aurelien 70 
			// creation de miniatures pour chacuns des formats définis
71 
			foreach ($this->formats as $format) {
72 
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
73 
			};
2134 aurelien 74 
			$verrou = flock($fp, LOCK_UN);
75 
			fclose($fp);
2119 aurelien 76 
		}
77 
	}
78 
 
79 
	public function itererRecursivement($dossier) {
80 
		// on ne parse que le dossier des images originales
81 
		$dossiers_a_exclure = $this->getFormats();
82 
 
83 
		foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
84 
			if ($fichier_ou_dossier->isDot()) {
85 
				continue;
86 
			}
87 
 
88 
			if (in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
89 
				continue;
90 
			}
91 
 
2414 jpm 92 
			if ($fichier_ou_dossier->isDir()) {
93 
				$this->itererRecursivement($fichier_ou_dossier->getPathname());
94 
			} else {
95 
				$nom_fichier = $fichier_ou_dossier->getFilename();
2119 aurelien 96 
 
97 
				$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
2414 jpm 98 
				$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
2119 aurelien 99 
 
2414 jpm 100 
				// creation de miniatures pour chacuns des formats définis
2119 aurelien 101 
				foreach ($this->formats as $format) {
102 
					$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
103 
				}
2414 jpm 104 
			}
2119 aurelien 105 
		}
106 
	}
2414 jpm 107 
 
2119 aurelien 108 
	public function creerOuRenvoyerImage($id, $format) {
109 
		$dossier = $this->obtenirDossierPourFormat($id, $format);
110 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
2414 jpm 111 
		$chemin_image = $dossier.'/'.$nom_fichier;
2119 aurelien 112 
 
113 
		$image = false;
114 
		if(!file_exists($chemin_image)) {
115 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($this->obtenirCheminImageOriginale($id));
116 
			if($infos_image_originale) {
117 
				$debut = microtime();
118 
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
2414 jpm 119 
 
2119 aurelien 120 
				$image = file_get_contents($chemin_image);
121 
			}
122 
		} else {
123 
			$image = file_get_contents($chemin_image);
124 
		}
2414 jpm 125 
 
2119 aurelien 126 
		return $image;
127 
	}
128 
 
129 
	public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
130 
		if ($format == 'O') {
131 
			// format original : rien à faire
132 
			$image_redimensionnee = $infos_image_originale['image'];
133 
 
134 
		} else {
135 
			 if ($this->estUnFormatRogne($format)) {
136 
			 	if ($this->mode == self::MODE_IMAGEMAGICK) {
137 
			 		// si l'on dispose de la librairie imageMagick
138 
			 		// on applique l'algorithme d'auto détection de sujets
139 
			 		// qui centre la miniature sur le sujet de l'image
140 
			 		$image_redimensionnee = $this->opticrop($infos_image_originale, $format);
141 
			 	} else {
142 
			 		// si l'on ne dispose que de gd
143 
					// la minature est une image redimensionnée rognée au centre
144 
					$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
145 
			 	}
146 
			} else if ($this->estUnFormatCarre($format)) {
147 
				// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
148 
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
149 
			} else {
150 
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
151 
			}
152 
		}
153 
 
154 
		return $image_redimensionnee;
155 
	}
2414 jpm 156 
 
2119 aurelien 157 
	public function stockerFichierOriginal($fichier, $id) {
158 
		$chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier;
2414 jpm 159 
 
2119 aurelien 160 
		$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
161 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
2414 jpm 162 
 
2119 aurelien 163 
		$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
2414 jpm 164 
 
2119 aurelien 165 
		$deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier);
2414 jpm 166 
 
2119 aurelien 167 
		if ($deplacement_fichier) {
168 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
169 
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
2414 jpm 170 
 
2119 aurelien 171 
			if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) {
172 
				$this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression);
173 
			}
174 
 
175 
			return $infos_image_originale;
2414 jpm 176 
 
2119 aurelien 177 
		} else {
178 
			$erreur =  'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
179 
			$this->logger('CEL_bugs',$erreur);
180 
			return false ;
181 
		}
182 
	}
2414 jpm 183 
 
2119 aurelien 184 
	public function stockerFichierEtCreerMiniatures($fichier, $id) {
2414 jpm 185 
 
2119 aurelien 186 
		$infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id);
187 
		if($infos_image_originale_stockee) {
188 
			$formats = $this->getFormats();
2414 jpm 189 
 
2119 aurelien 190 
			// creation de miniatures pour chacuns des formats définis
191 
			foreach($formats as $format) {
192 
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
193 
			}
194 
		} else {
195 
			$erreur =  'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ;
196 
			$this->logger('CEL_bugs',$erreur);
197 
			return false ;
198 
		}
2414 jpm 199 
 
2119 aurelien 200 
		return true ;
201 
	}
202 
 
203 
	public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
204 
		$image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format);
205 
 
206 
		$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
207 
		$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
208 
 
209 
		return true;
210 
	}
211 
 
212 
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
213 
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
214 
 
215 
		imagecopyresampled($image_redimensionnee,
216 
			$infos_image_originale['image'],
217 
			0, 0,
218 
			0, 0,
219 
			$largeur_redimension,
220 
			$hauteur_redimension,
221 
			$infos_image_originale['largeur'],
222 
			$infos_image_originale['hauteur']
223 
		);
224 
 
225 
		return $image_redimensionnee;
226 
	}
227 
 
228 
	public function creerMiniature($informations_images, $format) {
229 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
230 
 
231 
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
232 
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
233 
 
234 
		return $image_redimensionnee;
235 
	}
236 
 
237 
	public function creerMiniatureCarree($informations_image, $format) {
238 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
239 
		$cote_carre = $taille_reference_pour_format['largeur'];
240 
 
241 
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
242 
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
243 
 
244 
		if ($this->estPaysage($informations_image)) {
245 
			$debut_largeur_a_copier = 0 ;
246 
			$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
247 
		} else {
248 
			$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
249 
			$debut_hauteur_a_copier = 0 ;
250 
		}
251 
 
252 
		$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
253 
 
254 
		imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
255 
			$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
256 
			$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
257 
		);
258 
 
259 
		return $image_carre_blanc_cible;
260 
	}
261 
 
262 
	public function creerMiniatureCarreeRognee($informations_image, $format) {
263 
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
264 
		$cote_carre = $taille_reference_pour_format['largeur'];
265 
		$cote_carre_non_redimensionne = 0;
266 
 
267 
		if ($this->estPaysage($informations_image)) {
268 
			$cote_carre_non_redimensionne = $informations_image['hauteur'];
269 
			$debut_largeur_a_copier = ($informations_image['hauteur'] - $cote_carre)/2 ;
270 
			$debut_hauteur_a_copier = 0;
271 
 
272 
			if($debut_largeur_a_copier <= 0) {
273 
				$debut_largeur_a_copier = 0;
274 
			}
275 
 
276 
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
277 
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
278 
		} else {
279 
			$cote_carre_non_redimensionne = $informations_image['largeur'];
280 
			$debut_largeur_a_copier = 0 ;
281 
			$debut_hauteur_a_copier = ($informations_image['largeur'] - $cote_carre)/2;
282 
 
2414 jpm 283 
			if ($debut_hauteur_a_copier <= 0) {
2119 aurelien 284 
				$debut_hauteur_a_copier = 0;
285 
			}
286 
 
287 
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
288 
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
289 
		}
290 
 
291 
		$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
292 
 
293 
		imagecopyresampled($image_carre_temporaire,
294 
			$informations_image['image'],
295 
			0, 0,
296 
			$debut_largeur_a_copier,
297 
			$debut_hauteur_a_copier,
298 
			$cote_carre_non_redimensionne,
299 
			$cote_carre_non_redimensionne,
300 
			$nb_pixels_largeur_a_copier,
301 
			$nb_pixels_hauteur_a_copier
302 
		);
303 
 
304 
		$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
305 
 
306 
		imagecopyresampled($image_redimensionnee,
307 
			$image_carre_temporaire,
308 
			0, 0,
309 
			0, 0,
310 
			$cote_carre,
311 
			$cote_carre,
312 
			$cote_carre_non_redimensionne,
313 
			$cote_carre_non_redimensionne
314 
		);
315 
 
316 
		return $image_redimensionnee;
317 
	}
318 
 
319 
	public function stockerImageExterne($chemin_fichier_temp, $chemin_destination) {
320 
		if (is_uploaded_file($chemin_fichier_temp)) {
321 
			$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
322 
		} else {
323 
			$deplacement = rename($chemin_fichier_temp, $chemin_destination);
324 
		}
325 
 
326 
		return $deplacement;
327 
	}
328 
 
329 
	public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
330 
		$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format);
331 
 
332 
		if (!file_exists($chemin_sur_serveur_final)) {
333 
			umask(0);
334 
			if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) {
335 
				$erreur =  'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
336 
				$this->logger('CEL_bugs', $erreur);
337 
				return false;
338 
			}
339 
		}
340 
 
341 
		return $chemin_sur_serveur_final;
342 
	}
343 
 
344 
	public function obtenirDossierPourFormat($id, $format) {
345 
		$chemin_base = Config::get('dossierImages');
346 
 
347 
		$chemin_sur_serveur = $chemin_base;
348 
 
349 
		$id = sprintf('%09s', $id);
350 
		$id = wordwrap($id, 3 , '_', true);
351 
 
352 
		list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
353 
 
354 
		$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
355 
 
356 
		return $chemin_sur_serveur_final;
357 
	}
358 
 
359 
	public function obtenirCheminImageOriginale($id_image) {
360 
		$nom = $this->convertirIdBddVersNomFichier($id_image, 'O');
361 
		$dossier = $this->obtenirDossierPourFormat($id_image,'O');
362 
 
363 
		return $dossier.'/'.$nom;
364 
	}
365 
 
366 
	public function obtenirImageEtInfosPourId($id_image) {
367 
		$chemin_image_o = $this->obtenirCheminImageOriginale($id_image);
368 
		return $this->obtenirImageEtInfosPourChemin($chemin_image_o);
369 
	}
370 
 
371 
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
372 
		$image_et_infos = false;
373 
 
374 
		if (file_exists($chemin_fichier)) {
375 
			$image_et_infos = array();
3459 killian 376 
			list($image_et_infos['largeur'], $image_et_infos['hauteur'], $image_et_infos['imagetype']) = getimagesize($chemin_fichier);
2119 aurelien 377 
			$image_et_infos['poids_octets'] = filesize($chemin_fichier);
378 
			$image_et_infos['chemin'] = $chemin_fichier;
3459 killian 379 
 
380 
			switch (image_type_to_mime_type($image_et_infos['imagetype'])) {
381 
				case 'image/jpeg':
382 
					$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
383 
					break;
384 
				case 'image/png':
385 
					$image_et_infos['image'] = imagecreatefrompng($chemin_fichier);
386 
					break;
387 
				default:
388 
					// ni jpeg ni png donc pas supporté, ça dégage
389 
					return false;
390 
			}
2119 aurelien 391 
		}
392 
 
393 
		return $image_et_infos;
394 
	}
395 
 
396 
	public function obtenirDimensionsPourFormat($format) {
397 
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
398 
 
399 
		if (Config::get('format_'.$format) != null) {
400 
			list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', Config::get('format_'.$format));
401 
		}
402 
 
403 
		return $dimensions;
404 
	}
405 
 
406 
	public function calculerTailleImage($informations_images, $taille_max) {
2414 jpm 407 
		$HL_redimension = array();
2119 aurelien 408 
 
2414 jpm 409 
		if ($this->estPaysage($informations_images)) {
410 
			$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
411 
			$HL_redimension['largeur'] = round($taille_max) ;
412 
			$HL_redimension['hauteur'] = round($taille_max*$rapport) ;
413 
		} else {
414 
			$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
415 
			$HL_redimension['hauteur'] = round($taille_max) ;
416 
			$HL_redimension['largeur'] = round($taille_max*$rapport) ;
417 
		}
2119 aurelien 418 
 
2414 jpm 419 
		return $HL_redimension;
2119 aurelien 420 
	}
421 
 
422 
	public function getFormats() {
423 
		return $this->formats;
424 
	}
425 
 
426 
	public function estUnFormatCarre($format) {
427 
		return (strpos($format,'C') === 0);
428 
	}
429 
 
430 
	public function estUnFormatRogne($format) {
431 
		return (strpos($format,'R') === 1);
432 
	}
433 
 
434 
	public function estPaysage($informations_images) {
435 
		return $informations_images['largeur'] > $informations_images['hauteur'];
436 
	}
437 
 
438 
	public function estPortait($informations_images) {
439 
		return $informations_images['largeur'] < $informations_images['hauteur'];
440 
	}
441 
 
442 
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
443 
		$poids_max_octets = Config::get('tailleMaxImages');
444 
 
445 
		$ratio_compression = 100 ;
446 
 
2414 jpm 447 
		if ($poids_octets >= $poids_max_octets) {
448 
			$ratio_compression = 75 ;
449 
		}
2119 aurelien 450 
 
2414 jpm 451 
		return $ratio_compression;
2119 aurelien 452 
	}
453 
 
454 
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
455 
		// creation du format original
456 
		$id_avec_zeros = sprintf('%09s', $id) ;
457 
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
458 
 
459 
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
460 
 
461 
		return $nom_fichier;
462 
	}
463 
 
464 
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
465 
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
466 
 
467 
		foreach($formats as $format) {
468 
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
469 
		}
470 
 
471 
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
472 
 
473 
		// suppression des 0 devant
474 
		$id_image += 0;
475 
 
476 
		return $id_image;
477 
	}
478 
 
479 
	public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
480 
		umask(0);
481 
 
482 
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
483 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
484 
 
485 
		if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
486 
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
487 
		}
488 
 
489 
		// attention, ceci ne preserve pas les metadonnées
490 
		imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
491 
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
492 
	}
493 
 
494 
	public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
495 
		$img = new Imagick($chemin_image_a_stocker);
496 
 
497 
		// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
498 
		$img->setformat("jpeg");
499 
		$img->setImageCompression(imagick::COMPRESSION_JPEG);
500 
		$img->setCompressionQuality($compression);
501 
		$img->writeImage($chemin_image_a_stocker);
502 
		$img->destroy();
503 
 
504 
		chmod($chemin_image_a_stocker, $this->droits);
505 
	}
506 
 
507 
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
508 
		$image_blanche = imagecreatetruecolor($cote, $cote);
509 
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
510 
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
511 
 
512 
		return $image_blanche;
513 
	}
514 
 
515 
	public function detruireImageEnMemoire($image) {
516 
		imagedestroy($image);
517 
	}
518 
 
519 
	public function detruireImageSurDisque($id) {
520 
		$formats = $this->getFormats();
521 
 
522 
		// on detruit aussi l'image originale
523 
		$formats[] = 'O';
524 
 
525 
		$destruction_formats_fichier = false;
526 
 
527 
		// destructions de chacuns des formats définis
528 
		foreach($formats as $format) {
529 
 
530 
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
531 
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
532 
 
533 
			if (file_exists($dossier_format.'/'.$nom_fichier)) {
534 
				$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
535 
			} else {
536 
				$destruction_formats_fichier = true;
537 
			}
538 
		}
539 
 
540 
		return $destruction_formats_fichier;
541 
	}
542 
 
543 
	/*
544 
	 * edge-maximizing crop
545 
	 * determines center-of-edginess, then tries different-sized crops around it.
546 
	 * picks the crop with the highest normalized edginess.
547 
	 * see documentation on how to tune the algorithm
548 
	 *
549 
	 * $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
550 
	 * $format - le format (ex. : CS, XS, XL, CRS)
551 
	*/
552 
	public function opticrop($informations_image, $format) {
553 
		umask(0);
554 
 
555 
		$nom_temp = md5(time());
556 
		$chemin_temp =
557 
 
558 
		$out = Config::get('dossierImagesStockageTemp').'/'.$nom_temp;
559 
 
560 
		$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
561 
 
562 
		$largeur_vignette = $dimension_vignettes['largeur'];
563 
		$hauteur_vignette = $dimension_vignettes['hauteur'];
564 
 
2414 jpm 565 
		// source dimensions
566 
		$largeur_image_originale = $informations_image['largeur'];
567 
		$hauteur_image_originale = $informations_image['hauteur'];
2119 aurelien 568 
 
2414 jpm 569 
		$chemin_image = $informations_image['chemin'];
2119 aurelien 570 
 
2414 jpm 571 
		//if ($largeur_vignette > $largeur_image_originale || $hauteur_vignette > $hauteur_image_originale)
572 
		//    die("Target dimensions must be smaller or equal to source dimensions.");
2119 aurelien 573 
 
2414 jpm 574 
		// parameters for the edge-maximizing crop algorithm
575 
		$r = 1; // radius of edge filter
576 
		$nk = 9; // scale count: number of crop sizes to try
577 
		$gamma = 0.2; // edge normalization parameter -- see documentation
578 
		$ar = $largeur_vignette/$hauteur_vignette;    // target aspect ratio (AR)
579 
		$ar0 = $largeur_image_originale/$hauteur_image_originale;    // original aspect ratio (AR)
2119 aurelien 580 
 
2414 jpm 581 
		$img = new Imagick($chemin_image);
582 
		$imgcp = clone $img;
2119 aurelien 583 
 
2414 jpm 584 
		// compute center of edginess
585 
		$img->edgeImage($r);
586 
		$img->modulateImage(100,0,100); // grayscale
587 
		$img->blackThresholdImage("#0f0f0f");
588 
		$img->writeImage($out);
589 
		// use gd for random pixel access
590 
		$im = ImageCreateFromJpeg($out);
591 
		$xcenter = 0;
592 
		$ycenter = 0;
593 
		$sum = 0;
594 
		$n = 100000;
595 
		for ($k=0; $k<$n; $k++) {
596 
			$i = mt_rand(0,$largeur_image_originale-1);
597 
			$j = mt_rand(0,$hauteur_image_originale-1);
598 
			$val = imagecolorat($im, $i, $j) & 0xFF;
599 
			$sum += $val;
600 
			$xcenter += ($i+1)*$val;
601 
			$ycenter += ($j+1)*$val;
602 
		}
603 
		$xcenter /= $sum;
604 
		$ycenter /= $sum;
2119 aurelien 605 
 
2414 jpm 606 
		// crop source img to target AR
607 
		if ($largeur_image_originale/$hauteur_image_originale > $ar) {
608 
			// source AR wider than target
609 
			// crop width to target AR
610 
			$wcrop0 = round($ar*$hauteur_image_originale);
611 
			$hcrop0 = $hauteur_image_originale;
612 
		} else {
613 
			// crop height to target AR
614 
			$wcrop0 = $largeur_image_originale;
615 
			$hcrop0 = round($largeur_image_originale/$ar);
616 
		}
2119 aurelien 617 
 
2414 jpm 618 
		// crop parameters for all scales and translations
619 
		$params = array();
2119 aurelien 620 
 
2414 jpm 621 
		// crop at different scales
622 
		$hgap = $hcrop0 - $hauteur_vignette;
623 
		$hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
624 
		$wgap = $wcrop0 - $largeur_vignette;
625 
		$winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
2119 aurelien 626 
 
2414 jpm 627 
		// find window with highest normalized edginess
628 
		$n = 10000;
629 
		$maxbetanorm = 0;
630 
		$maxfile = '';
631 
		$maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
2119 aurelien 632 
 
2414 jpm 633 
		for ($k = 0; $k < $nk; $k++) {
634 
			$hcrop = round($hcrop0 - $k*$hinc);
635 
			$wcrop = round($wcrop0 - $k*$winc);
636 
			$xcrop = $xcenter - $wcrop / 2;
637 
			$ycrop = $ycenter - $hcrop / 2;
638 
			//echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
2119 aurelien 639 
 
2414 jpm 640 
			if ($xcrop < 0) $xcrop = 0;
641 
			if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
642 
			if ($ycrop < 0) $ycrop = 0;
643 
			if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
2119 aurelien 644 
 
2414 jpm 645 
			$beta = 0;
646 
			for ($c=0; $c<$n; $c++) {
647 
				$i = mt_rand(0,$wcrop-1);
648 
				$j = mt_rand(0,$hcrop-1);
649 
				$beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
650 
			}
651 
			$area = $wcrop * $hcrop;
652 
			$betanorm = $beta / ($n*pow($area, $gamma-1));
653 
			// echo("beta: $beta; betan: $betanorm");
654 
			// echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
655 
			// best image found, save it
2119 aurelien 656 
 
2414 jpm 657 
			if ($betanorm > $maxbetanorm) {
2119 aurelien 658 
 
2414 jpm 659 
				$maxbetanorm = $betanorm;
660 
				$maxparam['w'] = $wcrop;
661 
				$maxparam['h'] = $hcrop;
662 
				$maxparam['x'] = $xcrop;
663 
				$maxparam['y'] = $ycrop;
664 
			}
665 
		}
2119 aurelien 666 
 
2414 jpm 667 
		// return image
668 
		$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
669 
		$imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
670 
		$imgcp->writeImage($out);
671 
		chmod($out, 0777);
672 
		$img->destroy();
673 
		$imgcp->destroy();
2119 aurelien 674 
 
2414 jpm 675 
		$image_sortie = ImageCreateFromJpeg($out);
676 
		unlink($out);
2119 aurelien 677 
 
2414 jpm 678 
		return $image_sortie;
2119 aurelien 679 
	}
3459 killian 680 
}