Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
591 aurelien 1
<?php
2
Class ImageRecreation extends DBAccessor {
3
 
605 aurelien 4
	private $droits = 0755;
591 aurelien 5
	private $formats = array('CRX2S','CXS','CS','S','M','L','XL','X2L','X3L');
6
 
7
	public function ImageRecreation($config) {
8
 
9
		$this->config=$config;
10
	}
11
 
12
	public function getRessource() {
605 aurelien 13
 
591 aurelien 14
	}
15
 
16
	public function getElement($param) {
17
 
18
	}
19
 
605 aurelien 20
	public function recreerMiniaturesRecursivement() {
21
		$this->itererRecursivement($this->config['cel_db']['chemin_images']);
621 aurelien 22
	}
591 aurelien 23
 
605 aurelien 24
	public function itererRecursivement($dossier) {
591 aurelien 25
 
26
		// on ne parse que le dossier des images originales
27
		$dossiers_a_exclure = $this->getFormats();
28
 
29
		foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
30
 
31
			if($fichier_ou_dossier->isDot()) {
32
				continue;
33
			}
34
 
35
			if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
36
				continue;
37
			}
38
 
39
		    if($fichier_ou_dossier->isDir()) {
40
 
41
		    	$profondeur_dossier_fils = $profondeur + 1;
42
	    		$this->itererRecursivement($fichier_ou_dossier->getPathname(), $profondeur_dossier_fils);
43
 
44
		    } else {
45
 
46
		    	$nom_fichier = $fichier_ou_dossier->getFilename();
47
 
48
				$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
605 aurelien 49
		    	$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
591 aurelien 50
 
51
		    	// creation de miniatures pour chacuns des formats définis
605 aurelien 52
				foreach($this->formats as $format) {
591 aurelien 53
 
54
					$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
55
				}
56
		    }
57
		}
58
	}
59
 
60
	public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
61
 
62
		if($format == 'O') {
63
			// format original : rien à faire
64
			$image_redimensionnee = $infos_image_originale['image'];
65
 
66
		} else {
67
			 if($this->estUnFormatRogne($format)) {
68
				// la minature est une image redimensionnée rognée au centre
69
				$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format);
70
			} else if($this->estUnFormatCarre($format)) {
71
				// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
72
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);
73
			} else {
74
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);
75
			}
76
		}
77
 
78
		$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
79
		$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
80
 
81
		return true;
82
	}
83
 
84
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
85
 
86
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
87
 
88
		imagecopyresampled($image_redimensionnee,
89
						$infos_image_originale['image'],
90
						0, 0,
91
						0, 0,
92
						$largeur_redimension,
93
						$hauteur_redimension,
94
						$infos_image_originale['largeur'],
95
						$infos_image_originale['hauteur']
96
		);
97
 
98
		return $image_redimensionnee;
99
	}
100
 
101
	public function creerMiniature($informations_images, $format) {
102
 
103
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
104
 
105
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
106
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
107
 
108
		return $image_redimensionnee;
109
	}
110
 
111
	public function creerMiniatureCarree($informations_image, $format) {
112
 
113
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
114
		$cote_carre = $taille_reference_pour_format['largeur'];
115
 
116
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
117
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
118
 
119
		if($this->estPaysage($informations_image)) {
120
				$debut_largeur_a_copier = 0 ;
121
				$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;
122
		} else {
123
				$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
124
				$debut_hauteur_a_copier = 0 ;
125
		}
126
 
127
		$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
128
 
129
		imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
130
				$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
131
				$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
132
		);
133
 
134
		return $image_carre_blanc_cible;
135
	}
136
 
137
	public function creerMiniatureCarreeRognee($informations_image, $format) {
138
 
139
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
140
		$cote_carre = $taille_reference_pour_format['largeur'];
141
		$cote_carre_non_redimensionne = 0;
142
 
143
		if($this->estPaysage($informations_image)) {
144
				$cote_carre_non_redimensionne = $informations_image['hauteur'];
145
				$debut_largeur_a_copier = ($informations_image['hauteur'] - $informations_image['hauteur'])/2 ;
146
				$debut_hauteur_a_copier = 0;
147
				$nb_pixels_largeur_a_copier = $informations_image['hauteur'];
148
				$nb_pixels_hauteur_a_copier = $informations_image['hauteur'];
149
		} else {
150
				$cote_carre_non_redimensionne = $informations_image['largeur'];
151
				$debut_largeur_a_copier = 0 ;
152
				$debut_hauteur_a_copier = ($informations_image['largeur'] - $informations_image['largeur'])/2;
153
				$nb_pixels_largeur_a_copier = $informations_image['largeur'];
154
				$nb_pixels_hauteur_a_copier = $informations_image['largeur'];
155
		}
156
 
157
		$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
158
 
159
		imagecopyresampled($image_carre_temporaire,
160
						$informations_image['image'],
161
						0, 0,
162
						$debut_largeur_a_copier,
163
						$debut_hauteur_a_copier,
164
						$cote_carre_non_redimensionne,
165
						$cote_carre_non_redimensionne,
166
						$nb_pixels_largeur_a_copier,
167
						$nb_pixels_hauteur_a_copier
168
		);
169
 
170
		$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
171
 
172
		imagecopyresampled($image_redimensionnee,
173
						$image_carre_temporaire,
174
						0, 0,
175
						0, 0,
176
						$cote_carre,
177
						$cote_carre,
178
						$cote_carre_non_redimensionne,
179
						$cote_carre_non_redimensionne
180
		);
181
 
182
		return $image_redimensionnee;
183
	}
