Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | 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)) {
97
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($this->obtenirCheminImageOriginale($id));
98
			if($infos_image_originale) {
99
				$debut = microtime();
100
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
101
 
102
				$image = file_get_contents($chemin_image);
103
			}
104
		} else {
105
			$image = file_get_contents($chemin_image);
106
		}
107
 
108
		return $image;
109
	}
110
 
668 aurelien 111
	public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') {
1154 jpm 112
		if ($format == 'O') {
591 aurelien 113
			// format original : rien à faire
114
			$image_redimensionnee = $infos_image_originale['image'];
1154 jpm 115
 
591 aurelien 116
		} else {
632 aurelien 117
			 if ($this->estUnFormatRogne($format)) {
118
			 	if ($this->mode == self::MODE_IMAGEMAGICK) {
119
			 		// si l'on dispose de la librairie imageMagick
120
			 		// on applique l'algorithme d'auto détection de sujets
121
			 		// qui centre la miniature sur le sujet de l'image
122
			 		$image_redimensionnee = $this->opticrop($infos_image_originale, $format);
123
			 	} else {
124
			 		// si l'on ne dispose que de gd
125
					// la minature est une image redimensionnée rognée au centre
1154 jpm 126
					$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
127
			 	}
632 aurelien 128
			} else if ($this->estUnFormatCarre($format)) {
591 aurelien 129
				// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
1154 jpm 130
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
591 aurelien 131
			} else {
1154 jpm 132
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
591 aurelien 133
			}
134
		}
1154 jpm 135
 
668 aurelien 136
		return $image_redimensionnee;
137
	}
2083 aurelien 138
 
139
	public function stockerFichierOriginal($fichier, $id) {
140
		$chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier;
141
 
142
		$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
143
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
144
 
145
		$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
146
 
147
		$deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier);
148
 
149
		if ($deplacement_fichier) {
150
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
151
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
152
 
153
			if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) {
154
				$this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression);
155
			}
1154 jpm 156
 
2083 aurelien 157
			return $infos_image_originale;
158
 
159
		} else {
160
			$erreur =  'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
161
			$this->logger('CEL_bugs',$erreur);
162
			return false ;
163
		}
164
	}
165
 
166
	public function stockerFichierEtCreerMiniatures($fichier, $id) {
167
 
168
		$infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id);
169
		if($infos_image_originale_stockee) {
170
			$formats = $this->getFormats();
171
 
172
			// creation de miniatures pour chacuns des formats définis
173
			foreach($formats as $format) {
174
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
175
			}
176
		} else {
177
			$erreur =  'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ;
178
			$this->logger('CEL_bugs',$erreur);
179
			return false ;
180
		}
181
 
182
		return true ;
183
	}
184
 
668 aurelien 185
	public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
186
		$image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format);
1154 jpm 187
 
591 aurelien 188
		$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
189
		$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
1154 jpm 190
 
591 aurelien 191
		return true;
192
	}
1154 jpm 193
 
591 aurelien 194
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
195
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
1154 jpm 196
 
197
		imagecopyresampled($image_redimensionnee,
198
			$infos_image_originale['image'],
199
			0, 0,
200
			0, 0,
201
			$largeur_redimension,
202
			$hauteur_redimension,
203
			$infos_image_originale['largeur'],
672 jpm 204
			$infos_image_originale['hauteur']
591 aurelien 205
		);
1154 jpm 206
 
591 aurelien 207
		return $image_redimensionnee;
208
	}
1154 jpm 209
 
591 aurelien 210
	public function creerMiniature($informations_images, $format) {
211
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
1154 jpm 212
 
591 aurelien 213
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
214
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
1154 jpm 215
 
591 aurelien 216
		return $image_redimensionnee;
217
	}
1154 jpm 218
 
