Subversion Repositories eFlore/Applications.cel

Rev

Rev 3460 | Details | Compare with Previous | 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();
3460 killian 376 
			list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
2119 aurelien 377 
			$image_et_infos['poids_octets'] = filesize($chemin_fichier);
3460 killian 378 
			$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
2119 aurelien 379 
			$image_et_infos['chemin'] = $chemin_fichier;
380 
		}
381 
 
382 
		return $image_et_infos;
383 
	}
384 
 
385 
	public function obtenirDimensionsPourFormat($format) {
386 
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
387 
 
388 
		if (Config::get('format_'.$format) != null) {
389 
			list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', Config::get('format_'.$format));
390 
		}
391 
 
392 
		return $dimensions;
393 
	}
394 
 
395 
	public function calculerTailleImage($informations_images, $taille_max) {
2414 jpm 396 
		$HL_redimension = array();
2119 aurelien 397 
 
2414 jpm 398 
		if ($this->estPaysage($informations_images)) {
399 
			$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
400 
			$HL_redimension['largeur'] = round($taille_max) ;
401 
			$HL_redimension['hauteur'] = round($taille_max*$rapport) ;
402 
		} else {
403 
			$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
404 
			$HL_redimension['hauteur'] = round($taille_max) ;
405 
			$HL_redimension['largeur'] = round($taille_max*$rapport) ;
406 
		}
2119 aurelien 407 
 
2414 jpm 408 
		return $HL_redimension;
2119 aurelien 409 
	}
410 
 
411 
	public function getFormats() {
412 
		return $this->formats;
413 
	}
414 
 
415 
	public function estUnFormatCarre($format) {
416 
		return (strpos($format,'C') === 0);
417 
	}
418 
 
419 
	public function estUnFormatRogne($format) {
420 
		return (strpos($format,'R') === 1);
421 
	}
422 
 
423 
	public function estPaysage($informations_images) {
424 
		return $informations_images['largeur'] > $informations_images['hauteur'];
425 
	}
426 
 
427 
	public function estPortait($informations_images) {
428 
		return $informations_images['largeur'] < $informations_images['hauteur'];
429 
	}
430 
 
431 
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
432 
		$poids_max_octets = Config::get('tailleMaxImages');
433 
 
434 
		$ratio_compression = 100 ;
435 
 
2414 jpm 436 
		if ($poids_octets >= $poids_max_octets) {
437 
			$ratio_compression = 75 ;
438 
		}
2119 aurelien 439 
 
2414 jpm 440 
		return $ratio_compression;
2119 aurelien 441 
	}
442 
 
443 
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
444 
		// creation du format original
445 
		$id_avec_zeros = sprintf('%09s', $id) ;
446 
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
447 
 
448 
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
449 
 
450 
		return $nom_fichier;
451 
	}
452 
 
453 
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
454 
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
455 
 
456 
		foreach($formats as $format) {
457 
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
458 
		}
459 
 
460 
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
461 
 
462 
		// suppression des 0 devant
463 
		$id_image += 0;
464 
 
465 
		return $id_image;
466 
	}
467 
 
468 
	public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
469 
		umask(0);
470 
 
471 
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
472 
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
473 
 
474 
		if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
475 
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
476 
		}
477 
 
478 
		// attention, ceci ne preserve pas les metadonnées
479 
		imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
480 
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
481 
	}
482 
 
483 
	public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
484 
		$img = new Imagick($chemin_image_a_stocker);
485 
 
486 
		// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
487 
		$img->setformat("jpeg");
488 
		$img->setImageCompression(imagick::COMPRESSION_JPEG);
489 
		$img->setCompressionQuality($compression);
490 
		$img->writeImage($chemin_image_a_stocker);
491 
		$img->destroy();
492 
 
493 
		chmod($chemin_image_a_stocker, $this->droits);
494 
	}
495 
 
496 
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
497 
		$image_blanche = imagecreatetruecolor($cote, $cote);
498 
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
499 
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
500 
 
501 
		return $image_blanche;
502 
	}
503 
 
504 
	public function detruireImageEnMemoire($image) {
505 
		imagedestroy($image);
506 
	}
507 
 
508 
	public function detruireImageSurDisque($id) {
509 
		$formats = $this->getFormats();
510 
 
511 
		// on detruit aussi l'image originale
512 
		$formats[] = 'O';
513 
 
514 
		$destruction_formats_fichier = false;
515 
 
516 
		// destructions de chacuns des formats définis
517 
		foreach($formats as $format) {
518 
 
519 
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
520 
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
521 
 
522 
			if (file_exists($dossier_format.'/'.$nom_fichier)) {
523 
				$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
524 
			} else {
525 
				$destruction_formats_fichier = true;
526 
			}
527 
		}
528 
 
529 
		return $destruction_formats_fichier;
530 
	}
531 
 
532 
	/*
533 
	 * edge-maximizing crop
534 
	 * determines center-of-edginess, then tries different-sized crops around it.
535 
	 * picks the crop with the highest normalized edginess.
536 
	 * see documentation on how to tune the algorithm
537 
	 *
538 
	 * $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
539 
	 * $format - le format (ex. : CS, XS, XL, CRS)
540 
	*/