184
 
621 aurelien 185
 
186
	/*public function extractionSelonDate() {
187
 
188
		$DB=$this->connectDB($this->config,'cel_db');
591 aurelien 189
 
621 aurelien 190
		$requete_selection_diff = 'SELECT * FROM cel_images WHERE ci_meta_date_ajout >= "2011-02-23"';
191
 
192
		$diff_image =& $DB->query($query_ordre);
193
 
194
		if (PEAR::isError($diff_imag))
195
		{
196
			$erreur = 'ERROR' ;
197
	        die($diff_image->getMessage());
198
	    }
199
 
200
		while ($row =& $diff_image->fetchrow(DB_FETCHMODE_ASSOC)) {
201
 
202
			$id = $row['ci_id_image'];
203
 
204
			$dossier = $this->obtenirDossierPourFormat($id,'L');
205
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'L');
206
 
207
			$chemin_complet = $dossier.'/'.$nom_fichier;
208
 
209
 
210
 
211
			$chemin_stockage_fichier = '/home/telabotap/www/sites/eflore/projets/cel_sauvegarde/'.str_replace(' ','_',$row['ci_nom_original']);
212
			copy($chemin_complet,$chemin_stockage_fichier);
213
 
214
		}
215
	}*/
216
 
217
	public function stockerFichierEtCreerMiniatures($fichier, $id) {
218
 
591 aurelien 219
		$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
220
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
221
 
222
		$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
223
 
621 aurelien 224
		if(rename($fichier['tmp_name'],$chemin_fichier)) {
591 aurelien 225
 
226
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
227
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
228
 
229
			if($taux_compression < 100) {
230
				$this->recompresserImageSurDisqueEnPreservantMeta($chemin_fichier, $taux_compression);
231
			}
232
 
233
			$infos_image_originale_stockee = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
234
 
235
			$formats = $this->getFormats();
236
 
237
			// creation de miniatures pour chacuns des formats définis
238
			foreach($formats as $format) {
239
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
240
			}
241
 
242
	  		return true ;
243
 
244
		} else {
245
			$erreur =  'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
246
			$this->logger('CEL_bugs',$erreur);
247
  			return false ;
248
		}
249
	}
250
 
251
	public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
252
 
253
		$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id,$format);
254
 
255
		if(!file_exists($chemin_sur_serveur_final))
256
		{
257
			if(mkdir($chemin_sur_serveur_final,$this->droits, true)) {
258
				chmod($chemin_sur_serveur_final,$this->droits);
259
			}
260
			else
261
			{
262
				$erreur =  'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
263
				echo $erreur;
264
				$this->logger('CEL_bugs',$erreur);
265
				return false;
266
			}
267
		}
268
 
269
		return $chemin_sur_serveur_final;
270
	}
271
 
272
	public function obtenirDossierPourFormat($id, $format) {
273
 
274
		$chemin_base = $this->config['cel_db']['chemin_images'];
275
 
276
		$chemin_sur_serveur = $chemin_base ;
277
 
278
		$id = sprintf('%09s', $id) ;
279
		$id = wordwrap($id, 3 , '_', true) ;
280
 
281
		$niveauDossier = split("_", $id) ;
282
 
283
		$dossierNiveau1 = $niveauDossier[0] ;
284
		$dossierNiveau2 = $niveauDossier[1] ;
285
 
286
		$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
287
 
288
		return $chemin_sur_serveur_final;
289
	}
290
 
291
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
292
 
293
		$image_et_infos = array();
294
 
295
		list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);
296
		$image_et_infos['poids_octets'] = filesize($chemin_fichier);
297
		$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
298
 
299
		return $image_et_infos;
300
	}
301
 