591 aurelien 219
	public function creerMiniatureCarree($informations_image, $format) {
220
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
221
		$cote_carre = $taille_reference_pour_format['largeur'];
1154 jpm 222
 
591 aurelien 223
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
224
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
1154 jpm 225
 
226
		if ($this->estPaysage($informations_image)) {
672 jpm 227
			$debut_largeur_a_copier = 0 ;
1154 jpm 228
			$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
591 aurelien 229
		} else {
672 jpm 230
			$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
1154 jpm 231
			$debut_hauteur_a_copier = 0 ;
591 aurelien 232
		}
1154 jpm 233
 
591 aurelien 234
		$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
1154 jpm 235
 
591 aurelien 236
		imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
672 jpm 237
			$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
238
			$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
591 aurelien 239
		);
240
 
241
		return $image_carre_blanc_cible;
242
	}
1154 jpm 243
 
591 aurelien 244
	public function creerMiniatureCarreeRognee($informations_image, $format) {
245
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
246
		$cote_carre = $taille_reference_pour_format['largeur'];
247
		$cote_carre_non_redimensionne = 0;
1154 jpm 248
 
249
		if ($this->estPaysage($informations_image)) {
250
			$cote_carre_non_redimensionne = $informations_image['hauteur'];
672 jpm 251
			$debut_largeur_a_copier = ($informations_image['hauteur'] - $cote_carre)/2 ;
252
			$debut_hauteur_a_copier = 0;
1154 jpm 253
 
672 jpm 254
			if($debut_largeur_a_copier <= 0) {
255
				$debut_largeur_a_copier = 0;
256
			}
1154 jpm 257
 
672 jpm 258
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
259
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
260
		} else {
261
			$cote_carre_non_redimensionne = $informations_image['largeur'];
262
			$debut_largeur_a_copier = 0 ;
263
			$debut_hauteur_a_copier = ($informations_image['largeur'] - $cote_carre)/2;
1154 jpm 264
 
672 jpm 265
			if($debut_hauteur_a_copier <= 0) {
591 aurelien 266
				$debut_hauteur_a_copier = 0;
672 jpm 267
			}
1154 jpm 268
 
672 jpm 269
			$nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne;
270
			$nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne;
591 aurelien 271
		}
1154 jpm 272
 
591 aurelien 273
		$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
1154 jpm 274
 
275
		imagecopyresampled($image_carre_temporaire,
276
			$informations_image['image'],
277
			0, 0,
672 jpm 278
			$debut_largeur_a_copier,
1154 jpm 279
			$debut_hauteur_a_copier,
280
			$cote_carre_non_redimensionne,
281
			$cote_carre_non_redimensionne,
282
			$nb_pixels_largeur_a_copier,
672 jpm 283
			$nb_pixels_hauteur_a_copier
591 aurelien 284
		);
1154 jpm 285
 
591 aurelien 286
		$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
1154 jpm 287
 
288
		imagecopyresampled($image_redimensionnee,
289
			$image_carre_temporaire,
290
			0, 0,
291
			0, 0,
292
			$cote_carre,
293
			$cote_carre,
294
			$cote_carre_non_redimensionne,
672 jpm 295
			$cote_carre_non_redimensionne
591 aurelien 296
		);
297
 
298
		return $image_redimensionnee;
299
	}
1154 jpm 300
 
632 aurelien 301
	public function stockerImageExterne($chemin_fichier_temp, $chemin_destination) {
1154 jpm 302
		if (is_uploaded_file($chemin_fichier_temp)) {
632 aurelien 303
			$deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination);
304
		} else {
305
			$deplacement = rename($chemin_fichier_temp, $chemin_destination);
306
		}
1154 jpm 307
 
632 aurelien 308
		return $deplacement;
309
	}
1154 jpm 310
 
591 aurelien 311
	public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
672 jpm 312
		$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format);
1154 jpm 313
 
672 jpm 314
		if (!file_exists($chemin_sur_serveur_final)) {
668 aurelien 315
			umask(0);
672 jpm 316
			if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) {
591 aurelien 317
				$erreur =  'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
672 jpm 318
				$this->logger('CEL_bugs', $erreur);
591 aurelien 319
				return false;
320
			}
321
		}
1154 jpm 322
 
