Subversion Repositories eFlore/Applications.cel

<?php
Class ImageRecreation extends DBAccessor {
        
        private $droits = 0777;
        private $formats = array('CRX2S','CXS','CS','S','M','L','XL','X2L','X3L');

        public function ImageRecreation($config) {

                $this->config=$config;
        }
        
        public function getRessource() {
                return $this->getElement(array());
        }
        
        public function getElement($param) {
                
                ini_set ('max_execution_time',0);
                $this->itererRecursivement($this->config['cel_db']['chemin_images']);
        }
        
        public function itererRecursivement($dossier, $formats = null) {
        
                if($formats == null) {
                        $formats = $this->getFormats();         
                }
                
                // 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, $formats);
                                
                        // creation de miniatures pour chacuns des formats définis
                                foreach($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);
                }
        }
}
?>