302
	public function obtenirDimensionsPourFormat($format) {
303
 
304
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
305
 
306
		if(isset($this->config['cel_db']['format_'.$format])) {
307
 
308
			$format_largeur_hauteur = split('_', $this->config['cel_db']['format_'.$format]);
309
 
310
			$dimensions['largeur'] = $format_largeur_hauteur[0];
311
			$dimensions['hauteur'] = $format_largeur_hauteur[1];
312
		}
313
 
314
		return $dimensions;
315
 
316
	}
317
 
318
	public function calculerTailleImage($informations_images, $taille_max) {
319
 
320
	        $HL_redimension = array();
321
 
322
	        if($this->estPaysage($informations_images)) {
323
 
324
		        $rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
325
		        $HL_redimension['largeur'] = round($taille_max) ;
326
		        $HL_redimension['hauteur'] = round($taille_max*$rapport) ;
327
 
328
	        } else {
329
	        	$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
330
		        $HL_redimension['hauteur'] = round($taille_max) ;
331
		        $HL_redimension['largeur'] = round($taille_max*$rapport) ;
332
	        }
333
 
334
	        return $HL_redimension;
335
	}
336
 
337
	public function getFormats() {
338
		return $this->formats;
339
	}
340
 
341
	public function estUnFormatCarre($format) {
342
 
343
		return (strpos($format,'C') === 0);
344
	}
345
 
346
	public function estUnFormatRogne($format) {
347
 
348
		return (strpos($format,'R') === 1);
349
	}
350
 
351
	public function estPaysage($informations_images) {
352
		return $informations_images['largeur'] > $informations_images['hauteur'];
353
	}
354
 
355
	public function estPortait($informations_images) {
356
		return $informations_images['largeur'] < $informations_images['hauteur'];
357
	}
358
 
359
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
360
 
361
		$poids_max_octets = $this->config['cel_db']['taille_max'];
362
 
363
		$ratio_compression = 100 ;
364
 
365
	    if($poids_octets >= $poids_max_octets) {
366
	      $ratio_compression = 75 ;
367
	    }
368
 
369
	    return $ratio_compression;
370
	}
371
 
372
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
373
 
374
			// creation du format original
375
		$id_avec_zeros = sprintf('%09s', $id) ;
376
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
377
 
378
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
379
 
380
		return $nom_fichier;
381
	}
382
 
383
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
384
 
385
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
386
 
387
		foreach($formats as $format) {
388
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
389
		}
390
 
391
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
392
 
393
		// suppression des 0 devant
394
		$id_image += 0;
395
 
396
		return $id_image;
397
	}
398
 
399
	public function ecrireImageSurDisque($image, $id, $format, $compression = 100) {
400
 
401
		umask(0);
402
 
403
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
404
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
405
 
406
		if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
407
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
408
		}
409
 
410
		// attention ceci ne preserve pas les metadonnées
411
		imagejpeg($image,$chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
412
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
413
	}
414
 
415
 
416
	public function recompresserImageSurDisqueEnPreservantMeta($chemin_fichier, $compression = 100) {
417
 
605 aurelien 418
		/*$blob = file_get_contents($chemin_fichier);
591 aurelien 419
 
420
		$image_a_compresser = new Imagick();
421
		$image_a_compresser->readImageBlob($blob, $chemin_fichier);
422
		$image_a_compresser->setformat("jpeg");
423
		$image_a_compresser->setImageCompression(imagick::COMPRESSION_JPEG);
424
		$image_a_compresser->setCompressionQuality($compression);
425
		$image_a_compresser->writeImage($chemin_fichier);
426
		$image_a_compresser->destroy();
427
 
605 aurelien 428
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);*/
591 aurelien 429
	}
430
 
431
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
432
 
433
		$image_blanche = imagecreatetruecolor($cote, $cote);
434
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
435
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
436
 
437
		return $image_blanche;
438
	}
439
 
440
	public function detruireImageEnMemoire($image) {
441
		imagedestroy($image);
442
	}
443
 
444
	public function detruireImageSurDisque($id) {
621 aurelien 445
 
591 aurelien 446
		$formats = $this->getFormats();
447
 
448
		// on detruit aussi l'image originale
449
		$formats[] = 'O';
450
 
621 aurelien 451
		$destruction_formats_fichier = false;
452
 
591 aurelien 453
		// destructions de chacuns des formats définis
454
		foreach($formats as $format) {
621 aurelien 455
 
591 aurelien 456
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
457
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
621 aurelien 458
 
459
			if(file_exists($dossier_format.'/'.$nom_fichier)) {
460
				$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
461
			} else {
462
				$destruction_formats_fichier = true;
463
			}
591 aurelien 464
		}
621 aurelien 465
 
466
		return $destruction_formats_fichier;
591 aurelien 467
	}
468
}
469
?>