Subversion Repositories eFlore/Applications.cel

Rev

Rev 2355 | Details | Compare with Previous | Last modification | View Log | RSS feed

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