591 aurelien 323
		return $chemin_sur_serveur_final;
324
	}
1154 jpm 325
 
591 aurelien 326
	public function obtenirDossierPourFormat($id, $format) {
970 aurelien 327
		$chemin_base = $this->config['cel']['chemin_images'];
1154 jpm 328
 
672 jpm 329
		$chemin_sur_serveur = $chemin_base;
1154 jpm 330
 
672 jpm 331
		$id = sprintf('%09s', $id);
332
		$id = wordwrap($id, 3 , '_', true);
1154 jpm 333
 
672 jpm 334
		list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
1154 jpm 335
 
591 aurelien 336
		$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
1154 jpm 337
 
591 aurelien 338
		return $chemin_sur_serveur_final;
339
	}
1154 jpm 340
 
668 aurelien 341
	public function obtenirCheminImageOriginale($id_image) {
342
		$nom = $this->convertirIdBddVersNomFichier($id_image, 'O');
343
		$dossier = $this->obtenirDossierPourFormat($id_image,'O');
1154 jpm 344
 
668 aurelien 345
		return $dossier.'/'.$nom;
346
	}
1154 jpm 347
 
668 aurelien 348
	public function obtenirImageEtInfosPourId($id_image) {
349
		$chemin_image_o = $this->obtenirCheminImageOriginale($id_image);
350
		return $this->obtenirImageEtInfosPourChemin($chemin_image_o);
351
	}
1154 jpm 352
 
591 aurelien 353
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
668 aurelien 354
		$image_et_infos = false;
1154 jpm 355
 
356
		if (file_exists($chemin_fichier)) {
668 aurelien 357
			$image_et_infos = array();
1154 jpm 358
			list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
668 aurelien 359
			$image_et_infos['poids_octets'] = filesize($chemin_fichier);
360
			$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
361
			$image_et_infos['chemin'] = $chemin_fichier;
362
		}
1154 jpm 363
 
591 aurelien 364
		return $image_et_infos;
365
	}
1154 jpm 366
 
591 aurelien 367
	public function obtenirDimensionsPourFormat($format) {
672 jpm 368
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
1154 jpm 369
 
970 aurelien 370
		if (isset($this->config['cel']['format_'.$format])) {
371
			list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', $this->config['cel']['format_'.$format]);
591 aurelien 372
		}
1154 jpm 373
 
591 aurelien 374
		return $dimensions;
375
	}
1154 jpm 376
 
591 aurelien 377
	public function calculerTailleImage($informations_images, $taille_max) {
672 jpm 378
        $HL_redimension = array();
1154 jpm 379
 
672 jpm 380
        if ($this->estPaysage($informations_images)) {
381
	        $rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
382
	        $HL_redimension['largeur'] = round($taille_max) ;
383
	        $HL_redimension['hauteur'] = round($taille_max*$rapport) ;
1154 jpm 384
 
672 jpm 385
        } else {
386
        	$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
387
	        $HL_redimension['hauteur'] = round($taille_max) ;
388
	        $HL_redimension['largeur'] = round($taille_max*$rapport) ;
389
        }
1154 jpm 390
 
672 jpm 391
        return $HL_redimension;
591 aurelien 392
	}
1154 jpm 393
 
591 aurelien 394
	public function getFormats() {
395
		return $this->formats;
396
	}
1154 jpm 397
 
591 aurelien 398
	public function estUnFormatCarre($format) {
1154 jpm 399
		return (strpos($format,'C') === 0);
591 aurelien 400
	}
1154 jpm 401
 
591 aurelien 402
	public function estUnFormatRogne($format) {
1154 jpm 403
		return (strpos($format,'R') === 1);
591 aurelien 404
	}
1154 jpm 405
 
591 aurelien 406
	public function estPaysage($informations_images) {
407
		return $informations_images['largeur'] > $informations_images['hauteur'];
408
	}
1154 jpm 409
 
591 aurelien 410
	public function estPortait($informations_images) {
411
		return $informations_images['largeur'] < $informations_images['hauteur'];
412
	}
