Subversion Repositories eFlore/Archives.chorologie

Rev

Rev 33 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4 jpm 1
<?php
2
/*vim: set expandtab tabstop=4 shiftwidth=4: */
3
// +------------------------------------------------------------------------------------------------------+
4
// | PHP version 4.3                                                                                    |
5
// +------------------------------------------------------------------------------------------------------+
6
// | Copyright (C) 2004 Tela Botanica (accueil@tela-botanica.org)                                         |
7
// +------------------------------------------------------------------------------------------------------+
8
// | This file is part of Cartographie.                                                                   |
9
// |                                                                                                      |
10
// | Foobar is free software; you can redistribute it and/or modify                                       |
11
// | it under the terms of the GNU General Public License as published by                                 |
12
// | the Free Software Foundation; either version 2 of the License, or                                    |
13
// | (at your option) any later version.                                                                  |
14
// |                                                                                                      |
15
// | Foobar is distributed in the hope that it will be useful,                                            |
16
// | but WITHOUT ANY WARRANTY; without even the implied warranty of                                       |
17
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                        |
18
// | GNU General Public License for more details.                                                         |
19
// |                                                                                                      |
20
// | You should have received a copy of the GNU General Public License                                    |
21
// | along with Foobar; if not, write to the Free Software                                                |
22
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                            |
23
// +------------------------------------------------------------------------------------------------------+
41 jp_milcent 24
// CVS : $Id: carto_carte.class.php,v 1.6 2007-01-08 11:41:13 jp_milcent Exp $
4 jpm 25
/**
26
* Classe Carto_Carte.
27
*
28
* Calsse permettant de réaliser des cartes.
29
*
30
*@package Cartographie
31
//Auteur original :
32
*@author        Nicolas MATHIEU
33
//Autres auteurs :
34
*@author        Jean-Pascal MILCENT <jpm@tela-botanica.org>
35
*@author        Alexandre GRANIER <alexandre@tela-botanica.org>
36
*@copyright     Tela-Botanica 2000-2004
41 jp_milcent 37
*@version       $Revision: 1.6 $ $Date: 2007-01-08 11:41:13 $
4 jpm 38
// +------------------------------------------------------------------------------------------------------+
39
*/
40
 
41
// +------------------------------------------------------------------------------------------------------+
42
// |                                            ENTETE du PROGRAMME                                       |
43
// +------------------------------------------------------------------------------------------------------+
44
require 'carto_action.class.php';
45
require 'carto_couleur.class.php';
46
require 'carto_historique.class.php';
47
 
