Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

Ignore whitespace Rev 1155 → Rev 1156

/branches/v5.11-bananeraie/services/modules/0.1/chorodep/cartes/TaxonsCartes.php
New file
0,0 → 1,468
<?php
// declare(encoding='UTF-8');
/**
* Gère le sous-service Taxons de Cartes.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes
*
* @package eFlore/services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class TaxonsCartes {
 
private $parametres = array();
private $ressources = array();
 
const CODE_REFTAX_DEFAUT = 'bdtfx';
const TYPE_ID_DEFAUT = 'nn';
const CARTE_DEFAUT = 'france_02';
const FORMAT_DEFAUT = '587x550';
const VERSION_DEFAUT = '+';
const MIME_SVG = 'image/svg+xml';
const MIME_PNG = 'image/png';
const PRESENCE_CHOROLOGIE = '1';
 
private $config = array();
private $convertisseur = '';
private $cheminCartesBase = '';
private $formatsSupportes = array(self::MIME_SVG, self::MIME_PNG);
private $reftaxSupportes = array(self::CODE_REFTAX_DEFAUT);
private $UrlNavigation = null;
private $taxonsDemandes = array();
private $imgLargeur = 0;
private $imgHauteur = 0;
private $tableMeta = '';
private $tableOntologie = '';
private $tableChorodep = '';
private $metadonnees = '';
private $ontologies = '';
private $priorites = '';
private $version = '';
private $legende = array();
private $donnees = array();
 
 
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
$this->config = $conteneur->getParametre('Cartes');
$this->convertisseur = $this->config['convertisseur'];
$this->tableMeta = $conteneur->getParametre('bdd_table_meta');
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
$this->cheminCartesBase = $this->config['chemin'];
$cacheOptions = array('mise_en_cache' => $this->config['cache_miseEnCache'],
'stockage_chemin' => $this->config['cache_stockageChemin'],
'duree_de_vie' => $this->config['cache_dureeDeVie']);
$this->cache = $conteneur->getCacheSimple($cacheOptions);
}
 
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirValeurParDefautDesParametres();
$this->verifierParametres();
 
$resultat = $this->obtenirResultat();
 
return $resultat;
}
 
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['retour']) == false) {
$this->parametres['retour'] = self::MIME_SVG;
}
if (isset($this->parametres['retour.format']) == false) {
$this->parametres['retour.format'] = self::FORMAT_DEFAUT;
}
if (isset($this->parametres['version.projet']) == false) {
$this->parametres['version.projet'] = self::VERSION_DEFAUT;
}
}
 
private function verifierParametres() {
$erreurs = array();
 
if (isset($this->parametres['retour']) == false) {
$erreurs[] = "Le paramètre type de retour 'retour' est obligatoire.";
}
if ($this->verifierValeurParametreRetour() == false) {
$erreurs[] = "Le type de retour '{$this->parametres['retour']}' n'est pas supporté.";
}
if (isset($this->parametres['retour.format']) == false) {
$erreurs[] = "Le paramètre de format de retour 'retour.format' est obligatoire.";
}
if ($this->verifierValeurParametreFormat() == false) {
$erreurs[] = "Le type de format '{$this->parametres['retour.format']}' n'est pas supporté.".
"Veuillez indiquer un nombre entier correspondant à la largeur désirée pour la carte.";
}
if ($this->verifierValeurParametreVersionProjet() == false) {
$erreurs[] = "Le format de version.projet '{$this->parametres['version.projet']}' n'est pas supporté.".
"Veuillez indiquer le code '+' (=dernière version) ou une année sur 4 chiffres séparé d'un mois ".
"sur deux chiffres par un point. Ex. : 2012.01";
}
 
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function verifierValeurParametreRetour() {
return in_array($this->parametres['retour'], $this->formatsSupportes);
}
 
private function verifierValeurParametreFormat() {
if ($ok = preg_match('/^([0-9]+)$/', $this->parametres['retour.format'], $match)) {
$this->imgLargeur = $match[1];
} else if ($ok = preg_match('/^([0-9]+)x([0-9]+)$/', $this->parametres['retour.format'], $match)) {
$this->imgLargeur = $match[1];
$this->imgHauteur = $match[2];
}
return $ok;
}
private function verifierValeurParametreVersionProjet() {
$ok = (preg_match('/^(?:[+]|[0-9]{4}\.[0-9]{2})$/', $this->parametres['version.projet']) == 0) ? false : true;
return $ok;
}
 
private function obtenirResultat() {
$this->analyserIdentifiants();
$this->verifierIdentifiants();
 
$this->chargerMetadonnees();
$this->definirVersion();
$this->tableChorodep = 'chorodep_v'.str_replace('.', '_', $this->version);
$this->chargerOntologies();
$this->chargerLegende();
$this->chargerPrioritesLegende();
$this->chargerDonnees();
$svg = $this->genererSVG();
$img = ($this->parametres['retour'] == self::MIME_PNG) ? $this->convertirEnPNG($svg) : $svg;
 
$resultat = new ResultatService();
$resultat->corps = $img;
$resultat->mime = $this->parametres['retour'];
 
return $resultat;
}
 
private function analyserIdentifiants() {
$ids = $this->ressources[0];
if (preg_match('/^[0-9]+$/', $ids)) {
$this->taxonsDemandes[self::CODE_REFTAX_DEFAUT]['nn'][] = $ids;
} else {
// ceci contient potentiellement des formes ref_tax1.nn:1,2;ref_tax2.nt:3,4
$projetsListeEtNumNoms = explode(';', $ids);
if (count($projetsListeEtNumNoms) > 0) {
foreach ($projetsListeEtNumNoms as $projetEtNumNoms) {
$projetEtNumNoms = (strpos($projetEtNumNoms, ':')) ? $projetEtNumNoms : self::CODE_REFTAX_DEFAUT.'.nn:'.$projetEtNumNoms;
list($projetEtType, $numNoms) = explode(':', $projetEtNumNoms);
 
$projetEtType = (strpos($projetEtType, '.')) ? $projetEtType : self::CODE_REFTAX_DEFAUT.'.'.$projetEtType;
list($projet, $type) = explode('.', $projetEtType);
 
$this->taxonsDemandes[$projet][$type] = explode(',', $numNoms);
}
}
}
}
 
private function verifierIdentifiants() {
foreach (array_keys($this->taxonsDemandes) as $reftax) {
$ok = in_array($reftax, $this->reftaxSupportes);
if ($ok == false) {
$message = "Le reférentiel taxonomique '$reftax' n'est pas pris en compte par ce projet.";
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
}
 
private function chargerMetadonnees() {
$requete = 'SELECT * '.
"FROM {$this->tableMeta} ".
"ORDER BY date_creation DESC ";
$resultats = $this->Bdd->recupererTous($requete);
 
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les méta-données n'ont pu être chargée pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
 
$this->metadonnees = $resultats;
}
 
private function definirVersion() {
if ($this->parametres['version.projet'] == '+') {
$this->version = $this->metadonnees[0]['version'];
} else {
$this->version = $this->parametres['version.projet'];
}
}
 
private function chargerOntologies() {
$requete = 'SELECT * '.
"FROM {$this->tableOntologie} ";
$resultats = $this->Bdd->recupererTous($requete);
 
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les données de légende n'ont pu être chargées pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
 
foreach ($resultats as $ontologie) {
$this->ontologies[$ontologie['id']] = Commun::extraireComplementsOntologies($ontologie);
}
}
 
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE) {
$this->legende[$ontologie['code']] = $ontologie['legende'];
}
}
}
 
private function chargerPrioritesLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE && isset($ontologie['priorite'])) {
$this->priorites[$ontologie['code']] = $ontologie['priorite'];
}
}
}
 
private function chargerDonnees() {
$conditions = $this->getConditions();
$requete = 'SELECT * '.
"FROM {$this->tableChorodep} ".
(isset($conditions) ? 'WHERE '.implode(' AND ', $conditions) : '');
$resultat = $this->Bdd->recupererTous($requete);
$this->donnees = $resultat;
}
 
private function getConditions() {
$conditions = null;
if ($nnListe = $this->getListeNumNom()) {
$conditions[] = "num_nom IN ($nnListe) ";
}
if ($ntListe = $this->getListeNumTax()) {
$conditions[] = "num_tax IN ($ntListe) ";
}
return $conditions;
}
 
private function getListeNumNom() {
$nnListe = null;
$refTax = self::CODE_REFTAX_DEFAUT;
if (isset($this->taxonsDemandes[$refTax])) {
$nnProteges = array();
if (isset($this->taxonsDemandes[$refTax]['nn'])) {
foreach ($this->taxonsDemandes[$refTax]['nn'] as $nn) {
$nnProteges[] = $this->Bdd->proteger($nn);
}
$nnListe = implode(',', $nnProteges);
}
}
return $nnListe;
}
 
private function getListeNumTax() {
$ntListe = null;
$refTax = self::CODE_REFTAX_DEFAUT;
if (isset($this->taxonsDemandes[$refTax])) {
$ntProteges = array();
if (isset($this->taxonsDemandes[$refTax]['nt'])) {
foreach ($this->taxonsDemandes[$refTax]['nt'] as $nt) {
$ntProteges[] = $this->Bdd->proteger($nt);
}
$ntListe = implode(',', $ntProteges);
}
}
return $ntListe;
}
 
private function genererSVG() {
$fichierCarteSvg = $this->cheminCartesBase.self::CARTE_DEFAUT.'.svg';
if (file_exists($fichierCarteSvg) === false) {
$message = "Le fichier SVG servant de base à la carte est introuvable : $fichierCarteSvg";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
 
$dom = new DOMDocument('1.0', 'UTF-8');
$dom->validateOnParse = true;
$dom->load($fichierCarteSvg);
 
$racineElement = $dom->documentElement;
$racineElement->setAttribute('width', $this->imgLargeur);
if ($this->imgHauteur != 0) {
$racineElement->setAttribute('height', $this->imgHauteur);
}
 
$css = $this->creerCssCarte();
$styleElement = $dom->getElementsByTagName('style')->item(0);
$css = $styleElement->nodeValue.$css;
$txtCss = $dom->createCDATASection($css);
$styleElement->nodeValue = '';
$styleElement->appendChild($txtCss);
 
$titre = $this->creerTitre();
$titreCdata = $dom->createCDATASection($titre);
$titreElement = $dom->getElementsByTagName('title')->item(0);
$titreElement->nodeValue = '';
$titreElement->appendChild($titreCdata);
 
$taxonTitre = $this->creerTitreTaxon();
$taxonCdata = $dom->createCDATASection($taxonTitre);
$xpath = new DOMXPath($dom);
$taxonTitreEl = $xpath->query("//*[@id='titre-taxon']")->item(0);
$taxonTitreEl->nodeValue = '';
$taxonTitreEl->setAttribute('title', $taxonTitre);
$taxonTitreEl->appendChild($taxonCdata);
 
$svg = $dom->saveXML();
return $svg;
}
 
private function creerCssCarte() {
$css = '';
$this->getZonesPriorites();
$zonesCouleurs = $this->getZonesCouleurs();
foreach ($zonesCouleurs as $couleur => $zonesClasses) {
$classes = implode(', ', $zonesClasses);
$css .= "$classes{\nfill:$couleur;\n}\n";
}
return $css;
}
 
private function getZonesPriorites() {
$this->zones = array();
$zonesPrioritaires = array();
foreach ($this->donnees as $donnee) {
foreach ($donnee as $zoneId => $codeLegende) {
if (preg_match('/^[0-9][0-9ab]$/i', $zoneId)) {
if (array_key_exists($codeLegende, $this->priorites)) {
$priorite = $this->priorites[$codeLegende];
if (array_key_exists($zoneId, $zonesPrioritaires) == false) {
$zonesPrioritaires[$zoneId] = 0;
}
if ($priorite > $zonesPrioritaires[$zoneId]) {
$zonesPrioritaires[$zoneId] = $priorite;
$this->zones[$zoneId] = $codeLegende;
}
}
}
}
}
}
 
private function getZonesCouleurs() {
$zones = array();
ksort($this->zones);
foreach ($this->zones as $zoneId => $codeLegende) {
if (array_key_exists($codeLegende, $this->legende)) {
$couleur = $this->legende[$codeLegende];
$zones[$couleur][] = strtolower('.departement'.sprintf('%02s', $zoneId));
}
}
return $zones;
}
 
private function creerTitre() {
$titre = "Carte en cours d'élaboration";
if ($this->donnees != array()) {
$titre .= ' pour '.$this->creerTitreTaxon();
}
return $titre;
}
 
private function creerTitreTaxon() {
$titre = '';
$noms = array();
foreach ($this->donnees as $donnee) {
$noms[] = $donnee['nom_sci'];
}
$titre = implode(', ', $noms);
return $titre;
}
 
private function convertirEnPNG($svg) {
$png = null;
if (isset($this->convertisseur)) {
if ($this->convertisseur == 'imagick') {
if (extension_loaded('imagick')) {
$png = $this->convertirEnPNGAvecImageMagick($svg);
} else {
$message = "Impossible de générer l'image sur le serveur. Extension ImageMagick abscente.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
} else if ($this->convertisseur == 'rsvg') {
$png = Commun::convertirEnPNGAvecRsvg($this->getIdFichier(), $this->config['cache_stockageChemin'], $svg);
} else {
$message = "Le convertisseur indiqué '{$this->convertisseur}' ne fait pas parti de la liste ".
"des convertisseurs disponibles : imagick, rsvg.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
} else {
$message = "Veuillez indiquer le convertisseur de svg à utiliser pour le service.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
return $png;
}
 
private function convertirEnPNGAvecImageMagick($svg) {
$convertisseur = new Imagick();
$convertisseur->setBackgroundColor(new ImagickPixel('transparent'));
$convertisseur->readImageBlob($svg);
$convertisseur->setImageFormat('png32');
$convertisseur->resizeImage($this->imgLargeur, $this->imgHauteur, imagick::FILTER_LANCZOS, 0, true);
$png = $convertisseur->getImageBlob();
$convertisseur->clear();
$convertisseur->destroy();
return $png;
}
 
private function getIdFichier() {
$id = '';
foreach ($this->taxonsDemandes as $reftax => $ids) {
$id[] = $reftax;
foreach ($ids as $type => $vals) {
$id[] = $type;
$id[] = implode('-', $vals);
}
}
$id = implode('-', $id);
return $id;
}
 
public function getParametreTableau($cle) {
$tableau = array();
$parametre = $this->config[$cle];
if (empty($parametre) === false) {
$tableauPartiel = explode(',', $parametre);
$tableauPartiel = array_map('trim', $tableauPartiel);
foreach ($tableauPartiel as $champ) {
if (strpos($champ, '=') === false) {
$tableau[] = trim($champ);
} else {
list($cle, $val) = explode('=', $champ);
$tableau[trim($cle)] = trim($val);
}
}
}
return $tableau;
}
}
?>
/branches/v5.11-bananeraie/services/modules/0.1/chorodep/cartes/FranceCartes.php
New file
0,0 → 1,273
<?php
// declare(encoding='UTF-8');
/**
* Gère le sous-service Taxons de Cartes.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes
*
* @package eFlore/services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class FranceCartes {
 
private $parametres = array();
private $ressources = array();
protected $largeurOrig = 600;
protected $longeurOrig = 545;
protected $largeurDefaut = 600;
protected $largeurDemandee = 600;
protected $prefixe_id_zone = 'INSEE-D';
protected $options_cache = array();
const PRESENCE_CHOROLOGIE = '1';
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
$this->config = $conteneur->getParametre('Cartes');
$this->convertisseur = $this->config['convertisseur'];
$this->tableMeta = $conteneur->getParametre('bdd_table_meta');
$this->cheminCartesBase = $this->config['chemin'];
$this->options_cache = array('mise_en_cache' => $this->config['cache_miseEnCache'],
'stockage_chemin' => $this->config['cache_stockageChemin'],
'duree_de_vie' => $this->config['cache_dureeDeVie']);
}
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
$this->chargerMetadonnees();
$this->definirVersion();
$this->tableChorodep = 'chorodep_v'.str_replace('.', '_', $this->version);
if(isset($parametres['retour.format']) && is_numeric($parametres['retour.format'])) {
$this->largeurDemandee = intval($parametres['retour.format']);
}
if(count($ressources) == 0) {
$resultat = $this->getCarteTaxonsParZones();
} else if($ressources[0] == "legende") {
$cache = $this->getCache('global');
if($cache != null) {
$max = $cache['nb_taxons_max'];
} else {
$max = $this->getNbMaxTaxonsParZones();
}
$resultat = $this->getLegendeCarteTaxonsParZones($max);
}
return $resultat;
}
private function chargerMetadonnees() {
$requete = 'SELECT * '.
"FROM {$this->tableMeta} ".
"ORDER BY date_creation DESC ";
$resultats = $this->Bdd->recupererTous($requete);
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les méta-données n'ont pu être chargée pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
$this->metadonnees = $resultats;
}
private function definirVersion() {
$this->version = $this->metadonnees[0]['version'];
}
public function getLegendeCarteTaxonsParZones($nb_max) {
// TODO : mettre en config ou en ontologie ?
// mais ça fait encore un appel de plus aux ontologies
// qui sont déjà bien bien bien bien chargées
$this->couleurs_legende_globale = array("#808080", "#EFF8E1", "#F2E2C0", "#C9CC8D", "#C1E587", "#A0FF7D");
$couleurs = $this->couleurs_legende_globale;
$legende = array(
"seuil0" => array(
"code" => "",
"couleur" => $couleurs[0],
"css" => "",
"nom" => "Non renseignée",
"description" => "Zone géographique non renseignée."
)
);
array_shift($couleurs);
$borne_min = 0;
$borne_max = 500;
for($i = 1; $i <= 5; $i++) {
$borne_max = ($i == 5) ? $nb_max : $borne_max;
$legende["seuil".$i] = array(
"code" => "",
"couleur" => $couleurs[$i-1],
"css" => "",
"nom" => "de ".$borne_min." à ".$borne_max." taxons",
"description" => "de ".$borne_min." à ".$borne_max." taxons."
);
$borne_min = $borne_max + 1;
$borne_max = ($i == 5) ? $nb_max : ($i * 1200);
}
return $legende;
}
private function convertirLegendeVersCss($legende) {
$css = "";
foreach($legende as $cle => $item) {
if($item['css'] != '') {
$css .=
$item['css']." {"."\n".
" fill:".$item['couleur'].";"."\n".
"}"."\n\n";
}
}
return $css;
}
public function getCarteTaxonsParZones() {
$this->envoyerCacheSiExiste('global');
$taxonsParZones = $this->compterTaxonsParZones();
$legende = $this->getLegendeCarteTaxonsParZones($taxonsParZones['max']);
$infos_zones = array();
$max = 0;
foreach($taxonsParZones['nb_taxons_par_zones'] as $id_zone => $nb) {
$infos_zones[$id_zone] = "- ".$nb." taxons présents";
$legende[$this->getSeuil($nb)]['css'] .= $legende[$this->getSeuil($nb)]['css'] != "" ? ', ' : '' ;
$legende[$this->getSeuil($nb)]['css'] .= "#".$this->prefixe_id_zone.$id_zone;
$max = $max < $nb ? $nb : $max;
}
 
$this->style = $this->convertirLegendeVersCss($legende);
$svg = $this->assemblerSvg(
$this->calculerHauteur($this->largeurDemandee),
$this->largeurDemandee,
$this->style,
$infos_zones);
$this->sauverCache(array('style' => $this->style, 'infos_zones' => $infos_zones, 'nb_taxons_max' => $max), 'global');
$this->envoyerSvg($svg);
}
// Fonction bien pourrie pour renvoyer juste un max
// mais son résultat est mis en cache donc elle sera appelée environ
// une fois par an (et encore si on appelle la légende avant la carte)
public function getNbMaxTaxonsParZones() {
$taxonsParZones = $this->compterTaxonsParZones();
$max = 0;
foreach($taxonsParZones as $id_zone => $nb) {
$max = $max < $nb ? $nb : $max;
}
return $max;
}
public function getSeuil($nb_taxons) {
// TODO: factoriser les bornes avec la fonction qui gère la légende
$seuil = "";
if($nb_taxons <= 1) {
$seuil = "1";
} elseif (2 <= $nb_taxons && $nb_taxons <= 1200) {
$seuil = "2";
} elseif (1201 <= $nb_taxons && $nb_taxons <= 2400) {
$seuil = "3";
} elseif (2401 <= $nb_taxons && $nb_taxons <= 3600) {
$seuil = "4";
} elseif (3601 <= $nb_taxons) {
$seuil = "5";
}
return "seuil".$seuil;
}
public function compterTaxonsParZones() {
$req = "SELECT * FROM ".$this->tableChorodep;
$resultat = $this->Bdd->recupererTous($req);
$max = 0;
$nb_taxons_par_zones = array();
foreach($resultat as $ligne) {
$i = 0;
for($i < 0; $i <= 100; $i++) {
$index = $i < 10 ? "0".$i : $i;
if(isset($ligne[$index]) && $ligne[$index] != "" && $ligne[$index] == self::PRESENCE_CHOROLOGIE) {
// seules les présences certaines sont prises en compte
$nb_taxons_par_zones[$index] = isset($nb_taxons_par_zones[$index]) ? $nb_taxons_par_zones[$index] : 0;
$nb_taxons_par_zones[$index] += 1;
// calcul du max qui sert à générer la légende
$max = $nb_taxons_par_zones[$index] > $max ? $nb_taxons_par_zones[$index] : $max;
}
}
}
return array('nb_taxons_par_zones' => $nb_taxons_par_zones, 'max' => $max);
}
public function sauverCache($a_cacher, $cache_id) {
$cache = new CacheSimple($this->options_cache);
return $cache->sauver(serialize($a_cacher), $cache_id);
}
public function getCache($id) {
$cache = new CacheSimple($this->options_cache);
if(($contenu_cache = $cache->charger($id)) !== false) {
$contenu_cache = unserialize($contenu_cache);
}
return $contenu_cache;
}
private function calculerHauteur($largeur) {
$rapport = $this->longeurOrig/$this->largeurOrig;
$hauteur = $rapport * $largeur;
return intval($hauteur);
}
private function envoyerCacheSiExiste($id) {
if(($cache = $this->getCache($id))) {
$style = $cache['style'];
$infos_zones = $cache['infos_zones'];
$cache = $this->assemblerSvg($this->calculerHauteur($this->largeurDemandee), $this->largeurDemandee, $style, $infos_zones);
$this->envoyerSvg($cache);
}
}
private function assemblerSvg($hauteur, $largeur, $style, $infos_zones) {
$tpl_svg = $this->cheminCartesBase.'/france_02.tpl.svg';
$donnees = array(
'hauteur' => $hauteur,
'largeur' => $largeur,
'css' => $style,
'infos_zones' => $infos_zones
);
$svg = SquelettePhp::analyser($tpl_svg, $donnees);
return $svg;
}
private function envoyerLegende($legende) {
header("Content-type: application/json");
echo json_encode($legende);
exit;
}
private function envoyerSvg($svg) {
header("Content-type: image/svg+xml");
echo $svg;
exit;
}
}
/branches/v5.11-bananeraie/services/modules/0.1/chorodep/cartes/LegendeCartes.php
New file
0,0 → 1,112
<?php
// declare(encoding='UTF-8');
/**
* Gère le sous-service Legende de Cartes.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes
*
* @package eFlore/services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class LegendeCartes {
 
private $parametres = array();
private $ressources = array();
 
const MIME_JSON = 'application/json';
const PRESENCE_CHOROLOGIE = '1';
 
private $formatsSupportes = array(self::MIME_JSON);
private $tableOntologie = '';
private $ontologies = '';
private $legende = array();
 
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
}
 
public function consulter($ressources, $parametres) {
//$tpsDebut = microtime(true);
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirValeurParDefautDesParametres();
$this->verifierParametres();
 
$resultat = $this->obtenirResultat();
 
return $resultat;
}
 
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['retour']) == false) {
$this->parametres['retour'] = self::MIME_JSON;
}
}
 
private function verifierParametres() {
$erreurs = array();
 
if (isset($this->parametres['retour']) == false) {
$erreurs[] = "Le paramètre type de retour 'retour' est obligatoire.";
}
if ($this->verifierValeurParametreRetour() == false) {
$erreurs[] = "Le type de retour '{$this->parametres['retour']}' n'est pas supporté.";
}
 
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function verifierValeurParametreRetour() {
return in_array($this->parametres['retour'], $this->formatsSupportes);
}
 
private function obtenirResultat() {
$this->chargerOntologies();
$this->chargerLegende();
 
$resultat = new ResultatService();
$resultat->corps = $this->legende;
$resultat->mime = $this->parametres['retour'];
 
return $resultat;
}
 
private function chargerOntologies() {
$requete = "SELECT * FROM {$this->tableOntologie} ";
$resultats = $this->Bdd->recupererTous($requete);
 
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les données d'ontologies n'ont pu être chargées pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
 
foreach ($resultats as $ontologie) {
$this->ontologies[$ontologie['id']] = Commun::extraireComplementsOntologies($ontologie);
}
}
 
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE) {
$this->legende[] = array(
'code' => $ontologie['code'],
'couleur' => $ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']);
}
}
}
}
?>