1154 jpm 413
 
591 aurelien 414
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
970 aurelien 415
		$poids_max_octets = $this->config['cel']['taille_max'];
1154 jpm 416
 
591 aurelien 417
		$ratio_compression = 100 ;
1154 jpm 418
 
632 aurelien 419
	    if ($poids_octets >= $poids_max_octets) {
591 aurelien 420
	      $ratio_compression = 75 ;
421
	    }
1154 jpm 422
 
591 aurelien 423
	    return $ratio_compression;
424
	}
1154 jpm 425
 
591 aurelien 426
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
672 jpm 427
		// creation du format original
591 aurelien 428
		$id_avec_zeros = sprintf('%09s', $id) ;
429
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
1154 jpm 430
 
591 aurelien 431
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
1154 jpm 432
 
591 aurelien 433
		return $nom_fichier;
434
	}
1154 jpm 435
 
591 aurelien 436
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
437
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
1154 jpm 438
 
591 aurelien 439
		foreach($formats as $format) {
440
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
441
		}
1154 jpm 442
 
591 aurelien 443
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
1154 jpm 444
 
591 aurelien 445
		// suppression des 0 devant
446
		$id_image += 0;
1154 jpm 447
 
591 aurelien 448
		return $id_image;
449
	}
1154 jpm 450
 
632 aurelien 451
	public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) {
591 aurelien 452
		umask(0);
1154 jpm 453
 
591 aurelien 454
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
455
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
1154 jpm 456
 
632 aurelien 457
		if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
591 aurelien 458
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
459
		}
1154 jpm 460
 
668 aurelien 461
		// attention, ceci ne preserve pas les metadonnées
632 aurelien 462
		imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
591 aurelien 463
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
464
	}
1154 jpm 465
 
466
	public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) {
467
		$img = new Imagick($chemin_image_a_stocker);
468
 
632 aurelien 469
		// l'utilisation d'image magick préserve les métadonnées lors d'une recompression
1154 jpm 470
		$img->setformat("jpeg");
471
		$img->setImageCompression(imagick::COMPRESSION_JPEG);
472
		$img->setCompressionQuality($compression);
473
		$img->writeImage($chemin_image_a_stocker);
474
		$img->destroy();
475
 
476
		chmod($chemin_image_a_stocker, $this->droits);
591 aurelien 477
	}
1154 jpm 478
 
591 aurelien 479
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
1154 jpm 480
		$image_blanche = imagecreatetruecolor($cote, $cote);
591 aurelien 481
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
482
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
1154 jpm 483
 
591 aurelien 484
		return $image_blanche;
485
	}
1154 jpm 486
 
487
	public function detruireImageEnMemoire($image) {
591 aurelien 488
		imagedestroy($image);
489
	}
1154 jpm 490
 
591 aurelien 491
	public function detruireImageSurDisque($id) {
492
		$formats = $this->getFormats();
1154 jpm 493
 
591 aurelien 494
		// on detruit aussi l'image originale
495
		$formats[] = 'O';
1154 jpm 496
 
621 aurelien 497
		$destruction_formats_fichier = false;
1154 jpm 498
 
591 aurelien 499
		// destructions de chacuns des formats définis
500
		foreach($formats as $format) {
1154 jpm 501
 
591 aurelien 502
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
503
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
1154 jpm 504
 
632 aurelien 505
			if (file_exists($dossier_format.'/'.$nom_fichier)) {
621 aurelien 506
				$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
507
			} else {
508
				$destruction_formats_fichier = true;
509
			}
591 aurelien 510
		}
1154 jpm 511
 
621 aurelien 512
		return $destruction_formats_fichier;
591 aurelien 513
	}
1154 jpm 514
 
1755 raphael 515
	// recopie de Cel->logger() (pas d'extends pour ça)
