WebSVN – eFlore/Applications.cel – Diff – /trunk/jrest/services/ImageRecreation.php


<?php
Class ImageRecreation extends DBAccessor {
	
	private $droits = 0755;
	private $formats = array('CRX2S','CXS','CS','S','M','L','XL','X2L','X3L');
 
	public function ImageRecreation($config) {
 
		$this->config=$config;
	}
	
	public function getRessource() {
 
		
	}
	
	public function getElement($param) {
 
 
		
	}
	
	public function recreerMiniaturesRecursivement() {
 
		$this->itererRecursivement($this->config['cel_db']['chemin_images']);
 
	} 
	
	public function itererRecursivement($dossier) {
		
		// on ne parse que le dossier des images originales
		$dossiers_a_exclure = $this->getFormats();
				
		foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
							
			if($fichier_ou_dossier->isDot()) {
				continue;
			}
			
			if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
				continue;
			}
			
		    if($fichier_ou_dossier->isDir()) {
		    	
		    	$profondeur_dossier_fils = $profondeur + 1;
	    		$this->itererRecursivement($fichier_ou_dossier->getPathname(), $profondeur_dossier_fils);
	    		
		    } else {	
		    	    	
		    	$nom_fichier = $fichier_ou_dossier->getFilename();
		    	
				$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
		    	$id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats);
				
		    	// creation de miniatures pour chacuns des formats définis
				foreach($this->formats as $format) {
					
					$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format);
				}
		    }
		}
	}
			
	public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') {
		
		if($format == 'O') {		
			// format original : rien à faire
			$image_redimensionnee = $infos_image_originale['image'];
			
		} else {
			 if($this->estUnFormatRogne($format)) {
				// la minature est une image redimensionnée rognée au centre
				$image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format); 														
			} else if($this->estUnFormatCarre($format)) {
				// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);				
			} else {
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);			
			}
		}
				
		$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
		$this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression);
				
		return true;
	}
	
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
		
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
		
		imagecopyresampled($image_redimensionnee, 
						$infos_image_originale['image'], 
						0, 0, 
						0, 0, 
						$largeur_redimension, 
						$hauteur_redimension, 
						$infos_image_originale['largeur'], 
						$infos_image_originale['hauteur']
		);
		
		return $image_redimensionnee;
	}
	
	public function creerMiniature($informations_images, $format) {
				
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
		
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
		
		return $image_redimensionnee;
	}
	
	public function creerMiniatureCarree($informations_image, $format) {
		
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
		$cote_carre = $taille_reference_pour_format['largeur'];
		
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format);
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']);
		
		if($this->estPaysage($informations_image)) {				
				$debut_largeur_a_copier = 0 ;
				$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;	
		} else {
				$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
				$debut_hauteur_a_copier = 0 ;	
		}
		
		$image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre);
		
		imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport,
				$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
				$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
		);
 
		return $image_carre_blanc_cible;
	}
	
	public function creerMiniatureCarreeRognee($informations_image, $format) {
		
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
		$cote_carre = $taille_reference_pour_format['largeur'];
		$cote_carre_non_redimensionne = 0;
		
		if($this->estPaysage($informations_image)) {	
				$cote_carre_non_redimensionne = $informations_image['hauteur'];		
				$debut_largeur_a_copier = ($informations_image['hauteur'] - $informations_image['hauteur'])/2 ;
				$debut_hauteur_a_copier = 0;
				$nb_pixels_largeur_a_copier = $informations_image['hauteur'];
				$nb_pixels_hauteur_a_copier = $informations_image['hauteur'];
		} else {
				$cote_carre_non_redimensionne = $informations_image['largeur'];
				$debut_largeur_a_copier = 0 ;
				$debut_hauteur_a_copier = ($informations_image['largeur'] - $informations_image['largeur'])/2;
				$nb_pixels_largeur_a_copier = $informations_image['largeur'];
				$nb_pixels_hauteur_a_copier = $informations_image['largeur'];
		}
		
		$image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne);
		
		imagecopyresampled($image_carre_temporaire, 
						$informations_image['image'], 
						0, 0, 
						$debut_largeur_a_copier,
						$debut_hauteur_a_copier, 
						$cote_carre_non_redimensionne, 
						$cote_carre_non_redimensionne, 
						$nb_pixels_largeur_a_copier, 
						$nb_pixels_hauteur_a_copier
		);
		
		$image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre);
		
		imagecopyresampled($image_redimensionnee, 
						$image_carre_temporaire, 
						0, 0, 
						0, 0, 
						$cote_carre, 
						$cote_carre, 
						$cote_carre_non_redimensionne, 
						$cote_carre_non_redimensionne
		);
 
		return $image_redimensionnee;
	}
	
	public function stockerFichierUploadeEtCreerMiniatures($fichier, $id) {
		
		$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');	
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
	
		$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
		
		if(move_uploaded_file($fichier['tmp_name'],$chemin_fichier)) {
 
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
			
			if($taux_compression < 100) {
				$this->recompresserImageSurDisqueEnPreservantMeta($chemin_fichier, $taux_compression);
			}
				
			$infos_image_originale_stockee = $this->obtenirImageEtInfosPourChemin($chemin_fichier);
			
			$formats = $this->getFormats();
			
			// creation de miniatures pour chacuns des formats définis
			foreach($formats as $format) {
				$this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format);
			}
	
	  		return true ;
	  		
		} else {
			$erreur =  'ERROR : probleme durant le déplacement du fichier temporaire \n' ;
			$this->logger('CEL_bugs',$erreur);
  			return false ;
		}
	}
	
	public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) {
		
		$chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id,$format);
		
		if(!file_exists($chemin_sur_serveur_final))
		{
			if(mkdir($chemin_sur_serveur_final,$this->droits, true)) {
				chmod($chemin_sur_serveur_final,$this->droits);
			}
			else
			{
				$erreur =  'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ;
				echo $erreur;
				$this->logger('CEL_bugs',$erreur);
				return false;
			}
		}
		
		return $chemin_sur_serveur_final;
	}
	
	public function obtenirDossierPourFormat($id, $format) {
		
		$chemin_base = $this->config['cel_db']['chemin_images'];
	
		$chemin_sur_serveur = $chemin_base ;
	
		$id = sprintf('%09s', $id) ;
		$id = wordwrap($id, 3 , '_', true) ;
	
		$niveauDossier = split("_", $id) ;
	
		$dossierNiveau1 = $niveauDossier[0] ;
		$dossierNiveau2 = $niveauDossier[1] ;
		
		$chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format;
		
		return $chemin_sur_serveur_final;
	}
	
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
		
		$image_et_infos = array();
		
		list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);		
		$image_et_infos['poids_octets'] = filesize($chemin_fichier);
		$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
		
		return $image_et_infos;
	}
	
	public function obtenirDimensionsPourFormat($format) {
		
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
			
		if(isset($this->config['cel_db']['format_'.$format])) {
			
			$format_largeur_hauteur = split('_', $this->config['cel_db']['format_'.$format]);
			
			$dimensions['largeur'] = $format_largeur_hauteur[0];
			$dimensions['hauteur'] = $format_largeur_hauteur[1];
		}
		
		return $dimensions;
		
	}
	
	public function calculerTailleImage($informations_images, $taille_max) {
	
	        $HL_redimension = array();
	        
	        if($this->estPaysage($informations_images)) {
	        
		        $rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
		        $HL_redimension['largeur'] = round($taille_max) ;
		        $HL_redimension['hauteur'] = round($taille_max*$rapport) ;
		        
	        } else {
	        	$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
		        $HL_redimension['hauteur'] = round($taille_max) ;
		        $HL_redimension['largeur'] = round($taille_max*$rapport) ;
	        }
	        
	        return $HL_redimension;
	}
	
	public function getFormats() {
		return $this->formats;
	}
	
	public function estUnFormatCarre($format) {
		
		return (strpos($format,'C') === 0);		
	}
	
	public function estUnFormatRogne($format) {
 
		return (strpos($format,'R') === 1);		
	}
	
	public function estPaysage($informations_images) {
		return $informations_images['largeur'] > $informations_images['hauteur'];
	}
	
	public function estPortait($informations_images) {
		return $informations_images['largeur'] < $informations_images['hauteur'];
	}
	
	public function renvoyerTauxCompressionPourPoids($poids_octets) {
 
		$poids_max_octets = $this->config['cel_db']['taille_max'];
		
		$ratio_compression = 100 ;
		
	    if($poids_octets >= $poids_max_octets) {
	      $ratio_compression = 75 ;
	    }
	    
	    return $ratio_compression;
	}
	
	public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') {
		
			// creation du format original
		$id_avec_zeros = sprintf('%09s', $id) ;
		$id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ;
		
		$nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension;
		
		return $nom_fichier;
	}
	
	public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) {
		
		$nom_fichier_sans_extension = trim($nom_fichier, '.jpg');
		
		foreach($formats as $format) {
			$nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format);
		}
		
		$id_image = str_replace('_', '', $nom_fichier_sans_extension);
			
		// suppression des 0 devant
		$id_image += 0;
		
		return $id_image;
	}
	
	public function ecrireImageSurDisque($image, $id, $format, $compression = 100) {
		
		umask(0);
		
		$chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format);
		$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
		
		if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
		}
		
		// attention ceci ne preserve pas les metadonnées
		imagejpeg($image,$chemin_sur_serveur_final.'/'.$nom_fichier, $compression);
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);
	}
	
	
	public function recompresserImageSurDisqueEnPreservantMeta($chemin_fichier, $compression = 100) {
 
		/*$blob = file_get_contents($chemin_fichier);
			
		$image_a_compresser = new Imagick();
		$image_a_compresser->readImageBlob($blob, $chemin_fichier);
		$image_a_compresser->setformat("jpeg");
		$image_a_compresser->setImageCompression(imagick::COMPRESSION_JPEG); 
		$image_a_compresser->setCompressionQuality($compression);
		$image_a_compresser->writeImage($chemin_fichier);
		$image_a_compresser->destroy();	
		
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);*/
	}
	
	public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) {
		
		$image_blanche = imagecreatetruecolor($cote, $cote);		
		$blanc = imagecolorallocate($image_blanche, 255, 255, 255);
		imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc);
		
		return $image_blanche;
	}
	
	public function detruireImageEnMemoire($image) {		
		imagedestroy($image);
	}
	
	public function detruireImageSurDisque($id) {
		$formats = $this->getFormats();
		
		// on detruit aussi l'image originale
		$formats[] = 'O';
		
		// destructions de chacuns des formats définis
		foreach($formats as $format) {
			$dossier_format = $this->obtenirDossierPourFormat($id, $format);
			$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
			unlink($dossier_format.'/'.$nom_fichier);
		}
	}
}
?>

