WebSVN – Sites.obs-saisons.fr – Diff – /trunk/applications/jrest/services/OdsImageEspece.php


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

Rev 262	Rev 289
1	`<?php`	1	`<?php`
2		2
3	`class OdsImageEspece extends JrestService {`	3	`class OdsImageEspece extends JRestService {`
4		4
5	`private $droits = 0755;`	5	`private $droits = 0755;`
6	`const PREFIXE = 'get';`	6	`const PREFIXE = 'get';`
7		7
8	`public function OdsImageEspece($config) {`	8	`public function OdsImageEspece($config) {`
9		-
10	`$this->config=$config;`	9	`$this->config=$config;`
11	`}`	10	`}`
12		11
13	`/**`	12	`/**`
14	`* Méthode appelée avec une requête de type GET.`	13	`* Méthode appelée avec une requête de type GET.`
15	`*`	14	`*`
16	`*/`	15	`*/`
17	`function getElement($param = array()) {`	16	`function getElement($param = array()) {`
18		17
19	`$type = $param[0];`	18	`$type = $param[0];`
20		19
21	`if ($type == '*' \|\| is_numeric($type)) {`	20	`if ($type == '*' \|\| is_numeric($type)) {`
22	`$info = $this->getElementParDefaut($param);`	21	`$info = $this->getElementParDefaut($param);`
23	`} else {`	22	`} else {`
24	`$methode = self::PREFIXE.$type;`	23	`$methode = self::PREFIXE.$type;`
25	`if (method_exists($this, $methode)) {`	24	`if (method_exists($this, $methode)) {`
26	`array_shift($param);`	25	`array_shift($param);`
27	`$info = $this->$methode($param);`	26	`$info = $this->$methode($param);`
28	`} else {`	27	`} else {`
29	`$this->messages[] = "Le type d'information demandé '$type' n'est pas disponible.";`	28	`$this->messages[] = "Le type d'information demandé '$type' n'est pas disponible.";`
30	`}`	29	`}`
31	`}`	30	`}`
32		31
33	`// Envoi sur la sortie standard`	32	`// Envoi sur la sortie standard`
34	`echo 'OK';`	33	`echo 'OK';`
35	`}`	34	`}`
-		35
-		36	`/**`
-		37	`*`
-		38	`* Méthode appelée avec une requête de type POST.`
-		39	`*/`
-		40	`public function createElement($params) {`
-		41	`// fonction devant uniquement être appelée depuis le serveur`
-		42	`// lui-même, cad par l'application de saisie`
-		43	`$controle = new ControleUtilisateur($this->config);`
-		44	`$controle->controleAppelIpAutorisee();`
-		45
-		46	`$chemin_temp = $params['chemin'];`
-		47	`$nom_espece = $params['nom_fichier'];`
-		48	`$credits = $params['credits'];`
-		49
-		50	`$chemin_image_final = $this->stockerFichierOriginal($nom_espece, $chemin_temp);`
-		51	`$chemin_credits = $this->stockerCredits($nom_espece, $credits);`
-		52
-		53	`$this->creerMiniatures($nom_espece.'.jpg', $chemin_image_final);`
-		54
-		55	`echo json_encode('ok');`
-		56	`}`
-		57
-		58	`private function stockerFichierOriginal($nom_espece, $chemin_temp) {`
-		59	`$dossier = $this->config['appli']['chemin_stockage_images_especes'];`
-		60	`$chemin_dest = $dossier.'/'.$nom_espece.'.jpg';`
-		61	`copy($chemin_temp, $chemin_dest);`
-		62
-		63	`return $chemin_dest;`
-		64	`}`
-		65
-		66	`private function stockerCredits($nom_espece, $credits) {`
-		67	`$dossier = $this->config['appli']['chemin_stockage_images_especes'];`
-		68	`$chemin_dest = $dossier.'/'.$nom_espece.'.txt';`
-		69	`file_put_contents($chemin_dest, $credits);`
-		70	`}`
-		71
-		72	`public function creerMiniatures($nom_fichier, $chemin) {`
-		73	`$formats = array('CXS','XS','S','M');`
-		74	`$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin);`
-		75
-		76	`// creation de miniatures pour chacuns des formats définis`
-		77	`foreach($formats as $format) {`
-		78	`$this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);`
-		79	`}`
-		80	`}`
36		81
37	`public function getRecreationMiniatures() {`	82	`public function getRecreationMiniatures() {`
38		83
39	`$dossier = $this->config['appli']['chemin_stockage_images_especes'];`	84	`$dossier = $this->config['appli']['chemin_stockage_images_especes'];`
40		85
41	`$formats = array('CXS','XS','S','M');`	86	`$formats = array('CXS','XS','S','M');`
42		87
43	`$dossiers_a_exclure = array();`	88	`$dossiers_a_exclure = array();`
44		89
45	`foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {`	90	`foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {`
46		91
47	`if($fichier_ou_dossier->isDot() \|\| $fichier_ou_dossier->isDir()) {`	92	`if($fichier_ou_dossier->isDot() \|\| $fichier_ou_dossier->isDir()) {`
48	`continue;`	93	`continue;`
49	`}`	94	`}`
50		95
51	`if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {`	96	`if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {`
52	`continue;`	97	`continue;`
53	`}`	98	`}`
54		99
55	`$extension = pathinfo($fichier_ou_dossier->getPathname(),PATHINFO_EXTENSION);`	100	`$extension = pathinfo($fichier_ou_dossier->getPathname(),PATHINFO_EXTENSION);`
56	`if($extension == 'txt') {`	101	`if($extension == 'txt') {`
57	`continue;`	102	`continue;`
58	`}`	103	`}`
59		104
60	`$nom_fichier = $fichier_ou_dossier->getFilename();`	105	`$nom_fichier = $fichier_ou_dossier->getFilename();`
61		106
62	`$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());`	107	`$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());`
63		108
64	`// creation de miniatures pour chacuns des formats définis`	109	`// creation de miniatures pour chacuns des formats définis`
65	`foreach($formats as $format) {`	110	`foreach($formats as $format) {`
66	`$this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);`	111	`$this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);`
67	`}`	112	`}`
68	`}`	113	`}`
69	`}`	114	`}`
70		115
71	`public function creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier ,$infos_image_originale, $format = 'O') {`	116	`public function creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier ,$infos_image_originale, $format = 'O') {`
72		117
73	`if($format == 'O') {`	118	`if($format == 'O') {`
74	`// format original : rien à faire`	119	`// format original : rien à faire`
75	`$image_redimensionnee = $infos_image_originale['image'];`	120	`$image_redimensionnee = $infos_image_originale['image'];`
76		121
77	`} else {`	122	`} else {`
78	`// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc`	123	`// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc`
79	`if($this->estUnFormatCarre($format)) {`	124	`if($this->estUnFormatCarre($format)) {`
80	`$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);`	125	`$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format);`
81		126
82	`} else {`	127	`} else {`
83	`// la minature est une image redimensionnée en gardant son ratio`	128	`// la minature est une image redimensionnée en gardant son ratio`
84	`$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);`	129	`$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format);`
85	`}`	130	`}`
86	`}`	131	`}`
87		132
88	`$taux_compression = 100;`	133	`$taux_compression = 100;`
89	`if($format == 'O') {`	134	`if($format == 'O') {`
90	`$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);`	135	`$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);`
91	`}`	136	`}`
92	`$this->ecrireImageSurDisque($image_redimensionnee, $nom_fichier, $format, $taux_compression);`	137	`$this->ecrireImageSurDisque($image_redimensionnee, $nom_fichier, $format, $taux_compression);`
93		138
94	`return true;`	139	`return true;`
95	`}`	140	`}`
96		141
97	`public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {`	142	`public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {`
98		143
99	`$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);`	144	`$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);`
100		145
101	`imagecopyresampled($image_redimensionnee,`	146	`imagecopyresampled($image_redimensionnee,`
102	`$infos_image_originale['image'],`	147	`$infos_image_originale['image'],`
103	`0, 0,`	148	`0, 0,`
104	`$debut_largeur_a_copier,`	149	`0,`
105	`$debut_hauteur_a_copier,`	150	`0,`
106	`$largeur_redimension,`	151	`$largeur_redimension,`
107	`$hauteur_redimension,`	152	`$hauteur_redimension,`
108	`$infos_image_originale['largeur'],`	153	`$infos_image_originale['largeur'],`
109	`$infos_image_originale['hauteur']`	154	`$infos_image_originale['hauteur']`
110	`);`	155	`);`
111		156
112	`return $image_redimensionnee;`	157	`return $image_redimensionnee;`
113	`}`	158	`}`
114		159
115	`public function creerMiniature($informations_images, $format) {`	160	`public function creerMiniature($informations_images, $format) {`
116		161
117	`$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);`	162	`$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);`
118		163
119	`$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);`	164	`$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);`
120	`$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);`	165	`$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);`
121		166
122	`return $image_redimensionnee;`	167	`return $image_redimensionnee;`
123	`}`	168	`}`
124		169
125	`public function creerMiniatureCarree($informations_images, $format) {`	170	`public function creerMiniatureCarree($informations_images, $format) {`
126		171
127	`$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);`	172	`$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);`
128	`$cote_carre = $taille_reference_pour_format['largeur'];`	173	`$cote_carre = $taille_reference_pour_format['largeur'];`
129		174
130	`$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_images, $format);`	175	`$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_images, $format);`
131	`$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);`	176	`$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);`
132		177
133	`if($this->estPaysage($informations_images)) {`	178	`if($this->estPaysage($informations_images)) {`
134	`$debut_largeur_a_copier = 0 ;`	179	`$debut_largeur_a_copier = 0 ;`
135	`$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;`	180	`$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;`
136	`} else {`	181	`} else {`
137	`$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;`	182	`$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;`
138	`$debut_hauteur_a_copier = 0 ;`	183	`$debut_hauteur_a_copier = 0 ;`
139	`}`	184	`}`
140		185
141	`$image_carre_cible = $this->renvoyerEtCreerImageCarreeSelonFormat($cote_carre);`	186	`$image_carre_cible = $this->renvoyerEtCreerImageCarreeSelonFormat($cote_carre);`
142		187
143	`imagecopy($image_carre_cible, $image_redimensionnee_avec_rapport,`	188	`imagecopy($image_carre_cible, $image_redimensionnee_avec_rapport,`
144	`$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,`	189	`$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,`
145	`$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']`	190	`$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']`
146	`);`	191	`);`
147		192
148	`return $image_carre_cible;`	193	`return $image_carre_cible;`
149	`}`	194	`}`
150		195
151	`public function obtenirImageEtInfosPourChemin($chemin_fichier) {`	196	`public function obtenirImageEtInfosPourChemin($chemin_fichier) {`
152		197
153	`$image_et_infos = array();`	198	`$image_et_infos = array();`
154		199
155	`list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);`	200	`list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);`
156	`$image_et_infos['poids_octets'] = filesize($chemin_fichier);`	201	`$image_et_infos['poids_octets'] = filesize($chemin_fichier);`
157	`$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);`	202	`$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);`
158		203
159	`return $image_et_infos;`	204	`return $image_et_infos;`
160	`}`	205	`}`
161		206
162	`public function obtenirDimensionsPourFormat($format) {`	207	`public function obtenirDimensionsPourFormat($format) {`
163		208
164	`$dimensions = array('largeur' => 0, 'hauteur' => 0);`	209	`$dimensions = array('largeur' => 0, 'hauteur' => 0);`
165		210
166	`if(isset($this->config['appli']['format_'.$format])) {`	211	`if(isset($this->config['appli']['format_'.$format])) {`
167		212
168	`$format_largeur_hauteur = explode('_', $this->config['appli']['format_'.$format]);`	213	`$format_largeur_hauteur = explode('_', $this->config['appli']['format_'.$format]);`
169		214
170	`$dimensions['largeur'] = $format_largeur_hauteur[0];`	215	`$dimensions['largeur'] = $format_largeur_hauteur[0];`
171	`$dimensions['hauteur'] = $format_largeur_hauteur[1];`	216	`$dimensions['hauteur'] = $format_largeur_hauteur[1];`
172	`}`	217	`}`
173		218
174	`return $dimensions;`	219	`return $dimensions;`
175		220
176	`}`	221	`}`
177		222
178	`public function calculerTailleImage($informations_images, $taille_max) {`	223	`public function calculerTailleImage($informations_images, $taille_max) {`
179		224
180	`$HL_redimension = array();`	225	`$HL_redimension = array();`
181		226
182	`if($this->estPaysage($informations_images)) {`	227	`if($this->estPaysage($informations_images)) {`
183		228
184	`$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;`	229	`$rapport = $informations_images['hauteur']/$informations_images['largeur'] ;`
185	`$HL_redimension['largeur'] = round($taille_max) ;`	230	`$HL_redimension['largeur'] = round($taille_max) ;`
186	`$HL_redimension['hauteur'] = round($taille_max*$rapport) ;`	231	`$HL_redimension['hauteur'] = round($taille_max*$rapport) ;`
187		232
188	`} else {`	233	`} else {`
189	`$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;`	234	`$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;`
190	`$HL_redimension['hauteur'] = round($taille_max) ;`	235	`$HL_redimension['hauteur'] = round($taille_max) ;`
191	`$HL_redimension['largeur'] = round($taille_max*$rapport) ;`	236	`$HL_redimension['largeur'] = round($taille_max*$rapport) ;`
192	`}`	237	`}`
193		238
194	`return $HL_redimension;`	239	`return $HL_redimension;`
195	`}`	240	`}`
196		241
197	`public function estUnFormatCarre($format) {`	242	`public function estUnFormatCarre($format) {`
198		243
199	`return (strpos($format,'C') === 0);`	244	`return (strpos($format,'C') === 0);`
200	`}`	245	`}`
201		246
202	`public function estPaysage($informations_images) {`	247	`public function estPaysage($informations_images) {`
203	`return $informations_images['largeur'] > $informations_images['hauteur'];`	248	`return $informations_images['largeur'] > $informations_images['hauteur'];`
204	`}`	249	`}`
205		250
206	`public function estPortait($informations_images) {`	251	`public function estPortait($informations_images) {`
207	`return $informations_images['largeur'] < $informations_images['hauteur'];`	252	`return $informations_images['largeur'] < $informations_images['hauteur'];`
208	`}`	253	`}`
209		254
210	`public function renvoyerTauxCompressionPourPoids($poids_octets) {`	255	`public function renvoyerTauxCompressionPourPoids($poids_octets) {`
211		256
212	`$poids_max_octets = $this->config['appli']['taille_max'];`	257	`$poids_max_octets = $this->config['appli']['taille_max'];`
213		258
214	`$ratio_compression = 100 ;`	259	`$ratio_compression = 100 ;`
215		260
216	`if($poids_octets >= $poids_max_octets) {`	261	`if($poids_octets >= $poids_max_octets) {`
217	`$ratio_compression = 85 ;`	262	`$ratio_compression = 85 ;`
218	`}`	263	`}`
219		264
220	`return $ratio_compression;`	265	`return $ratio_compression;`
221	`}`	266	`}`
222		267
223	`public function ecrireImageSurDisque($image, $nom_fichier, $format, $compression) {`	268	`public function ecrireImageSurDisque($image, $nom_fichier, $format, $compression) {`
224		269
225	`umask(0);`	270	`umask(0);`
226		271
227	`$chemin_sur_serveur_final = $this->config['appli']['chemin_stockage_images_especes'].'/'.$format;`	272	`$chemin_sur_serveur_final = $this->config['appli']['chemin_stockage_images_especes'].'/'.$format;`
228		273
229	`if(!is_dir($chemin_sur_serveur_final)) {`	274	`if(!is_dir($chemin_sur_serveur_final)) {`
230	`mkdir($chemin_sur_serveur_final,$this->droits);`	275	`mkdir($chemin_sur_serveur_final,$this->droits);`
231	`}`	276	`}`
232		277
233	`if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {`	278	`if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {`
234	`unlink($chemin_sur_serveur_final.'/'.$nom_fichier);`	279	`unlink($chemin_sur_serveur_final.'/'.$nom_fichier);`
235	`}`	280	`}`
236		281
237	`imagejpeg($image, $chemin_sur_serveur_final.'/'.$nom_fichier);`	282	`imagejpeg($image, $chemin_sur_serveur_final.'/'.$nom_fichier);`
238	`chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);`	283	`chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);`
239		284
240	`}`	285	`}`
241		286
242	`public function renvoyerEtCreerImageCarreeSelonFormat($cote) {`	287	`public function renvoyerEtCreerImageCarreeSelonFormat($cote) {`
243		288
244	`$r = $g = $b = 255;`	289	`$r = $g = $b = 255;`
245		290
246	`if(isset($this->config['appli']['couleur_fond_carre'])) {`	291	`if(isset($this->config['appli']['couleur_fond_carre'])) {`
247	`$rgb = $this->config['appli']['couleur_fond_carre'];`	292	`$rgb = $this->config['appli']['couleur_fond_carre'];`
248		293
249	`$r = base_convert(substr($rgb,0,2), 16, 10);`	294	`$r = base_convert(substr($rgb,0,2), 16, 10);`
250	`$g = base_convert(substr($rgb,2,2), 16, 10);`	295	`$g = base_convert(substr($rgb,2,2), 16, 10);`
251	`$b = base_convert(substr($rgb,4,2), 16, 10);`	296	`$b = base_convert(substr($rgb,4,2), 16, 10);`
252	`}`	297	`}`
253		298
254	`$image_couleur = imagecreatetruecolor($cote, $cote);`	299	`$image_couleur = imagecreatetruecolor($cote, $cote);`
255	`$couleur = imagecolorallocate($image_couleur, $r, $g, $b);`	300	`$couleur = imagecolorallocate($image_couleur, $r, $g, $b);`
256	`imagefilledrectangle($image_couleur, 0, 0, $cote, $cote, $couleur);`	301	`imagefilledrectangle($image_couleur, 0, 0, $cote, $cote, $couleur);`
257		302
258	`return $image_couleur;`	303	`return $image_couleur;`
259	`}`	304	`}`
260		305
261	`public function detruireImageEnMemoire($image) {`	306	`public function detruireImageEnMemoire($image) {`
262	`imagedestroy($image);`	307	`imagedestroy($image);`
263	`}`	308	`}`
264	`}`	309	`}`
265	`?>`	310	`?>`

Subversion Repositories Sites.obs-saisons.fr

(root)/trunk/applications/jrest/services/OdsImageEspece.php – Rev 262 → 289