516
	public function logger($index,$chaine) {
517
		if(!class_exists('Log')) {
518
			Log::getInstance();
519
		}
520
 
521
		Log::setCheminLog($this->config['log']['cheminlog']);
522
		Log::setTimeZone($this->config['log']['timezone']);
523
		Log::setTailleMax($this->config['log']['taillemax']);
524
 
525
		Log::ajouterEntree($index,$chaine);
526
	}
527
 
1154 jpm 528
	/*
632 aurelien 529
	 * edge-maximizing crop
1154 jpm 530
	 * determines center-of-edginess, then tries different-sized crops around it.
632 aurelien 531
	 * picks the crop with the highest normalized edginess.
532
	 * see documentation on how to tune the algorithm
533
	 *
534
	 * $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin
535
	 * $format - le format (ex. : CS, XS, XL, CRS)
536
	*/
672 jpm 537
	public function opticrop($informations_image, $format) {
632 aurelien 538
		umask(0);
1154 jpm 539
 
632 aurelien 540
		$nom_temp = md5(time());
1154 jpm 541
		$chemin_temp =
542
 
970 aurelien 543
		$out = $this->config['cel']['chemin_stockage_temp'].'/'.$nom_temp;
1154 jpm 544
 
632 aurelien 545
		$dimension_vignettes = $this->obtenirDimensionsPourFormat($format);
1154 jpm 546
 
632 aurelien 547
		$largeur_vignette = $dimension_vignettes['largeur'];
548
		$hauteur_vignette = $dimension_vignettes['hauteur'];
1154 jpm 549
 
632 aurelien 550
	    // source dimensions
551
	    $largeur_image_originale = $informations_image['largeur'];
552
	    $hauteur_image_originale = $informations_image['hauteur'];
1154 jpm 553
 
632 aurelien 554
	    $chemin_image = $informations_image['chemin'];
1154 jpm 555
 
632 aurelien 556
	    //if ($largeur_vignette > $largeur_image_originale || $hauteur_vignette > $hauteur_image_originale)
557
	    //    die("Target dimensions must be smaller or equal to source dimensions.");
1154 jpm 558
 
632 aurelien 559
	    // parameters for the edge-maximizing crop algorithm
560
	    $r = 1;         // radius of edge filter
561
	    $nk = 9;        // scale count: number of crop sizes to try
562
	    $gamma = 0.2;   // edge normalization parameter -- see documentation
563
	    $ar = $largeur_vignette/$hauteur_vignette;    // target aspect ratio (AR)
564
	    $ar0 = $largeur_image_originale/$hauteur_image_originale;    // original aspect ratio (AR)
1154 jpm 565
 
632 aurelien 566
	    //echo("$chemin_image: $largeur_image_originale x $hauteur_image_originale => $largeur_vignette x $hauteur_vignette");
567
	    $img = new Imagick($chemin_image);
568
	    $imgcp = clone $img;
1154 jpm 569
 
632 aurelien 570
	    // compute center of edginess
571
	    $img->edgeImage($r);
572
	    $img->modulateImage(100,0,100); // grayscale
573
	    $img->blackThresholdImage("#0f0f0f");
574
	    $img->writeImage($out);
575
	    // use gd for random pixel access
576
	    $im = ImageCreateFromJpeg($out);
577
	    $xcenter = 0;
578
	    $ycenter = 0;
579
	    $sum = 0;
580
	    $n = 100000;
581
	    for ($k=0; $k<$n; $k++) {
582
	        $i = mt_rand(0,$largeur_image_originale-1);
583
	        $j = mt_rand(0,$hauteur_image_originale-1);
584
	        $val = imagecolorat($im, $i, $j) & 0xFF;
585
	        $sum += $val;
586
	        $xcenter += ($i+1)*$val;
587
	        $ycenter += ($j+1)*$val;
588
	    }
589
	    $xcenter /= $sum;
590
	    $ycenter /= $sum;
1154 jpm 591
 
632 aurelien 592
	    // crop source img to target AR
593
	    if ($largeur_image_originale/$hauteur_image_originale > $ar) {
594
	        // source AR wider than target
595
	        // crop width to target AR
596
	        $wcrop0 = round($ar*$hauteur_image_originale);
597
	        $hcrop0 = $hauteur_image_originale;
672 jpm 598
	    } else {
632 aurelien 599
	        // crop height to target AR
600
	        $wcrop0 = $largeur_image_originale;
601
	        $hcrop0 = round($largeur_image_originale/$ar);
602
	    }
1154 jpm 603
 
632 aurelien 604
	    // crop parameters for all scales and translations
605
	    $params = array();
1154 jpm 606
 
632 aurelien 607
	    // crop at different scales
608
	    $hgap = $hcrop0 - $hauteur_vignette;
609
	    $hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1);
