Subversion Repositories Sites.obs-saisons.fr

<?php

class OdsImageEspece extends JRestService {
        
        private $droits = 0755;
        const PREFIXE = 'get';

        public function OdsImageEspece($config) {
                $this->config=$config;
        }
        
        /**
     * Méthode appelée avec une requête de type GET.
     *
     */
    function getElement($param = array()) {
        
        $type = $param[0];
                
        if ($type == '*' || is_numeric($type)) {
            $info = $this->getElementParDefaut($param);
        } else {
            $methode = self::PREFIXE.$type;
            if (method_exists($this, $methode)) {
                array_shift($param);
                $info = $this->$methode($param);
            } else {
                $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible.";
            }
        }
       
        // Envoi sur la sortie standard
        echo 'OK';
    }
    
    /**
     * 
     * Méthode appelée avec une requête de type POST.
     */
    public function createElement($params) {  
                // fonction devant uniquement être appelée depuis le serveur
        // lui-même, cad par l'application de saisie
        $controle = new ControleUtilisateur($this->config);
        $controle->controleAppelIpAutorisee();
        
        $chemin_temp = $params['chemin'];
        $nom_espece = $params['nom_fichier'];
        $credits = $params['credits'];
        
        $chemin_image_final = $this->stockerFichierOriginal($nom_espece, $chemin_temp);
        $chemin_credits = $this->stockerCredits($nom_espece, $credits);
        
        $this->creerMiniatures($nom_espece.'.jpg', $chemin_image_final);
        
        echo json_encode('ok');
    }
    
    private function stockerFichierOriginal($nom_espece, $chemin_temp) {
        $dossier = $this->config['appli']['chemin_stockage_images_especes'];
        $chemin_dest = $dossier.'/'.$nom_espece.'.jpg';
        copy($chemin_temp, $chemin_dest);
        
        return $chemin_dest;
    }
    
        private function stockerCredits($nom_espece, $credits) {
                $dossier = $this->config['appli']['chemin_stockage_images_especes'];
                $chemin_dest = $dossier.'/'.$nom_espece.'.txt';
                file_put_contents($chemin_dest, $credits);
        }
        
        public function creerMiniatures($nom_fichier, $chemin) {
                $formats = array('CXS','XS','S','M');
                $infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin);
                
                // creation de miniatures pour chacuns des formats définis
                foreach($formats as $format) {
                        $this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);
                }
        }
        
        public function getRecreationMiniatures() {
                
                $dossier = $this->config['appli']['chemin_stockage_images_especes'];
        
                $formats = array('CXS','XS','S','M');
                
                $dossiers_a_exclure = array();
                
                foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
                        
                        if($fichier_ou_dossier->isDot() || $fichier_ou_dossier->isDir()) {
                                continue;
                        }
                        
                        if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
                                continue;
                        }

                        $extension = pathinfo($fichier_ou_dossier->getPathname(),PATHINFO_EXTENSION);
                        if($extension == 'txt') {
                                continue;
                        }
                                
                    $nom_fichier = $fichier_ou_dossier->getFilename();
                                                                
                        $infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
                                
                    // creation de miniatures pour chacuns des formats définis
                        foreach($formats as $format) {
                                $this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);
                        }
                }
        }
                        
        public function creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier ,$infos_image_originale, $format = 'O') {
                
                if($format == 'O') {            
                        // format original : rien à faire
                        $image_redimensionnee = $infos_image_originale['image'];
                        
                } else {
                        // le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
                        if($this->estUnFormatCarre($format)) {
                                $image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);                                                                                                           
                                                        
                        } else {
                                // la minature est une image redimensionnée en gardant son ratio
                                $image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);                                                                                                                 
                        }
                }

                $taux_compression = 100;
                if($format == 'O') {
                        $taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
                }
                $this->ecrireImageSurDisque($image_redimensionnee, $nom_fichier, $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_images, $format) {
                
                $taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
                $cote_carre = $taille_reference_pour_format['largeur'];
                
                $image_redimensionnee_avec_rapport = $this->creerMiniature($informations_images, $format);
                $taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
                
                if($this->estPaysage($informations_images)) {                           
                                $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_cible = $this->renvoyerEtCreerImageCarreeSelonFormat($cote_carre);
                
                imagecopy($image_carre_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_cible;
        }
        
        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['appli']['format_'.$format])) {
                        
                        $format_largeur_hauteur = explode('_', $this->config['appli']['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 estUnFormatCarre($format) {
                
                return (strpos($format,'C') === 0);             
        }
        
        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['appli']['taille_max'];
                
                $ratio_compression = 100 ;
        
            if($poids_octets >= $poids_max_octets) {
              $ratio_compression = 85 ;
            }
            
            return $ratio_compression;
        }
        
        public function ecrireImageSurDisque($image, $nom_fichier, $format, $compression) {
                
                umask(0);
                
                $chemin_sur_serveur_final = $this->config['appli']['chemin_stockage_images_especes'].'/'.$format;
                
                if(!is_dir($chemin_sur_serveur_final)) {
                        mkdir($chemin_sur_serveur_final,$this->droits);
                }
                
                if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
                        unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
                }
                
                imagejpeg($image, $chemin_sur_serveur_final.'/'.$nom_fichier);
                chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);

        }
        
        public function renvoyerEtCreerImageCarreeSelonFormat($cote) {
                
                $r = $g = $b = 255;
                
                if(isset($this->config['appli']['couleur_fond_carre'])) {
                        $rgb = $this->config['appli']['couleur_fond_carre'];
                        
                        $r = base_convert(substr($rgb,0,2), 16, 10);
                        $g = base_convert(substr($rgb,2,2), 16, 10);
                        $b = base_convert(substr($rgb,4,2), 16, 10);
                }
                
                $image_couleur = imagecreatetruecolor($cote, $cote);            
                $couleur = imagecolorallocate($image_couleur, $r, $g, $b);
                imagefilledrectangle($image_couleur, 0, 0, $cote, $cote, $couleur);
                
                return $image_couleur;
        }
        
        public function detruireImageEnMemoire($image) {                
                imagedestroy($image);
        }
}
?>