Subversion Repositories eFlore/Applications.cel

Rev

Rev 2134 | Rev 3459 | Go to most recent revision | 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();
376
			list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
377
			$image_et_infos['poids_octets'] = filesize($chemin_fichier);
378
			$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
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
	}
2414 jpm 669
}