Subversion Repositories eFlore/Applications.cel

(root)/trunk/jrest/services/ImageRecreation.php @ 636 – Rev 591 → 605

Rev 591		Rev 605
1	`<?php`	1	`<?php`
2	`Class ImageRecreation extends DBAccessor {`	2	`Class ImageRecreation extends DBAccessor {`
3		3
4	`private $droits = 0777;`	4	`private $droits = 0755;`
5	`private $formats = array('CRX2S','CXS','CS','S','M','L','XL','X2L','X3L');`	5	`private $formats = array('CRX2S','CXS','CS','S','M','L','XL','X2L','X3L');`
6		6
7	`public function ImageRecreation($config) {`	7	`public function ImageRecreation($config) {`
8		8
9	`$this->config=$config;`	9	`$this->config=$config;`
10	`}`	10	`}`
11		11
12	`public function getRessource() {`	12	`public function getRessource() {`
13	`return $this->getElement(array());`	-
-		13
14	`}`	14	`}`
15		15
16	`public function getElement($param) {`	16	`public function getElement($param) {`
17		-
18	`ini_set ('max_execution_time',0);`	-
19	`$this->itererRecursivement($this->config['cel_db']['chemin_images']);`	17
20	`}`	18	`}`
-		19
-		20	`public function recreerMiniaturesRecursivement() {`
21		-
22	`public function itererRecursivement($dossier, $formats = null) {`	21	`$this->itererRecursivement($this->config['cel_db']['chemin_images']);`
23		-
24	`if($formats == null) {`	22	`}`
25	`$formats = $this->getFormats();`	23
26	`}`	24	`public function itererRecursivement($dossier) {`
27		25
28	`// on ne parse que le dossier des images originales`	26	`// on ne parse que le dossier des images originales`
29	`$dossiers_a_exclure = $this->getFormats();`	27	`$dossiers_a_exclure = $this->getFormats();`
30		28
31	`foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {`	29	`foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {`
32		30
33	`if($fichier_ou_dossier->isDot()) {`	31	`if($fichier_ou_dossier->isDot()) {`
34	`continue;`	32	`continue;`
35	`}`	33	`}`
36		34
37	`if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {`	35	`if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {`