Subversion Repositories eFlore/Applications.cel

Rev

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