Subversion Repositories eFlore/Applications.cel

<?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);

		}

	}

}

?>