3 if (!defined('_ECRIRE_INC_VERSION')) {
7 include_spip('inc/config');
8 include_spip('inc/json');
11 * Filtre dec_to_dms, http://www.statemaster.com/encyclopedia/Geographic-coordinate-conversion
13 * @param decimal $coord
16 function dec_to_dms($coord) {
20 60*(abs($coord)-floor(abs($coord)))
25 * Filtre dms_to_dec, http://www.statemaster.com/encyclopedia/Geographic-coordinate-conversion
27 * @param string $ref N, E, S, W
33 function dms_to_dec($ref, $deg, $min, $sec) {
35 $arrLatLong = array();
38 $arrLatLong['S'] = -1;
39 $arrLatLong['W'] = -1;
41 return ($deg+
((($min*60)+
($sec))/3600)) * $arrLatLong[$ref];
45 * Filtre distance pour renvoyer la distance entre deux points
46 * http://snipplr.com/view/2531/calculate-the-distance-between-two-coordinates-latitude-longitude/
47 * sinon voir ici : http://zone.spip.org/trac/spip-zone/browser/_plugins_/forms/geoforms/inc/gPoint.php
49 * @param int|array $from
50 * id_gis du point de référence ou tableau de coordonnées
51 * @param int|array $to
52 * id_gis du point distant ou tableau de coordonnées
54 * Renvoyer le résultat en miles (kilomètres par défaut)
56 * Retourne la distance en kilomètre ou en miles
58 function distance($from, $to, $miles = false) {
59 // On ne travaille que si on a toutes les infos
60 if (((is_array($from) and isset($from['lat']) and isset($from['lon'])) // Le départ est soit un tableau soit un entier
61 or ($from = intval($from) and $from > 0 and $from = sql_fetsel('lat,lon', 'spip_gis', "id_gis=$from")))
62 and ((is_array($to) and isset($to['lat']) and isset($to['lon'])) or ($to = intval($to) and $to > 0 and $to = sql_fetsel('lat,lon', 'spip_gis', "id_gis=$to"))) // Le distant est soit un tableau soit un entier
65 $from['lat'] *= $pi80;
66 $from['lon'] *= $pi80;
70 $r = 6372.797; // mean radius of Earth in km
71 $dlat = $to['lat'] - $from['lat'];
72 $dlng = $to['lon'] - $from['lon'];
73 $a = sin($dlat / 2) * sin($dlat / 2) +
cos($from['lat']) * cos($to['lat']) * sin($dlng / 2) * sin($dlng / 2);
74 $c = 2 * atan2(sqrt($a), sqrt(1 - $a));
77 return ($miles ?
($km * 0.621371192) : $km);
84 * Afficher proprement une distance
86 * @param float $distance
87 * Nombre indiquant une distance
88 * @param int $precision
89 * Précision des décimales du nombre final, par défaut 2
90 * @param string $format_entree
91 * Format de distance donnée en entrée : par défaut en kilomètres, sinon en mètres avec "m"
93 * Retourne une chaine composée d'un nombre arrondi et d'une unité de mesure de distance
95 function distance_en_metres($distance, $precision = 2, $format_entree = 'km') {
97 // On passe toujours tout en kilomètres pour uniformiser
98 if ($format_entree == 'm') {
99 $distance = $distance / 1000;
102 // Si c'est supérieur à 1, on reste en kilomètres
105 } elseif (($distance = $distance*1000) > 1) {
109 $distance = number_format($distance, $precision, ',', '') . ' ' . $unite;
116 * Compilation du critère {distancefrom}
118 * Critère {distancefrom} qui permet de ne sélectionner que les objets se trouvant à une distance comparée avec un point de repère.
119 * On doit lui passer 3 paramètres obligatoires :
120 * - le point de repère qui est un tableau avec les clés "lat" et "lon" ou un id_gis
121 * - l'opérateur de comparaison
122 * - la distance à comparer, en kilomètres
123 * Cela donne par exemple :
124 * {distancefrom #ARRAY{lat,#LAT,lon,#LON},<,30}
125 * {distancefrom #ARRAY{lat,#ENV{lat},lon,#ENV{lon}},<=,#ENV{distance}}
127 * @param unknown $idb
128 * @param unknown &$boucles
129 * @param unknown $crit
131 function critere_distancefrom_dist($idb, &$boucles, $crit) {
132 $boucle = &$boucles[$idb];
133 $id_table = $boucle->id_table
; // articles
134 $primary = $boucle->primary
; // id_article
135 $objet = objet_type($id_table); // article
137 if (($id_table == 'gis' or isset($boucle->join
['gis'])) // Soit depuis une boucle (GIS) soit un autre objet mais avec {gis}
138 and count($crit->param
) == 3 // Il faut aussi qu'il y ait 3 critères obligatoires
140 $point_reference = calculer_liste($crit->param
[0], array(), $boucles, $boucles[$idb]->id_parent
);
141 $operateur = calculer_liste($crit->param
[1], array(), $boucles, $boucles[$idb]->id_parent
);
142 $distance = calculer_liste($crit->param
[2], array(), $boucles, $boucles[$idb]->id_parent
);
144 // Si le point de référence est un entier, on essaye de récupérer les coordonnées du point GIS
145 // Et si on a toujours pas de tableau correct, on met false
146 $boucle->hierarchie
.= '$point_reference = '.$point_reference.';';
147 $boucle->hierarchie
.= 'if (is_numeric($point_reference)){ $point_reference = sql_fetsel("lat,lon", "spip_gis", "id_gis = ".intval($point_reference)); }';
148 $boucle->hierarchie
.= 'if (!is_array($point_reference) or !isset($point_reference["lat"]) or !isset($point_reference["lon"])){ $point_reference = false; }';
149 // L'opérateur doit exister dans une liste précise
150 $boucle->hierarchie
.= '$operateur_distance = trim('.$operateur.');';
151 $boucle->hierarchie
.= 'if (!in_array($operateur_distance, array("=","<",">","<=",">="))){ $operateur_distance = false; }';
152 $boucle->hierarchie
.= '$distance = '.$distance.';';
154 $boucle->select
[] = '".(!$point_reference ? "\'\' as distance" : "(6371 * acos( cos( radians(".$point_reference["lat"].") ) * cos( radians( gis.lat ) ) * cos( radians( gis.lon ) - radians(".$point_reference["lon"].") ) + sin( radians(".$point_reference["lat"].") ) * sin( radians( gis.lat ) ) ) ) AS distance")."';
155 $boucle->having
[] = '((!$point_reference or !$operateur_distance or !$distance) ? "1=1" : "distance $operateur_distance ".sql_quote($distance))';
160 * Compile le critère `{gis}` qui permet de compléter la boucle avec les points GIS
163 * - `{gis}` Retourne les objets ayant des points (et ajoute les balises spéciales GIS tel que `#TITRE_GIS`)
164 * - `{!gis}` Retourne les objets sans points
165 * - `{gis distance<XX}`, sur une boucle `GIS`, filtre une liste de points par rapport à la distance du point de l'env
168 * @param array $boucles
169 * @param Critere $crit
171 function critere_gis_dist($idb, &$boucles, $crit) {
172 $boucle = &$boucles[$idb];
173 $id_table = $boucle->id_table
; // articles
174 $primary = $boucle->primary
; // id_article
175 $objet = objet_type($id_table); // article
177 if ($id_table == 'gis') {
178 // exclure l'élément en cours des résultats
179 $id_gis = calculer_argument_precedent($idb, $primary, $boucles);
180 $boucle->where
[]= array("'!='", "'$boucle->id_table." . "$primary'", $id_gis);
182 // récupérer les paramètres du critère
184 $params = $crit->param
;
185 $type = array_shift($params);
186 $type = $type[0]->texte
;
187 if (preg_match(',^(\w+)([<>=]+)([0-9]+)$,', $type, $r)) {
193 $boucle->having
[]= array("'".$op."'", "'".$type."'",$op_val);
196 // récupérer lat/lon du point de la boucle englobante
197 $lat = calculer_argument_precedent($idb, 'lat', $boucles);
198 $lon = calculer_argument_precedent($idb, 'lon', $boucles);
200 // http://www.awelty.fr/developpement-web/php/
201 // http://www.movable-type.co.uk/scripts/latlong-db.html
202 // http://code.google.com/intl/fr/apis/maps/articles/geospatial.html#geospatial
203 $select = "(6371 * acos( cos( radians(\".$lat.\") ) * cos( radians( gis.lat ) ) * cos( radians( gis.lon ) - radians(\".$lon.\") ) + sin( radians(\".$lat.\") ) * sin( radians( gis.lat ) ) ) ) AS distance";
204 $order = "'distance'";
206 $boucle->select
[]= $select;
207 $boucle->order
[]= $order;
209 /* Recherche d'objets SANS point */
211 $boucle->from
['gis_liens'] = 'spip_gis_liens';
212 $boucle->from_type
['gis_liens'] = 'LEFT';
213 $boucle->join
['gis_liens'] = array("'$id_table'","'id_objet'","'$primary'","'gis_liens.objet='.sql_quote('$objet')");
214 $boucle->where
[] = "'gis_liens.id_gis IS NULL'";
216 /* Recherche d'objets AVEC point + ajout des champs GIS */
218 // ajouter tous les champs du point au select
219 // et les suffixer pour lever toute ambiguite avec des champs homonymes
220 if (!function_exists('objet_info')) {
221 include_spip('inc/filtres');
223 $champs = objet_info('gis', 'champs_critere_gis');
224 foreach ($champs as $champ) {
225 $boucle->select
[] = $champ;
227 // jointure sur spip_gis_liens/spip_gis
228 // cf plugin notation
229 // $boucle->join["surnom (as) table de liaison"] = array("surnom de la table a lier", "cle primaire de la table de liaison", "identifiant a lier", "type d'objet de l'identifiant");
230 $boucle->from
['gis_liens'] = 'spip_gis_liens';
231 $boucle->join
['gis_liens']= array("'$id_table'","'id_objet'","'$primary'","'gis_liens.objet='.sql_quote('$objet')");
232 $boucle->from
['gis'] = 'spip_gis';
233 $boucle->join
['gis']= array("'gis_liens'","'id_gis'");
234 // bien renvoyer tous les points qui son attachés à l'objet
235 // mais attention, si on trouve en amont un groupement portant sur un champ *de GIS*,
236 // alors cela signifie que la personne veut faire une opération de groupement sur les points donc là on n'ajoute pas id_gis
237 $tous_les_points = true;
238 foreach ($boucle->group
as $champ) {
239 if (in_array($champ, array('ville', 'code_postal', 'pays', 'code_pays', 'region','departement'))) {
240 $tous_les_points = false;
243 if ($tous_les_points) {
244 $boucle->group
[] = 'gis_liens.id_gis';
246 // ajouter gis aux jointures et spécifier les jointures explicites pour pouvoir utiliser les balises de la table de jointure
247 // permet de passer dans trouver_champ_exterieur() depuis index_tables_en_pile()
248 // cf http://article.gmane.org/gmane.comp.web.spip.zone/6628
249 $boucle->jointures
[] = 'gis';
250 if (empty($boucle->jointures_explicites
)) {
251 $boucle->jointures_explicites
= 'gis_liens gis';
253 $boucle->jointures_explicites
.= ' gis_liens gis';
258 function critere_gis_tout_dist($idb, &$boucles, $crit) {
260 $critere_gis = charger_fonction('gis', 'critere/');
261 $critere_gis($idb, $boucles, $crit);
262 $boucle = &$boucles[$idb];
263 $boucle->from_type
['gis_liens'] = 'LEFT';
264 $boucle->from_type
['gis'] = 'LEFT';
268 * Balise #DISTANCE issue du critère {gis distance<XX}
269 * merci marcimant : http://formation.magraine.net/spip.php?article61
271 * @param unknown_type $p
273 function balise_distance_dist($p) {
274 return rindex_pile($p, 'distance', 'gis');
278 * Balise #TITRE_GIS : retourne le titre du point
279 * Necessite le critere {gis} sur la boucle
281 * @param unknown_type $p
283 function balise_titre_gis_dist($p) {
284 return rindex_pile($p, 'titre_gis', 'gis');
288 * Balise #DESCRIPTIF_GIS : retourne le descriptif du point
289 * Necessite le critere {gis} sur la boucle
291 * @param unknown_type $p
293 function balise_descriptif_gis_dist($p) {
294 return rindex_pile($p, 'descriptif_gis', 'gis');
298 * Balise #ADRESSE_GIS : retourne l'adresse du point
299 * Necessite le critere {gis} sur la boucle
301 * @param unknown_type $p
303 function balise_adresse_gis_dist($p) {
304 return rindex_pile($p, 'adresse_gis', 'gis');
308 * Balise #PAYS_GIS : retourne le pays du point
309 * Necessite le critere {gis} sur la boucle
311 * @param unknown_type $p
313 function balise_pays_gis_dist($p) {
314 return rindex_pile($p, 'pays_gis', 'gis');
318 * Balise #CODE_PAYS_GIS : retourne le code pays du point
319 * Necessite le critere {gis} sur la boucle
321 * @param unknown_type $p
323 function balise_code_pays_gis_dist($p) {
324 return rindex_pile($p, 'code_pays_gis', 'gis');
328 * Balise #VILLE_GIS : retourne la ville du point
329 * Necessite le critere {gis} sur la boucle
331 * @param unknown_type $p
333 function balise_ville_gis_dist($p) {
334 return rindex_pile($p, 'ville_gis', 'gis');
338 * Balise #REGION_GIS : retourne la région du point
339 * Necessite le critere {gis} sur la boucle
341 * @param unknown_type $p
343 function balise_region_gis_dist($p) {
344 return rindex_pile($p, 'region_gis', 'gis');
348 * Balise #DEPARTEMENT_GIS : censé retourner le département du point
349 * Necessite le critere {gis} sur la boucle
351 * @param unknown_type $p
353 function balise_departement_gis_dist($p) {
354 return rindex_pile($p, 'departement_gis', 'gis');
358 * Balise #CODE_POSTAL_GIS : retourne le code postal du point
359 * Necessite le critere {gis} sur la boucle
361 * @param unknown_type $p
363 function balise_code_postal_gis_dist($p) {
364 return rindex_pile($p, 'code_postal_gis', 'gis');
368 * Définition du fond de carte à utiliser par défaut en prenant compte les defines
370 function gis_layer_defaut() {
371 $defaut = 'openstreetmap_mapnik';
372 if (defined('_GIS_LAYER_DEFAUT_FORCE')) {
373 return _GIS_LAYER_DEFAUT_FORCE
;
375 if (defined('_GIS_LAYER_DEFAUT')) {
376 $defaut = _GIS_LAYER_DEFAUT
;
378 $config = lire_config('gis/layer_defaut');
379 return $config ?
$config : $defaut;
384 * Recuperer les cles primaires du env pour l'appel a l'url json des points
388 function gis_modele_url_json_env($env) {
390 if (is_string($env)) {
391 $env = unserialize($env);
394 // d'abord toutes les cles primaires connues
395 $tables_sql = lister_tables_objets_sql();
396 foreach (array_keys($tables_sql) as $table) {
397 $primary = id_table_objet($table);
398 if (isset($env[$primary])) {
399 $contexte[$primary] = is_array($env[$primary]) ?
$env[$primary] : trim($env[$primary]);
402 // puis cas particuliers et ceux ajoutés par le pipeline
403 $keys = pipeline('gis_modele_parametres_autorises', array('objet', 'id_objet', 'id_secteur', 'id_parent', 'media', 'recherche', 'mots', 'pays', 'code_pays', 'region', 'departement', 'ville', 'code_postal', 'adresse'));
404 foreach ($keys as $key) {
405 if (isset($env[$key])) {
406 $contexte[$key] = is_array($env[$key]) ?
$env[$key] : trim($env[$key]);
415 * Transforme un paramètre d'entrée en tableau
416 * s'il n'en est pas déjà un.
418 * Permet d'utiliser dans l'appel au modèle de carte gis
419 * depuis un texte d'article des paramètres tabulaires,
420 * tel que des identifiants de documents de tracés kml,
421 * tel que `<carte_gis|kml=10,11,12>`
423 * @example `#ENV{kml}|gis_param_to_array`
425 * @param string|int|array $param
426 * Le paramètre à transformer en tableau
428 * Le séparateur utilisé
431 function gis_param_to_array($param, $sep = ',') {
432 if (is_array($param)) {
435 // enlever les espaces et exploser
436 $tab = explode($sep, trim((string)$param));
437 // enlever les champs vides, les espaces sur chaques champs.
438 return array_map('trim', array_filter($tab));
442 * Transformer le tableau de kml en tableau d'urls :
443 * si numerique c'est un id de document
444 * si chaine c'est une url qu'on rapatrie en local
448 function gis_kml_to_urls($kml) {
449 if ($kml and count($kml)) {
450 include_spip('inc/filtres_mini');
451 include_spip('inc/distant');
452 foreach ($kml as $k => $v) {
453 if (is_numeric($v)) {
454 $kml[$k] = url_absolue(generer_url_entite($v, 'document'));
456 $kml[$k] = _DIR_RACINE
.copie_locale($kml[$k], 'modif');
464 * Retourne les propriétés JSON de l'icône d'un point
467 * Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
469 * Les propriétés de l'icône
471 function gis_icon_properties($img = '') {
475 if (largeur($img) >= 44) {
476 $icon = extraire_attribut(filtrer('image_graver', filtrer('image_recadre', filtrer('image_passe_partout', $img, 32, 32), 32, 32, 'center', 'transparent')), 'src');
478 $icon = extraire_attribut($img, 'src') ?
extraire_attribut($img, 'src') : $img;
481 $icon = find_in_path('images/marker_defaut.png');
485 $props .= ",\n\t\t\t\"icon\": ". json_encode(url_absolue($icon)).',';
486 list($h,$w) = taille_image($icon);
487 $props .= "\n\t\t\t\"icon_size\": ". json_encode(array($w,$h)).',';
489 * Si l'icone est carrée, on considère que c'est soit un point soit un carré qui pointe un lieu et non une "goutte"
490 * On centre donc au milieu de l'icone
493 $props .= "\n\t\t\t\"icon_anchor\": ". json_encode(array($w/2, $h/2)).',';
494 $props .= "\n\t\t\t\"popup_anchor\": ". json_encode(array(0,0));
496 $props .= "\n\t\t\t\"icon_anchor\": ". json_encode(array($w/2, $h)).',';
497 $props .= "\n\t\t\t\"popup_anchor\": ". json_encode(array(1, -round($h/1.2, 2)));
501 if ($shadow = find_in_path('images/marker_defaut_shadow.png')) {
502 $props .= ",\n\t\t\t\"shadow\": ". json_encode(url_absolue($shadow));
503 list($h,$w) = taille_image($shadow);
504 $props .= ",\n\t\t\t\"shadow_size\": ". json_encode(array($w,$h));