Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 620 → Rev 621

/trunk/jrest/lib/ImageRecreation.php
New file
0,0 → 1,469
<?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 extractionSelonDate() {
 
$DB=$this->connectDB($this->config,'cel_db');
$requete_selection_diff = 'SELECT * FROM cel_images WHERE ci_meta_date_ajout >= "2011-02-23"';
$diff_image =& $DB->query($query_ordre);
if (PEAR::isError($diff_imag))
{
$erreur = 'ERROR' ;
die($diff_image->getMessage());
}
while ($row =& $diff_image->fetchrow(DB_FETCHMODE_ASSOC)) {
$id = $row['ci_id_image'];
$dossier = $this->obtenirDossierPourFormat($id,'L');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'L');
$chemin_complet = $dossier.'/'.$nom_fichier;
$chemin_stockage_fichier = '/home/telabotap/www/sites/eflore/projets/cel_sauvegarde/'.str_replace(' ','_',$row['ci_nom_original']);
copy($chemin_complet,$chemin_stockage_fichier);
}
}*/
public function stockerFichierEtCreerMiniatures($fichier, $id) {
$chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O');
$nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O');
$chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier;
if(rename($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';
$destruction_formats_fichier = false;
// destructions de chacuns des formats définis
foreach($formats as $format) {
$dossier_format = $this->obtenirDossierPourFormat($id, $format);
$nom_fichier = $this->convertirIdBddVersNomFichier($id, $format);
if(file_exists($dossier_format.'/'.$nom_fichier)) {
$destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier);
} else {
$destruction_formats_fichier = true;
}
}
return $destruction_formats_fichier;
}
}
?>