48
// +------------------------------------------------------------------------------------------------------+
49
// |                                            CORPS du PROGRAMME                                        |
50
// +------------------------------------------------------------------------------------------------------+
9 jpm 51
/**
52
* Classe Carto_Carte() - Classe principale de la cartographie.
53
*
54
* La classe Carto_Carte permet de travailler les fichiers images des cartes.
55
*/
4 jpm 56
class Carto_Carte
57
{
9 jpm 58
    // +--------------------------------------------------------------------------------------------------+
59
    //                                      LES ATTRIBUTS DE LA CLASSE
4 jpm 60
    var $id;
61
    var $_id_zone_geo_carte;
62
    var $nom;
63
    var $masque;
64
    var $fond;
65
    var $chemin;
66
    var $image;
67
    var $fils;
68
    var $url;
69
    var $_info_table_zg;
70
    var $filiation;
71
    var $image_x;
72
    var $image_y;
73
    var $historique_cartes;
74
    var $liste_zone_carte;
75
    var $historique;
76
    // La couleur dominante ( $maxiRVB ), la couleur la plus claire ($miniRVB) et la couleur
77
    // intermédiaire précédant le maximum ( $mediumRVB ) au cas ou il y aurait un trop grand
78
    //ecart entre les deux plus grandes valeurs.
79
    var $_zeroR;
80
    var $_zeroV;
81
    var $_zeroB;
82
    var $_miniR;
83
    var $_miniV;
84
    var $_miniB;
85
    var $_mediumR;
86
    var $_mediumV;
87
    var $_mediumB;
88
    var $_maxiR;
89
    var $_maxiV;
90
    var $_maxiB;
91
    //Le type de formule mathématique permettant de colorier la carte
92
    var $_formule_coloriage;
93
    //L'action à réaliser
33 jp_milcent 94
    var $_action;
9 jpm 95
 
4 jpm 96
    // +--------------------------------------------------------------------------------------------------+
9 jpm 97
    //                                     LE CONSTRUCTEUR DE LA CLASSE
98
    function Carto_Carte($id, $id_zone_geo_carte, $nom, $masque, $fond, $chemin, $info_table_zg, $info_table_action)
4 jpm 99
    {
100
        $this->id = $id;
101
        $this->_id_zone_geo_carte = $id_zone_geo_carte;
102
        $this->nom = $nom;
103
        $this->masque = $chemin.$masque;
104
        $this->fond = $chemin.$fond;
105
        $this->chemin = $chemin;
9 jpm 106
        $this->_info_table_zg = $info_table_zg;
4 jpm 107
 
9 jpm 108
        $this->_action = new Carto_Action($info_table_zg, $info_table_action);
4 jpm 109
        $this->fils = array();
110
        $this->filiation = $id;
111
        $this->historique_cartes = '';
112
        $this->liste_zone_carte = '';
113
        $this->definirCouleurs();
114
        $this->definirFormuleColoriage();
115
    }
9 jpm 116
 
4 jpm 117
    // +--------------------------------------------------------------------------------------------------+
9 jpm 118
    //                                       LES METHODES PUBLIQUES
4 jpm 119
    function definirCouleurs (
120
        $couleur_zero_R = '255', $couleur_zero_V = '255', $couleur_zero_B = '255',
121
        $couleur_mini_R = '210', $couleur_mini_V = '230', $couleur_mini_B = '210',
122
        $couleur_medium_R  = '92', $couleur_medium_V = '181', $couleur_medium_B = '92',
123
        $couleur_maxi_R = '0', $couleur_maxi_V = '127', $couleur_maxi_B = '0')
124
    {
125
        $this->_zeroR = $couleur_zero_R;
126
        $this->_zeroV = $couleur_zero_V;
127
        $this->_zeroB = $couleur_zero_B;
128
        $this->_miniR = $couleur_mini_R;
129
        $this->_miniV = $couleur_mini_V;
130
        $this->_miniB = $couleur_mini_B;
131
        $this->_mediumR = $couleur_medium_R;
132
        $this->_mediumV = $couleur_medium_V;
133
        $this->_mediumB = $couleur_medium_B;
134
        $this->_maxiR = $couleur_maxi_R;
135
        $this->_maxiV = $couleur_maxi_V;
136
        $this->_maxiB = $couleur_maxi_B;
137
    }
138
 
139
    function definirFormuleColoriage ($nomFormuleColoriage = 'defaut')
140
    {
141
        $this->_formule_coloriage = $nomFormuleColoriage;
142
    }
143
 
144
    //********************************************************************************************************
145
    // La méthode donnerImageSimple ($objet) permet de récupérer une image non cliquable.
146
    //*********************************************************************************************************
147
 
148
    function donnerImageSimple($objet)
149
    {
150
        $nom_fichier_image = $this->_donnerIdUnique();
151
        $objet->_lancerColoriage('', $nom_fichier_image);
152
        $retour = '<img src="cartographie/bibliotheque/lib.carto.extractimg.php?fichier='.$nom_fichier_image.'" alt="Carte" />';
153
        return $retour;
154
    }
155
 
156
    //********************************************************************************************************
157
    // La methode ajouterFils() est essentielle. Elle permet d'ajouter toutes les sous cartes voulues.
158
    // Il faut lui indiquer, comme a la carte du niveau du dessus, son nom, le masque, le fond et info_table_couleur.
159
    // On a ainsi une inclusion d'objets les uns dans les autres.
160
    //*********************************************************************************************************
161
 
162
    function ajouterFils($id, $id_zone_geo_carte, $nom, $masque, $fond, $info_table)
163
    {
164
        $this->fils[$id] = new Carto_Carte ($id, $id_zone_geo_carte, $nom, $masque, $fond, $this->chemin, $info_table);
165
        //Si on ajoute à la carte du monde comme fils celle de l'europe, alors
166
        //on aura comme valeur pour $this->filiation de la carte d'europe : monde*europe
167
        $this->fils[$id]->filiation = $this->filiation.'*'.$id;
168
        $this->fils[$id]->url = $this->url;
169
        //Si on ajoute à la carte du monde dont le nom est 'Monde' comme fils celle de l'europe,
170
        //dont le nom est 'Europe', alors on aura comme valeur pour $this->nom de la carte d'europe : Monde*Europe
171
        $this->fils[$id]->nom = $this->nom.'*'.$nom;
172
        $this->fils[$id]->historique_cartes = $this->historique_cartes;
173
    }
174
 
175
    //*********************************************************************************************************
176
    // La methode donnerFormulaireImage() est la methode principale de la carto. C'est elle qui gere ce qu'il y a faire en
177
    // fonction de l'action de l'utilisateur.
178
    // Trois cas se distinguent :
179
    //      -soit l'utilisateur a clique sur un point de la carte.
180
    //      -soit il a clique sur un des liens que l'on a afficher avec la méthode afficherHistoriqueCarte de l'objet Carto_HistoriqueCarte.
181
    //      -soit il a sélectionné une zone géographique dans la liste déroulante.
182
    // Elle renvoit a la fin:
183
    //      -soit une nouvelle carte coloriée
184
    //      -soit false.
185
    //**********************************************************************************************************
186
    function donnerFormulaireImage ()
187
    {
9 jpm 188
        //global $GS_GLOBAL;
4 jpm 189
        $res = '';
190
 
191
        // Nous commençons par tester tout d'abords si nous venons d'une autre carte. Pour cela nous vérifions,
192
        // si les attributs $this->image_x et $this->image_y de la classe Carte existe ou ne sont pas null.
193
        // La carte est une image appelée par une balise <input type="image"> et non par une balise classique <img>.
194
        // Ansi, lorsqu'on clique sur la carte le formulaire appelle (via l'url du formulaire) l'application
195
        // utilisant la classe carte et lui renvoit deux variables contenant les coordonnées x et y du clic.
196
        // L'application instancie à nouveau les objets cartes mais cette fois ci la carte affichée dépendra des
197
        // informations founit par une table de la base de données.
198
        // La classe carto_action instanciée dans l'application utilisant la classe carte fournit les noms
199
        // des champs et celui de la table contenant les valeur RVB de chaque zone des cartes, l'identifiant
200
        // de la zone et l'action à entreprendre pour la zone conssidérée.
201
        // La méthode imgform() utilise la méthode get_cartoAction() de l'objet Carto_Action pour connaître
202
        // en fonction des coordonnées du clic l'action à entreprendre.
203
 
204
 
205
        // Quoi qu'il arrive, on ouvre la balise formulaire
18 jpm 206
        $res = '<form id="cartographie" action="'.$this->url.'" method="post">'."\n";
9 jpm 207
        $res .= '<p>';
4 jpm 208
        if (isset ($this->image_x) && ($this->image_x != '') && isset ($this->image_y) && ($this->image_y != '')) {
209
            // on regarde ici si l'on a pas un objet de plus bas niveau présent dans la variable de session carte
210
            //a charger a la place de l'objet de plus haut niveau
211
 
9 jpm 212
            $var_session_retour = $_SESSION['carte'];
4 jpm 213
 
214
            if ($var_session_retour) {
215
                $image_x = $this->image_x;
216
                $image_y = $this->image_y;
217
                $liste_zone_carte = $this->liste_zone_carte;
218
                // Nous chargons alors l'ojet approprié en descendant grâce a la généalogie
219
 
220
                $historique_cartes = explode('*',$this->historique_cartes);
221
                foreach ($historique_cartes as $key => $value) {
222
                    if ($key != 0) {
33 jp_milcent 223
                        //$this = $this->fils[$value];
224
                        foreach (get_object_vars($this->fils[$value]) as $key => $value) {
225
									$this->$key = $value;
226
                        }
4 jpm 227
                    }
228
                }
229
                $this->image_x = $image_x;
230
                $this->image_y = $image_y;
231
                $this->liste_zone_carte = $liste_zone_carte;
9 jpm 232
                unset($_SESSION['carte']) ;
4 jpm 233
            }
234
 
235
            // on regarde qu'est-ce qu'on doit faire grace a la methode _consulterAction() de l'objet Carto_Action
236
 
237
            $action = $this->_action->_consulterActionImage($this->image_x, $this->image_y, $this->masque, $this->id);
238
 
239
            // Nous distinguons 2 cas :
240
            //le cas ou il faut afficher une nouvelle carte ... :
241
            if ($action['type_action'] == 'Aller_a') {
242
 
243
                $id_carte_destination = $action['id_carte_destination'] ;
244
                $this->fils[$id_carte_destination]->liste_zone_carte = $this->liste_zone_carte;
245
                $res .= ''.$this->fils[$id_carte_destination]->_donnerListeZoneCarte()."<br />\n";
246
                $res .= '<input type="image" src="';
247
                $id_image = $this->_donnerIdUnique();
248
                $this->fils[$id_carte_destination]->_lancerColoriage($id_image);
249
                $obj = serialize($this->fils[$id_carte_destination]);
9 jpm 250
                $_SESSION['carte'] = $obj;
4 jpm 251
                $this->historique = $this->fils[$id_carte_destination]->filiation;
252
                $this->id = $this->fils[$id_carte_destination]->id;
253
                $this->nom = $this->fils[$id_carte_destination]->nom;
254
            }
255
            //Dans le cas où l'on veut rappeler une nouvelle carte, il se peut que la nouvelle carte à rappeler
256
            //soit la même que précédement.
257
            //Cette possibilité peut se présenter quand on clique sur un zone blanche d'une carte (càd dans la mer)
258
            //Là, on recharge la carte précédente :
259
            elseif ($action['type_action'] == 'Recharger') {
260
                $res .= ''.$this->_donnerListeZoneCarte()."<br />\n";
261
                $res .= '<input type="image" src="';
262
                $id_image = $this->_donnerIdUnique();
263
                $this->_lancerColoriage($id_image);
264
                $obj = serialize($this);
265
                $_SESSION['carte'] = $obj ;
266
                $this->historique = $this->filiation;
267
            }
268
            // ... et le cas ou il faut lancer le dernier niveau
269
            else if ($action['type_action'] == 'Stop') {
270
                unset ($_SESSION['carte']) ;
271
                $this->historique = $this->filiation.'*'.$action['id_zone_geo'];
272
                $obj = serialize($this);
273
                $_SESSION['carte'] = $obj ;
274
                return false;
275
            }
276
        }
277
        elseif ($this->liste_zone_carte != '') {
278
            $liste_zone_carte = $this->liste_zone_carte;
279
            $historique_cartes = explode('*',$this->historique_cartes);
280
            foreach ($historique_cartes as $key => $value) {
281
                if ($key != 0) {
33 jp_milcent 282
                    //$this = $this->fils[$value];
283
                    foreach (get_object_vars($this->fils[$value]) as $key => $value) {
284
								$this->$key = $value;
285
							}
4 jpm 286
                }
287
            }
288
            $this->liste_zone_carte = $liste_zone_carte;
289
 
290
            $res .= ''.$this->_donnerListeZoneCarte($this->liste_zone_carte)."<br />\n";
291
            $res .= '<input type="image" src="';
292
            $id_image = $this->_donnerIdUnique();
293
            $this->_lancerColoriage($id_image, '', $this->liste_zone_carte);
294
            $this->historique = $this->historique_cartes;
295
            $obj = serialize($this);
296
            $_SESSION['carte'] = $obj ;
297
        }
298
        // On teste maintenant si l'on vient d'un lien. Si c'est le cas on a recu un argument
299
        // qui nous donne la "genealogie" de la carte que l'on doit afficher
300
        else if ($this->historique_cartes) {
301
            // Nous chargons alors l'ojet approprié en descendant grâce a la généalogie
302
            $historique_cartes = explode('*',$this->historique_cartes);
303
            foreach ($historique_cartes as $key => $value) {
304
                if ($key != 0) {
33 jp_milcent 305
                    //$this = $this->fils[$value];
306
                    foreach (get_object_vars($this->fils[$value]) as $key => $value) {
307
								$this->$key = $value;
308
                    }
4 jpm 309
                }
310
            }
311
            // une foit que l'on a charge le bon objet nous le colorions
312
            $res .= ''.$this->_donnerListeZoneCarte()."<br />\n";
313
 
314
            $res .= '<input type="image" src="';
315
            $id_image = $this->_donnerIdUnique();
316
            $this->_lancerColoriage($id_image);
317
            $this->historique = $this->historique_cartes;
318
            $obj = serialize($this);
319
            $_SESSION['carte'] = $obj ;
320
        }
321
        // Enfin si on ne vient pas d'une carte ou d'un lien c'est que l'on vient de l'onglet carto du menu
322
        // et on affiche alors la premiere carte
323
        else {
324
            unset ($_SESSION['carte']) ;
325
            $res .= ''.$this->_donnerListeZoneCarte()."<br />\n";
326
 
327
            $res .= '<input type="image" src="';
328
            $id_image = $this->_donnerIdUnique();
329
            $this->_lancerColoriage($id_image);
330
            $this->historique = $this->id;
331
            $obj = serialize($this);
332
 
12 jpm 333
            $_SESSION['carte'] = $obj;
4 jpm 334
        }
12 jpm 335
        $_SESSION['chemin'] = CAR_CHEMIN_TMP;
336
        $_SESSION['fichier'] = $this->id.$id_image;
337
        $res .= CAR_CHEMIN_CARTE.'"';
41 jp_milcent 338
        $res .= ' name="image" />'."\n";
12 jpm 339
        $res .= '<input type="hidden" name="historique_cartes" value="'.$this->historique.'" />'."\n";
340
        $res .= '</p>'."\n";
4 jpm 341
        $res .= '</form>'."\n";
342
        return $res;
343
    }
344
 
9 jpm 345
    // +--------------------------------------------------------------------------------------------------+
346
    //                                       LES METHODES PRIVÉES
4 jpm 347
    function _donnerListeZoneCarte($zone_par_defaut = '')
348
    {
349
        $retour = '';
350
 
351
        $requete =
352
                    'SELECT '.$this->_info_table_zg['nom_chp_id_zone'].', '.$this->_info_table_zg['nom_chp_nom_zone'].
353
                    ' FROM '.$this->_info_table_zg['nom_table_zone'];
354
        if ($this->_info_table_zg['nom_chp_zone_sup'] != ''){
355
            if(ereg("[a-z]+",$this->_id_zone_geo_carte)){
356
                $requete .=
357
                    ' WHERE '.$this->_info_table_zg['nom_chp_zone_sup'].' = "'.$this->_id_zone_geo_carte.'"';
358
            }
359
            else{
360
                $requete .=
361
                    ' WHERE '.$this->_info_table_zg['nom_chp_zone_sup'].' = '.$this->_id_zone_geo_carte;
362
            }
363
        }
364
        $requete .=
365
                    ' ORDER BY '.$this->_info_table_zg['nom_chp_nom_zone'].' ASC';
9 jpm 366
 
4 jpm 367
        $resultat = mysql_query ($requete) or die('
368
            <H2 style="text-align: center; font-weight: bold; font-size: 26px;">Erreur de requête</H2>'.
369
            '<b>Requete : </b>'.$requete.
370
            '<br/><br/><b>Erreur : </b>'.mysql_error());
371
 
372
        $i=0;
373
 
18 jpm 374
        $retour = '<select id="liste_zone_carte" name="liste_zone_carte" onchange="javascript:this.form.submit();">'."\n";
4 jpm 375
        $retour .= '<option value="">Visualiser une zone :</option>'."\n";
376
 
377
        $nom_chp_nom_zone = $this->_info_table_zg['nom_chp_nom_zone'];
378
        $nom_chp_id_zone = $this->_info_table_zg['nom_chp_id_zone'];
379
 
380
        while ($ligne = mysql_fetch_object ($resultat)) {
381
            if ($zone_par_defaut == $ligne->$nom_chp_id_zone){
382
                $retour .= '<option value="'.$ligne->$nom_chp_id_zone.'" selected="selected">'.$ligne->$nom_chp_nom_zone.'</option>'."\n";
383
            }
384
            else {
385
                $retour .= '<option value="'.$ligne->$nom_chp_id_zone.'">'.$ligne->$nom_chp_nom_zone.'</option>'."\n";
386
            }
387
            $i++;
388
        }
389
 
390
        $retour .= '</select>'."\n";
391
 
392
        return $retour;
393
    }
394
    //==============================================================================
395
    // METHODE _lancerColoriage()
396
    //
397
    // Elle lance le coloriage de l'image.
398
    // Elle est lancée toute seule par la méthode donnerFormulaireImage().
399
    // Les informations qui lui sont necessaires sont déjà données à l'objet carte (fond, info_table_couleur).
400
    //==============================================================================
401
 
402
    function _lancerColoriage ($id_image = '_00', $nom_fichier = '', $id_zone_a_reperer = '')
403
    {
404
        $this->image = imagecreatefrompng($this->fond);
405
        $this->_colorierImage ($this->image, $this->_info_table_zg['nom_table_zone'], $this->_info_table_zg['nom_chp_id_zone'], $this->_info_table_zg['nom_chp_rouge'],
406
                                        $this->_info_table_zg['nom_chp_vert'], $this->_info_table_zg['nom_chp_bleu'], $this->_info_table_zg['nom_chp_zone_sup'],
407
                                        $this->_info_table_zg['tableau_valeurs_zone'], $id_zone_a_reperer) ;
408
        if ($nom_fichier != '') {
9 jpm 409
            imagepng(&$this->image, CAR_CHEMIN_TMP.$nom_fichier.'.png');
4 jpm 410
            //$this->image = imagepng(&$this->image);
411
        }
412
        else {
9 jpm 413
            imagepng(&$this->image, CAR_CHEMIN_TMP.$this->id.$id_image.'.png');
4 jpm 414
            //imagepng(&$this->image);
415
        }
416
    }
417
 
418
    //==============================================================================
419
    // METHODE _colorierImage()
420
    //
421
    // Elle réalise le coloriage de l'image.
422
    //==============================================================================
423
 
424
    function _colorierImage (&$image_fond, $table_zone_geo, $chp_id_zone_couleur, $chp_rouge, $chp_vert, $chp_bleu, $chp_zone_sup, $tableau_valeurs_zone, $id_zone_a_reperer)
425
    {
426
        //----------------------------------------------------------------------------
427
        // Cherche les valeurs RVB de la couleur de chaque zone géographique et les rentre dans
428
        //un tableau d'objets Carto_InformationCouleur (voir la description de la classe ci-dessus.
429
 
430
        $requete_01 =
431
                    'SELECT *'.
432
                    ' FROM '.$table_zone_geo;
433
        if ($chp_zone_sup != ''){
434
            if(ereg("[a-z]+",$this->_id_zone_geo_carte)){
435
                $requete_01 .=
436
                    ' WHERE '.$chp_zone_sup.' = "'.$this->_id_zone_geo_carte.'"';
437
            }
438
            else{
439
                $requete_01 .=
440
                    ' WHERE '.$chp_zone_sup.' = '.$this->_id_zone_geo_carte;
441
            }
442
        }
443
        $resultat_01 = mysql_query ($requete_01) or die('
444
            <H2 style="text-align: center; font-weight: bold; font-size: 26px;">Erreur de requête</H2>'.
445
            '<b>Requete : </b>'.$requete_01.
446
            '<br/><br/><b>Erreur : </b>'.mysql_error());
447
        $i=0;
448
        $attachments = array();
449
        while ($ligne_01 = mysql_fetch_object ($resultat_01)) {
450
            $attachments[$i] = new Carto_Couleur ($ligne_01->$chp_id_zone_couleur, $ligne_01->$chp_rouge, $ligne_01->$chp_vert, $ligne_01->$chp_bleu);
451
            $i++;
452
        }
453
 
454
        //Nous libérons toute la mémoire associée à l'identifiant de résultat.
455
        mysql_free_result ($resultat_01);
456
 
457
        //----------------------------------------------------------------------------
458
        // On realide l'association entre l'index des couleurs et la zone de meme couleur
459
 
460
        $attachments = $this->_construireAssociationIndexZone ($image_fond, $attachments);
461
 
462
        //----------------------------------------------------------------------------
463
        //Dans l'application qui utilise la classe carte, nous avons instancié un tableau
464
        //associatif qui contient en clé l'identifiant d'une zone géographique et en valeur
465
        //un nombre (qui peut-être un nombre d'inscrit, d'institutions, de taxons...).
466
        // Nous récupérons ci-dessous la valeur minimum autre que 0 présente dans ce tableau
467
        //puis une valeur conscidérée comme maximum
468
 
469
        if (!is_array($tableau_valeurs_zone)) {
470
            $mini = 0;
471
            $medium = 0;
472
            $maxi = 0;
473
            $nbre_valeurs = 0;
474
        }
475
        else {
476
            if (count($tableau_valeurs_zone) == 0) {
477
                $mini=0;
478
                $medium = 0;
479
                $maxi=0;
480
            }
481
            else {
482
                $i=0;
483
                foreach ($tableau_valeurs_zone as $cle => $valeur) {
484
                    //Nous recherchons le minimum, le maximum et le la valeur médium juste au dessous du maximum.
485
                    if ($valeur != 0) {
486
                        $tablo_valeurs[$i] = $valeur;
487
                        $i++;
488
                    }
489
                }
490
                //Nombre d'entrées dans le tableau de valeurs non nulles :
491
                $nbre_valeurs = count($tablo_valeurs);
492
                $somme_valeurs = array_sum($tablo_valeurs);
493
                $tablo_frequences = array_count_values($tablo_valeurs);
494
                $nbre_frequences = count($tablo_frequences);
495
                if ($nbre_valeurs > 0){
496
                    //Nous trions le tableau dans l'ordre croissant :
497
                    sort($tablo_valeurs);
498
                    //Nous récupérons la valeur la plus petite :
499
                    $mini = $tablo_valeurs[0];
500
                    $maxi = $tablo_valeurs[$nbre_valeurs-1];
501
                    isset($tablo_valeurs[$nbre_valeurs-2]) ? $medium = $tablo_valeurs[$nbre_valeurs-2] : $medium = 0;
502
                    $moyenne = $somme_valeurs/$nbre_valeurs;
503
                    $ecart_au_carre_moyen = 0;
504
                    for ($i = 0; $i < $nbre_valeurs; $i++) {
505
                        $ecart_au_carre_moyen += pow(($tablo_valeurs[$i] - $moyenne), 2);
506
                    }
507
                    $variance = $ecart_au_carre_moyen/$nbre_valeurs;
508
                    $ecart_type = sqrt($variance);
509
 
510
                    $moyenne = round($moyenne, 0);
511
                    $variance = round($variance, 0);
512
                    $ecart_type = round($ecart_type, 0);
513
 
514
                    /*echo 'Nombre de valeurs : '.$nbre_valeurs.'<br>';
515
                    echo 'Nombre de frequences : '.$nbre_frequences.'<br>';
516
                    echo 'Moyenne : '.$moyenne.'<br>';
517
                    echo 'Variance : '.$variance.'<br>';
518
                    echo 'Ecart-type : '.$ecart_type.'<br>';
519
                    echo 'Formule de coloriage : '.$this->_formule_coloriage.'<br>';
520
                    echo "mini : $mini medium : $medium maxi : $maxi<br/>";
521
            */
522
                }
523
            }
524
        }
525
 
526
        //----------------------------------------------------------------------------
527
        // Nous réalisons le coloriage de toutes les zones :
528
 
529
        $requete_03 =
530
            "SELECT $chp_id_zone_couleur ".
531
            "FROM $table_zone_geo";
532
 
533
        $resultat_03 = mysql_query ($requete_03) or die('
534
            <H2 style="text-align: center; font-weight: bold; font-size: 26px;">Erreur de requête</H2>'.
535
            '<b>Requete : </b>'.$requete_03.
536
            '<br/><br/><b>Erreur : </b>'.mysql_error());
537
 
538
        while ($ligne_03 = mysql_fetch_object ($resultat_03)) {
539
            $id_zone_geo = $ligne_03->$chp_id_zone_couleur;
540
            if (!isset ($tableau_valeurs_zone[$id_zone_geo])) {
541
                $tableau_valeurs_zone[$id_zone_geo] = 0;
542
            }
543
            //Nous cherchons la couleur a afficher pour chaque zone.
544
            if ($tableau_valeurs_zone[$id_zone_geo] != 0) {
545
                //echo 'ZONE:'.$id_zone_geo."<br/>";
546
                //echo $tableau_valeurs_zone[$id_zone_geo]."<br/>";
547
                $theColor = $this->_donnerCouleur (
548
                                        $this->_miniR, $this->_miniV, $this->_miniB,
549
                                        $this->_mediumR , $this->_mediumV , $this->_mediumB ,
550
                                        $this->_maxiR , $this->_maxiV , $this->_maxiB ,
551
                                        $mini, $medium, $maxi, $nbre_valeurs, $ecart_type, $moyenne, $tablo_valeurs,
552
                                        $tablo_frequences, $nbre_frequences,
553
                                        $tableau_valeurs_zone[$id_zone_geo],
554
                                        $this->_formule_coloriage);
555
                //echo $theColor['R'].'<br>';
556
                //echo $theColor['V'].'<br>';
557
                //echo $theColor['B'].'<br>';
558
            }
559
            else {
560
                $theColor['R'] = $this->_zeroR;
561
                $theColor['V'] = $this->_zeroV;
562
                $theColor['B'] = $this->_zeroB;
563
            }
564
            //Nous réalisons le coloriage de toutes les zones de l'image avec la couleur obtenue.
565
            $this->_remplacerCouleur ($image_fond, $attachments, $id_zone_geo,  $theColor['R'], $theColor['V'], $theColor['B'], $id_zone_a_reperer);
566
        }
567
        //Nous libérons toute la mémoire associée à l'identifiant de résultat de la requête.
568
        mysql_free_result ($resultat_03);
569
    }
570
 
571
    //==============================================================================
572
    // METHODE  _construireAssociationIndexZone ($image, &$att)
573
    //
574
    // Le tableau $att est passé par référence. La méthode modifie donc directement
575
    // le tableau et ne renvoit donc rien.
576
    // Attache dans un tableau $att, contenant sous forme d'objet (Carto_ColorInfo)
577
    // les valeurs RVB des zones d'une image, la valeur de l'index correspondant
578
    // à la couleur de la zone.
579
    // Note : les images en question sont constituées de zones distincte possédant
580
    // chacune une couleur unique et unie.
581
    //==============================================================================
582
 
583
    function _construireAssociationIndexZone (&$image_fond, &$att)
584
    {
585
        // Nous récupérons le nombre de couleur différentes contenues dans l'image.
586
        //echo $this->fond.'<BR>';
587
        $image_fond = imagecreatefrompng($this->fond);
588
        $taille_palette = imagecolorstotal ($image_fond);
589
        //echo $taille_palette.'<br>';
590
        // Pour chaque couleur contenue dans l'image, nous cherchons l'objet correspondant
591
        // dans le tableau $att, qui contient des informations sur chaque zone de l'image,
592
        // et nous attribuons à l'objet la valeur de l'index de sa couleur dans l'image.
593
 
594
        for ($i = 0; $i < $taille_palette; $i++) {
595
            $valeurs_RVB = array();
596
            $valeurs_RVB = imagecolorsforindex ($image_fond, $i);
597
            for ($j = 0; $j < count ($att); $j++) {
598
 
599
                if (($att[$j]->rouge == $valeurs_RVB['red']) && ($att[$j]->vert == $valeurs_RVB['green']) && ($att[$j]->bleu == $valeurs_RVB['blue'])) {
600
                    $att[$j]->index = $i;
601
                    //echo 'ICI'.$att[$j]->id_zone.$att[$j]->index.'<br>';
602
                    break;
603
                }
604
            }
605
        }
606
 
607
        return $att;
608
    }//Fin méthode _construireAssociationIndexZone()
609
 
610
    //==============================================================================
611
    // METHODE _donnerCouleur()
612
    //------------------------------------------------------------------------------
613
    // Renvoie pour une valeur donnee la couleur a mettre
614
    //------------------------------------------------------------------------------
615
    // ENTREE
616
    // $miniR : valeur rouge du minimum
617
    // $miniV : valeur vert du minimum
618
    // $miniB : valeur blue du minimum
619
    // $maxiR : valeur rouge du maximum
620
    // $maxiV : valeur vert du maximum
621
    // $maxiB : valeur bleu du maximum
622
    // $mediumR : valeur rouge du deuxieme maximum
623
    // $mediumV : valeur vert du deuxieme maximum
624
    // $mediumB : valeur bleu du deuxieme maximum
625
    // $mini  : valeur mini sur l'echelle
626
    // $medium  : valeur juste au dessous du maximum sur l'echelle
627
    // $maxi  : valeur maxi sur l'echelle
628
    // $val   : valeur dont on cherche la couleur
629
    //------------------------------------------------------------------------------
630
    // SORTIE
631
    // $couleur array donne la couleur pour la valeur demande ($val)
632
    //------------------------------------------------------------------------------
633
 
634
    function _donnerCouleur ($miniR, $miniV, $miniB, $mediumR, $mediumV, $mediumB, $maxiR,
635
                            $maxiV, $maxiB, $mini, $medium, $maxi, $nbre_valeurs, $ecart_type, $moyenne, $tablo_valeurs, $tablo_frequences, $nbre_frequences, $val, $formuleColoriage)
636
    {
637
        if ($formuleColoriage == 'defaut'){
638
            if ($val == $maxi) {
639
                $couleur['R'] = $maxiR;
640
                $couleur['V'] = $maxiV;
641
                $couleur['B'] = $maxiB;
642
            }
643
            if ($val == $mini && $val != $maxi) {
644
                $couleur['R'] = $miniR;
645
                $couleur['V'] = $miniV;
646
                $couleur['B'] = $miniB;
647
            }
648
            if ($maxi/10 > $medium && $maxi/40 < $medium) {
649
                $diff = $medium - $mini;
650
                if ($diff > 0 && $val != $medium && $val != $maxi) {
651
                    $diffR   = $mediumR - $miniR;
652
                    $diffV   = $mediumV - $miniV;
653
                    $diffB   = $mediumB - $miniB;
654
                    $variationR =  round ( ($diffR/$diff ), 0 );
655
                    $variationV =  round ( ($diffV/$diff ), 0 );
656
                    $variationB =  round ( ($diffB/$diff ), 0 );
657
                    $couleur['R'] = couleur_bornerNbre(($miniR + ($val * $variationR)), 0, 255);
658
                    $couleur['V'] = couleur_bornerNbre(($miniV + ($val * $variationV)), 0, 255);
659
                    $couleur['B'] = couleur_bornerNbre(($miniB + ($val * $variationB)), 0, 255);
660
                }
661
                else if ($val == $medium) {
662
                    $couleur['R'] = $mediumR;
663
                    $couleur['V'] = $mediumV;
664
                    $couleur['B'] = $mediumB;
665
                }
666
            }
667
            else {
668
                $diff = $maxi - $mini;
669
                if ($diff > 0 && $val != $maxi && $val != $mini) {
670
                    $diffR = $maxiR - $miniR;
671
                    $diffV = $maxiV - $miniV;
672
                    $diffB = $maxiB - $miniB;
673
                    $variationR =  round ( ($diffR/$diff ), 0 );
674
                    $variationV =  round ( ($diffV/$diff ), 0 );
675
                    $variationB =  round ( ($diffB/$diff ), 0 );
676
                    $couleur['R'] = couleur_bornerNbre(($miniR + ($val * $variationR)), 0, 255);
677
                    $couleur['V'] = couleur_bornerNbre(($miniV + ($val * $variationV)), 0, 255);
678
                    $couleur['B'] = couleur_bornerNbre(($miniB + ($val * $variationB)), 0, 255);
679
                }
680
                else if ($diff == 0){
681
                    $couleur['R'] = $mediumR;
682
                    $couleur['V'] = $mediumV;
683
                    $couleur['B'] = $mediumB;
684
                }
685
            }
686
        }
687
        elseif ($formuleColoriage == 'ecart_type') {
688
            if ($ecart_type == 0) {
689
                    $couleur['R'] = $maxiR;
690
                    $couleur['V'] = $maxiV;
691
                    $couleur['B'] = $maxiB;
692
            }
693
            elseif ($ecart_type >= 1 && $ecart_type <= 15) {
694
                if ($val == $mini) {
695
                    $couleur['R'] = $miniR;
696
                    $couleur['V'] = $miniV;
697
                    $couleur['B'] = $miniB;
698
                }
699
                elseif ($val == $medium) {
700
                    $couleur['R'] = $mediumR;
701
                    $couleur['V'] = $mediumV;
702
                    $couleur['B'] = $mediumB;
703
                }
704
                elseif ($val == $maxi) {
705
                    $couleur['R'] = $maxiR;
706
                    $couleur['V'] = $maxiV;
707
                    $couleur['B'] = $maxiB;
708
                }
709
                else {
710
                    $dif_valeur_maxi_mini = $maxi - $mini;
711
                    $diffR = $maxiR - $miniR;
712
                    $diffV = $maxiV - $miniV;
713
                    $diffB = $maxiB - $miniB;
714
                    $variationR =  round ( ($diffR/$dif_valeur_maxi_mini ), 0 );
715
                    $variationV =  round ( ($diffV/$dif_valeur_maxi_mini ), 0 );
716
                    $variationB =  round ( ($diffB/$dif_valeur_maxi_mini ), 0 );
717
                    $couleur['R']=$miniR + ($val * $variationR);
718
                    $couleur['V']=$miniV + ($val * $variationV);
719
                    $couleur['B']=$miniB + ($val * $variationB);
720
                }
721
            }
722
            elseif ($ecart_type > 15) {
723
                //Le tableau est trié de la plus petite à la plus grande clé.
724
                ksort($tablo_frequences);
725
                $i = 0;
726
                foreach ($tablo_frequences as $cle => $valeur){
727
                    //Nous cherchons la correspondance entre la valeur et la clé.
728
                    if ($cle == $val) {
729
                        //Pour faire le Rouge, Vert, Bleu
730
                        $couleur['R'] = $miniR + ($i/$nbre_frequences) * ($maxiR - $miniR);
731
                        $couleur['V'] = $miniV + ($i/$nbre_frequences) * ($maxiV - $miniV);
732
                        $couleur['B'] = $miniB + ($i/$nbre_frequences) * ($maxiB - $miniB);
733
                    }
734
                    $i++;
735
                }
736
            }
737
        }
738
 
739
        return $couleur;
740
 
741
    }//Fin méthode _donnerCouleur()
742
 
743
    //==============================================================================
744
    // METHODE _remplacerCouleur ($img, $att, $id_zone_geo, $r, $g, $b)
745
    //
746
    // $img is the image, $att an array of carto_colorinfo objects, $id_zone_geo the name
747
    // of an object of $att, ($r, $g, $b) the new color.
748
    //
749
    // In the palette of $img, the color matching with $id_zone_geo is modified.
750
    //==============================================================================
751
 
752
    function _remplacerCouleur (&$image, &$atta, $id_zone_geo, $rouge, $vert, $bleu, $id_zone_a_reperer)
753
    {
754
        // Nous recherchons la valeur de l'index.
755
 
756
        $index = -1;
757
        for ($i = 0; $i < count ($atta); $i++) {
758
            if ($atta[$i]->id_zone == $id_zone_geo) {
759
                $index = $atta[$i]->index;
760
                //Dans le cas où nous voulons repérer une zone sur la carte :
761
                if($id_zone_geo == $id_zone_a_reperer) {
762
                    $rouge = 255;
763
                    $vert = 0;
764
                    $bleu = 0;
765
                }
766
                break;
767
            }
768
        }
769
 
770
        // Nous mettons à jour l'image de la carte avec la valeur de l'index.
771
 
772
        if ($index >= 0) {
773
            imagecolorset (&$image, $index, $rouge, $vert, $bleu);
774
        }
775
 
776
    }//Fin de la méthode _remplacerCouleur
777
 
778
    //==============================================================================
779
    // METHODE _donnerIdUnique ()
780
    //
781
    // Cette méthode privée retourne un identifiant de 32 caractères unique.
782
    //
783
    //==============================================================================
784
 
785
    function _donnerIdUnique ()
786
    {
787
        $id = '';
788
        $id = md5 (uniqid (rand()));
789
 
790
        return $id;
791
    }//Fin de la méthode _donnerIdUnique()
792
 
793
 
794
}//Fin de la classe Carto_Carte()
795
 
796
// +------------------------------------------------------------------------------------------------------+
797
// |                                            PIED du PROGRAMME                                         |
798
// +------------------------------------------------------------------------------------------------------+
799
 
800
 
801
/* +--Fin du code ----------------------------------------------------------------------------------------+
802
*
803
* $Log: not supported by cvs2svn $
41 jp_milcent 804
* Revision 1.5  2005/11/23 10:25:03  jp_milcent
805
* Compatibilité avec PHP5.
806
*
33 jp_milcent 807
* Revision 1.4  2005/02/23 17:29:38  jpm
808
* Ajout d'un id au formulaire  de la carto.
809
*
18 jpm 810
* Revision 1.3  2005/02/22 19:35:08  jpm
811
* Fin de gestion des variables via les sessions.
812
*
12 jpm 813
* Revision 1.2  2005/02/22 16:35:16  jpm
814
* Mise en forme.
815
* Utilisation de  constantes pour les chemins d'accès aux fichiers.
816
* Ajout de commentaires.
4 jpm 817
*
12 jpm 818
*
4 jpm 819
* +-- Fin du code ----------------------------------------------------------------------------------------+
820
*/
821
?>