541 
	public function opticrop($informations_image, $format) {
542 
		umask(0);
543 
 
544 
		$nom_temp = md5(time());
545 
		$chemin_temp =
546 
 
547 
		$out = Config::get('dossierImagesStockageTemp').'/'.$nom_temp;
548 
 
549 
		$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
550 
 
551 
		$largeur_vignette = $dimension_vignettes['largeur'];
552 
		$hauteur_vignette = $dimension_vignettes['hauteur'];
553 
 
2414 jpm 554 
		// source dimensions
555 
		$largeur_image_originale = $informations_image['largeur'];
556 
		$hauteur_image_originale = $informations_image['hauteur'];
2119 aurelien 557 
 
2414 jpm 558 
		$chemin_image = $informations_image['chemin'];
2119 aurelien 559 
 
2414 jpm 560 
		//if ($largeur_vignette > $largeur_image_originale || $hauteur_vignette > $hauteur_image_originale)
561 
		//    die("Target dimensions must be smaller or equal to source dimensions.");
2119 aurelien 562 
 
2414 jpm 563 
		// parameters for the edge-maximizing crop algorithm
564 
		$r = 1; // radius of edge filter
565 
		$nk = 9; // scale count: number of crop sizes to try
566 
		$gamma = 0.2; // edge normalization parameter -- see documentation
567 
		$ar = $largeur_vignette/$hauteur_vignette;    // target aspect ratio (AR)
568 
		$ar0 = $largeur_image_originale/$hauteur_image_originale;    // original aspect ratio (AR)
2119 aurelien 569 
 
2414 jpm 570 
		$img = new Imagick($chemin_image);
571 
		$imgcp = clone $img;
2119 aurelien 572 
 
2414 jpm 573 
		// compute center of edginess
574 
		$img->edgeImage($r);
575 
		$img->modulateImage(100,0,100); // grayscale
576 
		$img->blackThresholdImage("#0f0f0f");
577 
		$img->writeImage($out);
578 
		// use gd for random pixel access
579 
		$im = ImageCreateFromJpeg($out);
580 
		$xcenter = 0;
581 
		$ycenter = 0;
582 
		$sum = 0;
583 
		$n = 100000;
584 
		for ($k=0; $k<$n; $k++) {
585 
			$i = mt_rand(0,$largeur_image_originale-1);
586 
			$j = mt_rand(0,$hauteur_image_originale-1);
587 
			$val = imagecolorat($im, $i, $j) & 0xFF;
588 
			$sum += $val;
589 
			$xcenter += ($i+1)*$val;
590 
			$ycenter += ($j+1)*$val;
591 
		}
592 
		$xcenter /= $sum;
593 
		$ycenter /= $sum;
2119 aurelien 594 
 
2414 jpm 595 
		// crop source img to target AR
596 
		if ($largeur_image_originale/$hauteur_image_originale > $ar) {
597 
			// source AR wider than target
598 
			// crop width to target AR
599 
			$wcrop0 = round($ar*$hauteur_image_originale);
600 
			$hcrop0 = $hauteur_image_originale;
601 
		} else {
602 
			// crop height to target AR
603 
			$wcrop0 = $largeur_image_originale;
604 
			$hcrop0 = round($largeur_image_originale/$ar);
605 
		}
2119 aurelien 606 
 
2414 jpm 607 
		// crop parameters for all scales and translations
608 
		$params = array();
2119 aurelien 609 
 
2414 jpm 610 
		// crop at different scales
611 
		$hgap = $hcrop0 - $hauteur_vignette;
612 
		$hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
613 
		$wgap = $wcrop0 - $largeur_vignette;
614 
		$winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
2119 aurelien 615 
 
2414 jpm 616 
		// find window with highest normalized edginess
617 
		$n = 10000;
618 
		$maxbetanorm = 0;
619 
		$maxfile = '';
620 
		$maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
2119 aurelien 621 
 
2414 jpm 622 
		for ($k = 0; $k < $nk; $k++) {
623 
			$hcrop = round($hcrop0 - $k*$hinc);
624 
			$wcrop = round($wcrop0 - $k*$winc);
625 
			$xcrop = $xcenter - $wcrop / 2;
626 
			$ycrop = $ycenter - $hcrop / 2;
627 
			//echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
2119 aurelien 628 
 
2414 jpm 629 
			if ($xcrop < 0) $xcrop = 0;
630 
			if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
631 
			if ($ycrop < 0) $ycrop = 0;
632 
			if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
2119 aurelien 633 
 
2414 jpm 634 
			$beta = 0;
635 
			for ($c=0; $c<$n; $c++) {
636 
				$i = mt_rand(0,$wcrop-1);
637 
				$j = mt_rand(0,$hcrop-1);
638 
				$beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
639 
			}
640 
			$area = $wcrop * $hcrop;
641 
			$betanorm = $beta / ($n*pow($area, $gamma-1));
642 
			// echo("beta: $beta; betan: $betanorm");
643 
			// echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
644 
			// best image found, save it
2119 aurelien 645 
 
2414 jpm 646 
			if ($betanorm > $maxbetanorm) {
2119 aurelien 647 
 
2414 jpm 648 
				$maxbetanorm = $betanorm;
649 
				$maxparam['w'] = $wcrop;
650 
				$maxparam['h'] = $hcrop;
651 
				$maxparam['x'] = $xcrop;
652 
				$maxparam['y'] = $ycrop;
653 
			}
654 
		}
2119 aurelien 655 
 
2414 jpm 656 
		// return image
657 
		$imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
658 
		$imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
659 
		$imgcp->writeImage($out);
660 
		chmod($out, 0777);
661 
		$img->destroy();
662 
		$imgcp->destroy();
2119 aurelien 663 
 
2414 jpm 664 
		$image_sortie = ImageCreateFromJpeg($out);
665 
		unlink($out);
2119 aurelien 666 
 
2414 jpm 667 
		return $image_sortie;
2119 aurelien 668 
	}
3459 killian 669 
}