Subversion Repositories eFlore/Applications.cel

Rev

Rev 605 | Rev 632 | Go to most recent revision | Details | Compare with Previous | 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 
?>