610
	    $wgap = $wcrop0 - $largeur_vignette;
611
	    $winc = ($nk == 1) ? 0 : $wgap / ($nk - 1);
1154 jpm 612
 
632 aurelien 613
	    // find window with highest normalized edginess
614
	    $n = 10000;
615
	    $maxbetanorm = 0;
616
	    $maxfile = '';
617
	    $maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0);
1154 jpm 618
 
632 aurelien 619
	    for ($k = 0; $k < $nk; $k++) {
620
	        $hcrop = round($hcrop0 - $k*$hinc);
621
	        $wcrop = round($wcrop0 - $k*$winc);
622
	        $xcrop = $xcenter - $wcrop / 2;
623
	        $ycrop = $ycenter - $hcrop / 2;
624
	        //echo("crop: $wcrop, $hcrop, $xcrop, $ycrop");
1154 jpm 625
 
632 aurelien 626
	        if ($xcrop < 0) $xcrop = 0;
627
	        if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop;
628
	        if ($ycrop < 0) $ycrop = 0;
629
	        if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop;
1154 jpm 630
 
632 aurelien 631
	        /*if (self::MODE_DEBUG) {
632
	        	// debug
633
	        	$currfile = '/home/aurelien/web/file_tmp/'."image$k.jpg";
1154 jpm 634
 
632 aurelien 635
	            $currimg = clone $img;
1154 jpm 636
	            $c= new ImagickDraw();
637
	            $c->setFillColor("red");
638
	            $c->circle($xcenter, $ycenter, $xcenter, $ycenter+4);
639
	            $currimg->drawImage($c);
632 aurelien 640
	            $currimg->cropImage($wcrop, $hcrop, $xcrop, $ycrop);
641
	            $currimg->writeImage($currfile);
642
	            $currimg->destroy();
643
	        }*/
1154 jpm 644
 
632 aurelien 645
	        $beta = 0;
646
	        for ($c=0; $c<$n; $c++) {
647
	            $i = mt_rand(0,$wcrop-1);
648
	            $j = mt_rand(0,$hcrop-1);
649
	            $beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF;
650
	        }
651
	        $area = $wcrop * $hcrop;
652
	        $betanorm = $beta / ($n*pow($area, $gamma-1));
653
	        // echo("beta: $beta; betan: $betanorm");
654
	        // echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>");
655
	        // best image found, save it
1154 jpm 656
 
632 aurelien 657
	        if ($betanorm > $maxbetanorm) {
1154 jpm 658
 
632 aurelien 659
	            $maxbetanorm = $betanorm;
660
	            $maxparam['w'] = $wcrop;
661
	            $maxparam['h'] = $hcrop;
662
	            $maxparam['x'] = $xcrop;
663
	            $maxparam['y'] = $ycrop;
664
	            // $maxfile = $currfile;
665
	        }
666
	    }
1154 jpm 667
 
632 aurelien 668
        // return image
669
        $imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']);
670
        $imgcp->scaleImage($largeur_vignette, $hauteur_vignette);
671
        $imgcp->writeImage($out);
672
	    chmod($out, 0777);
673
	    $img->destroy();
674
	    $imgcp->destroy();
1154 jpm 675
 
632 aurelien 676
	    $image_sortie = ImageCreateFromJpeg($out);
677
	    unlink($out);
1154 jpm 678
 
632 aurelien 679
	    return $image_sortie;
680
	}
591 aurelien 681
}
682
?>