Suite

Enregistrement des cartes de dépliant dans la base de données

Enregistrement des cartes de dépliant dans la base de données


J'ai une page Web avec une carte Leaflet, je peux ajouter des marqueurs, des marqueurs de filtre, etc. Ma question est la suivante : comment puis-je le sauvegarder ?

  1. Charger la carte
  2. Ajouter des marqueurs sur la carte
  3. (Facultatif) Filtrez les marqueurs sur la carte
  4. Enregistrez la carte avec les marqueurs qui la placent dans une base de données (tout stockage possible)
  5. Ouvrir la carte dans le navigateur et afficher la même chose que ce que je viens d'enregistrer.

J'ai tout cherché mais c'est trop difficile de le faire des suggestions possibles?


Vous pouvez enregistrer les positions de vos marqueurs, vos coordonnées actuelles sur la carte, etc. dans le stockage local du navigateur. Le stockage local est pris en charge par presque tous les navigateurs modernes, vous pouvez vérifier la disponibilité du stockage local ici.


semble fonctionner sur la plupart des widgets.

Ouvrez un nouveau document RMarkdown. Lorsque vous utilisez RStudio, accédez à Fichier -> Nouveau fichier -> R Markdown . Une fois que vous avez enregistré le fichier, vous pouvez insérer votre code dans un morceau, comme ceci :

Appuyez ensuite sur le bouton Knit HTML au-dessus de la fenêtre de code et votre application s'ouvrira dans un nouveau fichier HTML. Vous pouvez envoyer le fichier par e-mail ou le télécharger sur votre ftp.

J'ai rencontré le même problème et après avoir installé la version Github, le problème a été résolu.

Ma version actuelle est 1.1.0.9000, fonctionnant sur macOS Sierra, RStudio Version 1.1.232 et R 3.4.0

Vous pouvez exporter depuis RStudio ou enregistrer à l'aide de htmlwidgets.

Une autre option utilisant la bibliothèque mapview est :

bibliothèque (mapview) mapshot(m, url = "m.html")

Notez que vous pouvez également définir la sortie sur .png , .pdf ou .jpeg .

Pour enregistrer en tant qu'image « png » ou « jpg » :

Les deux solutions saveWidget ou mapshot fonctionnent correctement (saveWidget semble être plus rapide), cependant, vous devez faire attention à la sélection des couleurs, en particulier dans celles choisies pour les bordures/lignes de polygones car dans la carte stockée toutes les couleurs des bordures ne sont pas dessinées ("grey50 " par exemple est ignoré alors que les couleurs pures comme le "noir" sont dessinées normalement).

Curieusement, ces couleurs sont stockées et affichées correctement lorsqu'elles sont utilisées comme couleur de remplissage.


Data Scientist en tant que cartographe : une introduction à la création de cartes interactives en R avec Leaflet

Noter: Cette version de l'article contient des images statiques de cartes générées avec Leaflet. Pour voir une version avec des cartes interactives, cliquez ici.

Une caractéristique frappante de nombreuses cartes du début de l'histoire de la cartographie est leur linéarité. Étant principalement destinées aux voyages (et compte tenu des limitations technologiques sur la façon dont les géographies pouvaient être comprises et affichées fidèlement), les cartes des siècles passés prenaient souvent la forme de longs rouleaux et de parchemins affichant les caractéristiques ordonnées des routes (quelle rivière serait rencontrée après laquelle village, etc.). Le Tabula Peutingeriana, peut-être la seule carte existante de l'ancien système routier romain, mesure plus de vingt pieds de long malgré une largeur beaucoup plus mince. Il reflète une approche de la cartographie qui traite les cartes comme des itinéraires, comme des schémas ordonnés. La conception linéaire a une fonctionnalité délicieuse : le réalisme géographique que nous attendons d'une carte contemporaine (qui aujourd'hui représenterait le voyage de Denver à Aspen comme une ligne horizontale ?) est soumis au souci pratique de trouver en toute sécurité son chemin de Florence à Rome.

Mais les cartes font bien plus que donner des instructions de voyage de nos jours. Les scientifiques des données et les journalistes les ont mis au travail pour représenter des différences quantitatives dans l'espace et dans le temps, des effets disparates du changement climatique sur les quartiers les plus riches et les plus pauvres au temps que les gens passaient chez eux aux États-Unis au début de la pandémie de COVID-19. À ces fins, la linéarité ne suffira pas : nous n'avons pas besoin de représenter le trajet entre deux points dont nous avons besoin pour représenter des données sur de nombreux domaines simultanément.

Le faire dans R est incroyablement facile avec Leaflet. Leaflet est une bibliothèque JavaScript open source permettant de créer des cartes interactives. Son utilisation est simple : l'utilisateur crée un widget cartographique, puis superpose les entités sur ce widget cartographique jusqu'à ce que l'affichage et l'interactivité soient comme souhaités. (Ce processus semblera familier aux utilisateurs du paquet chéri de la communauté R ggplot2 .)

Dans cet article, je vais passer en revue deux manières courantes de représenter des données sur une carte à l'aide de Leaflet dans R : (1) Définir des régions sur une carte et les distinguer en fonction de leur valeur sur une certaine mesure à l'aide de couleurs et d'ombrages (“choroplèthes,& #8221 ces cartes sont appelées), et (2) marquer des points individuels sur une carte (par exemple, sites de fouilles archéologiques, stades de baseball, lieux de vote, etc.).

Si vous prévoyez de coder avec les exemples ci-dessous, assurez-vous d'installer et de charger le dépliant. Je recommande également d'installer et/ou de charger le package magrittr afin que vous puissiez utiliser l'opérateur pipe ( %>% ) pour enchaîner les fonctions, ce qui simplifie considérablement le processus de création de carte. Installez et/ou chargez également les packages suivants, je les appelle à différents endroits dans le code ci-dessous : rgdal , geojsonio , htmltools , htmlwidgets , stringi et RColorBrewer .

Choroplèthes

L'objectif : Construire un choroplèthe pour représenter le prix moyen de l'électricité (en cents par kilowattheure) dans chacun des 48 États américains contigus (+ DC) en 2018. Les données proviennent de l'US Energy Information Administration, et vous pouvez accédez-y à l'aide du code ci-dessous. 1

Chaque fois que nous travaillons avec Leaflet, nous utilisons la fonction Leaflet() pour initialiser un widget de carte.

L'exécution de m à ce stade chargera simplement un panneau gris dépourvu de toute entité géographique. C'est la coquille creuse de l'éventuel choroplèthe.

Avant de définir nos zones d'intérêt (états) et la couche sur les données (coûts d'électricité), le widget de carte a besoin d'un “basemap” pour servir de base. Les fonds de carte se composent de tuiles de carte et de sections de carte individuelles qui se rejoignent pour former une image composite. Nous ajoutons un fond de carte au widget de carte avec la fonction addTiles(). L'exécuter sans ajustement se traduira par une vue aérienne du monde entier. Étant donné que les données disponibles concernent les États américains, la carte doit être centrée sur l'Amérique : la fonction setView() permet à un utilisateur de spécifier une longitude (est-ouest) et une latitude (nord-sud) pour servir de centre initial de la carte. (Le centre géographique des États-Unis contigus ? Non loin de la frontière Kansas-Nebraska.)

Par défaut, addTiles() génère un fond de carte à l'aide de tuiles OpenStreetMap. Ils conviennent, mais les options de tuiles à utiliser sont nombreuses. Consultez une longue liste ici. J'ai un faible pour la simplicité délavée des tuiles ‘CartoDB.PositronNoLabels’, donc je vais les utiliser dans les cartes qui suivent. Vous pouvez utiliser addProviderTiles() au lieu de addTiles() pour choisir parmi un ensemble prédéfini d'options tierces, ou vous pouvez appeler un ensemble de tuiles à partir d'une URL en fournissant un lien dans addTiles()

Avec cela, nous avons un fond de carte. Mais nous devons représenter chaque état comme une zone distincte que nous pouvons associer à un coût d'électricité. Nous pouvons alimenter Leaflet les données spatiales nécessaires en utilisant fichiers de formes. Le Census Bureau est une excellente source de fichiers de formes pour les États-Unis, et les fichiers de formes qu'il propose couvrent de nombreux niveaux de granularité géographique (États, comtés, districts scolaires, districts du Congrès, etc.).

Pour ces cartes, nous utiliserons le fichier de formes des États américains du Census Bureau 2019 1:5,000,000, que vous pouvez directement télécharger ici. Le fichier que vous aurez besoin de lire se termine par .shp, et vous pouvez le lire avec readOGR() à partir du package rgdal. (Remarque : le dossier que vous téléchargez à partir du Census Bureau contiendra d'autres fichiers & mdash.dbf, .shx et plus encore & mdashin en plus du fichier .shp. Vous devrez conserver ces fichiers dans le même répertoire à partir duquel vous lisez le fichier .shp. Vous pouvez en savoir plus sur la structure des fichiers de formes ici.)

Le fichier de formes (qui a été affecté aux états de l'objet) est du type d'objet “SpatialPolygonsDataFrame,” et avec lui, nous pouvons maintenant définir chaque état sur le fond de carte à l'aide de la fonction addPolygons() :

Nous devons en quelque sorte combiner les données sur les prix de l'électricité ( dat ) avec le fichier de formes ( états ). Notez, cependant, que le shapefile contient 56 éléments, alors que dat en contient 51. Qu'est-ce qui donne ? Le fichier de formes du Census Bureau contient des données géospatiales pour quelques zones en plus des 50 États + DC, comme Guam. Comme nous n'avons pas besoin de conserver ces régions dans le choroplèthe des 48 états contigus + DC, nous pouvons les supprimer pendant le processus de fusion. Nous fusionnerons les données et les états en fonction de la variable partagée NAME , qui contient les noms d'état dans les deux objets. Il est prudent, cependant, de confirmer que les conventions de nommage des états sont identiques pour les deux objets : par exemple, l'un pourrait-il répertorier la capitale nationale sous le nom de « Washington, DC » tandis que l'autre l'intitulera « Washington », DC”? Vérifier cela est assez simple. Le code suivant évalue si chaque élément de dat$NAME est contenu dans states$NAME if TRUE &mdashas nous voyons que l'expression is&mdashnous savons que chaque nom d'état répertorié dans les données de coût d'électricité ( dat ) peut être mis en correspondance avec un nom d'état dans le shapefile (états).

Maintenant, nous fusionnons. En incluant all.x = F comme argument, nous spécifions que les éléments d'états qui n'ont pas de correspondance dans dat (par exemple, Guam) ne doivent pas être conservés dans l'objet fusionné. Nous pouvons également aller de l'avant et supprimer Hawaï et l'Alaska du cadre de données fusionné, car ils ne seront pas représentés dans le choroplèthe final.

L'ombrage et la coloration sont ce qui fait d'un choroplèthe un choroplèthe, nous devons donc définir quelques règles de coloration. Pour mapper les couleurs sur des valeurs continues, utilisez colorNumeric() , en spécifiant la palette de couleurs vers laquelle les valeurs doivent être mappées et les valeurs. Ici, j'utilise la palette “Blues” de RColorBrewer .

Alternativement, nous pouvons mapper les couleurs sur des groupes de valeurs au lieu de le faire en continu. Dans les données sur les coûts de l'électricité, les valeurs vont de

19 centimes. Nous pouvons diviser cette gamme en bacs colorables discrets :

colorNumeric() et colorBin() génèrent chacun un une fonction à utiliser lors de la création d'un choroplèthe, les fonctions prennent une valeur et renvoient une couleur. Les états de ce choroplèthe seront colorés à l'aide de la fonction continue, nous insérons donc paletteNum() dans la fonction addPolygons() ci-dessous. (Plusieurs autres arguments ont également été ajoutés à addPolygons() pour ajuster l'esthétique de l'intrigue.)

Et voilà, nous avons un choroplèthe. Mais ceci est incomplet : nous n'avons aucune information de légende (quelle nuance représente un état coûteux ?), aucune étiquette d'état, et l'étendue de l'interactivité offerte par cette carte consiste à effectuer un zoom avant et arrière et à faire glisser la vue.

Pour les étiquettes : nous utiliserons sprintf() en combinaison avec lapply() et HTML() (à partir de htmltools ) pour générer une étiquette formatée et étiquetée HTML pour chaque état. 2 L'instruction cbind() coud les étiquettes sur les objets états. Les étiquettes peuvent être incluses dans le choroplèthe en ajoutant un argument label = dans addPolygons() , et labelOptions = fournit une personnalisation supplémentaire (couleur de l'étiquette, etc.).

Une légende est un ajout facile avec la fonction addLegend() : spécifiez simplement la fonction de palette de couleurs (la fonction que nous avons créée avec colorNumeric() ), les valeurs utilisées pour générer des couleurs pour cette fonction, une position (par exemple, ‘topleft&# 8217), et un titre. (Voir ?addLegend() pour des options supplémentaires.)

Enfin, nous tirerons parti des fonctionnalités d'interactivité de Leaflet en ajoutant un argument HighlightOptions = dans le cadre de addPolygons() . Cela nous permet de définir une réponse pour des sections de la carte lorsqu'un curseur passe dessus. Nous allons garder les choses simples : lors du survol de la souris, les états seront soulignés par une ligne bleue.

L'utilisation d'un choroplèthe dans ce cas est un service pour les personnes qui s'intéressent à vos données : pourquoi les obliger à parcourir une feuille de calcul alors qu'une carte est beaucoup plus digeste ?

Il existe plusieurs options pour exporter et enregistrer la carte interactive, notamment :

  • Intégrer la carte dans un document HTML R Markdown
  • Intégrez la carte dans une application Shiny (cela dépasse le cadre de cette introduction, mais l'intégration Shiny est un plus pour l'utilisation de Leaflet dans R)
  • Exportez la carte sous forme de fichier HTML directement depuis RStudio Viewer
  • Utilisez la fonction saveWidget() du package htmlwidgets ou save_html() de htmltools :

Marqueurs de carte individuels

Les polygones prononcés et les couleurs gaies d'un choroplèthe sont utiles pour afficher des données pertinentes pour des régions entières. Mais les points individuels ont leur place, et Leaflet rend à nouveau leur tracé indolore. Pour expliquer comment procéder ici, j'utiliserai un ensemble de données géré par James Fee (cageyjames sur GitHub) contenant les latitudes et les longitudes des stades de baseball professionnels du monde entier. En novembre 2020, il y avait plus de 500 ballparks répertoriés dans data&mdashplenty pour nos besoins. (Vous pouvez en savoir plus sur l'ensemble de données ici. 3

Ces données se présentent sous la forme d'un fichier GeoJSON (GeoJSON est un autre format de stockage de données géospatiales, similaire aux fichiers de formes de recensement utilisés ci-dessus). Vous pouvez utiliser le code ci-dessous pour lire les données (version novembre 2020) à l'aide de geojson_read() du package geojsonio. Je fais également un peu de nettoyage et de prétraitement des données dans les lignes ci-dessous si vous suivez dans R, assurez-vous de les exécuter.

Chaque parc de baseball a une latitude ( Lat ) et une longitude ( Long ) associées. Pour le choroplèthe ci-dessus, les latitudes et les longitudes dans le fichier de formes définissent ici les limites d'état, ces valeurs sont utilisées pour identifier des points uniques. Pour tracer ces points, nous adoptons le même processus général qu'auparavant : initialiser un widget de carte, ajouter des tuiles de fond de carte, définir les paramètres de vue, puis ajouter des couches contenant nos données d'intérêt. Nous pouvons tracer des points de différentes manières. Ci-dessous se trouve le cas le plus simple : échangez simplement dans addMarkers() (en spécifiant les variables de longitude et de latitude) où nous aurions utilisé addPolygons() dans le choroplèthe.

Nous avons maintenant marqué chaque stade sur la carte. Mais ils sont actuellement non identifiables, alors ajoutons des étiquettes sous la forme de fenêtres contextuelles interactives qui apparaissent lorsque quelqu'un clique sur un marqueur donné. Nous suivons un processus similaire à celui utilisé lors de l'étiquetage des états dans le choroplèthe :

Les marqueurs en forme de larme font l'affaire, mais nous ne sommes pas limités à eux. Considérez, par exemple, l'utilisation de marqueurs de cercle en appelant addCircleMarkers() au lieu de addMarkers() . De plus, nos cartes peuvent être beaucoup plus dynamiques et flexibles que la carte ci-dessus. Disons que nous voulions pouvoir afficher indépendamment les champs Major League, Double-A et Triple-A. Dans ce cas, nous pouvons ajouter chaque ensemble de parcs comme son propre calque et ajouter des fonctionnalités interactives avec addLayersControl() pour permettre à chaque calque d'être activé ou désactivé.

Les données sont plus utiles lorsqu'elles sont communicables, et lorsqu'il s'agit de données pouvant être organisées géospatialement, les cartes maximisent la communicabilité. Par rapport à un ensemble de marqueurs sur une carte ou un choroplèthe avec des régions bien délimitées, les lignes et les colonnes peuvent être opaques. Pour s'orienter à travers l'Empire romain dans l'Antiquité, on pouvait s'appuyer sur la Tabula Peutingeriana pour s'orienter dans un monde de données, on pouvait s'appuyer sur Leaflet.

Liens utiles et notes supplémentaires :

  • Les fichiers de formes du Census Bureau pour les zones d'intérêt fréquent (États, comtés, etc.) sont accessibles ici.
  • L'équipe RStudio a mis en place un site Web complet sur le paquet de brochures ici.
  • Au lieu d'appeler data = . dans addPolygons() / addMarkers() /etc., vous pouvez également spécifier un objet de données immédiatement dans l'instruction d'initialisation du widget map-foliget ( m <- leafet(data = . ) %>% . ).
  • Le package de cartes contient un assortiment utile de fichiers de formes pour une gamme de zones géographiques (par exemple, les villes du monde en Italie avec des populations de plus de 40 000 aux États-Unis, etc.). L'appel de données géospatiales à partir de ce package peut vous éviter une étape d'importation de fichier de formes.
  • Le package tigris (CRAN GitHub) vise à fournir des fonctionnalités similaires à celles des cartes en permettant aux utilisateurs de télécharger et d'appeler directement les fichiers de formes du US Census Bureau. Cependant, à compter du 1er novembre 2020, la version actuelle du package n'est pas fonctionnelle. Une fois ses erreurs résolues, ce devrait être un outil pratique.

Pour toute question ou clarification concernant cet article, contactez UVA Library StatLab : [email protected]

Voir toute la collection d'articles UVA Library StatLab.

1. Source : US Energy Information Administration. La version des données sur les coûts d'électricité de 2018 utilisées ici est à jour en novembre 2020.↩

2. Un guide de base sur le formatage de texte avec des balises HTML est ici, et un chapitre utile sur l'utilisation de sprintf() pour créer des chaînes de caractères formatées est ici.↩

3. L'ensemble de données, GeoJSON-Ballparks, est mis à disposition et utilisé selon les termes de la licence d'attribution Open Data Commons.↩


Premiers pas avec CyberGIS

Ce cours est destiné à initier les étudiants à CyberGIS - Geospatial Information Science and Systems (GIS) - basé sur une cyberinfrastructure avancée ainsi que sur l'état de l'art en matière de calcul haute performance, de big data et de cloud computing dans le contexte de la science des données géospatiales. . L'accent est mis sur l'apprentissage des avancées de pointe du cyberSIG et de ses principes sous-jacents de science des données géospatiales.

Олучаемые навыки

Géovisualisation, Programmation Python, Science des données géospatiales, Systèmes d'information géographique (SIG), CyberGIS

Dans ce module, les étudiants seront initiés aux techniques de visualisation géospatiale et de cartographie Web à l'aide de Python. Tout d'abord, nous allons apprendre les bases du traçage de données géospatiales et de la création de cartes à l'aide de Matplotlib, Basemap et Cartopy. Ensuite, nous apprendrons des techniques pour créer et partager nos cartes Web à l'aide des bibliothèques Mplleaflet et Folium. Enfin, nous verrons une brève introduction à GeoPandas et comment l'utiliser pour faire un tracé simple, une géométrie simple et effectuer des opérations spatiales de base.


Dépliant Cartographie SIG mobile

Êtes-vous un développeur d'applications mobiles Full Stack ou un expert SIG qui souhaite créer un mobile multiplateforme interactif et esthétique Applications de cartographie SIG vite? Si oui, alors vous êtes venu à l'endroit que vous cherchiez.

Pourquoi utiliser Leaflet et Flutter pour créer des applications de cartographie SIG mobiles ? Leaflet est une bibliothèque JavaScript avec une petite empreinte d'environ 39 Ko qui possède les fonctionnalités de cartographie dont vous aurez besoin dans vos projets de cartographie. Il a été conçu avec simplicité, performance et convivialitéà l'esprit et fonctionne très bien sur les plates-formes mobiles et de bureau. Ces caractéristiques ont fait de Leaflet la confiance de sociétés telles que Flickr, Facebook, The Washington Post et Foursquare.

Flutter utilise un langage déclaratif d'interface qui vous permettra de développer rapidement des interfaces utilisateur élégantes et fluides à l'aide des outils de conception de matériaux Google. De plus, il utilise une base de code unique pour les plateformes Android et iOS cela vous fera gagner du temps et des efforts sans sacrifier les performances de l'application. Vous allez également augmenter le temps de la vitesse du marché à cause de Rechargement à chaud fonctionnalité qui applique les modifications presque instantanément, sans perdre l'état actuel de l'application et parce que le framework fournit une variété de widgets prêts à l'emploi.

Une approche pratique a été utilisée pour dispenser le cours en élaborant un application laitière mobile pour relier les producteurs laitiers et les clients. L'application sera construite à partir de zéro ligne par ligne. De plus, le cours a été conçu avec des devoirs engageants à la fin des sections qui ont une composante de codage. L'approche vise à fournir une maîtrise pratique des compétences de cartographie SIG Leaflet à l'aide de Flutter.

À la fin du cours, vous aurez acquis des compétences pratiques en cartographie de fiches SIG mobiles qui vous permettront de développer des applications qui comprendront Recherche des contacts, cartographie des itinéraires de transport, gestion immobilière, cartographie de la criminalité et localisation des clients


Installer les packages R pour la gestion des données spatiales et GeoJSON

Pour effectuer toutes les opérations ci-dessous, vous devrez d'abord installer les packages R suivants.

  • rgdal — pour importer des Shapefiles vers R en tant que bloc de données spatiales.
  • spdplyr — pour manipuler les données attributaires à l'intérieur du bloc de données spatiales.
  • geojsonio — pour convertir la trame de données spatiales en GeoJSON et l'enregistrer dans des systèmes de fichiers.
  • rmapshaper — pour manipuler la partie géométrique (polygone, ligne, marqueur) des données GeoJSON.

Une analyse démographique qui donne un vrai aperçu

Vous pouvez utiliser des données démographiques pour évaluer la pénétration du marché. Le logiciel peut comparer le nombre de clients que vous avez dans chaque zone avec le nombre de clients potentiels que vous pourriez avoir. Il fera alors automatiquement une carte ombrée. Une pénétration élevée du marché est affichée dans une couleur et une faible pénétration est affichée dans une autre couleur, de sorte que vous pouvez immédiatement voir où vous vous en sortez bien. Vous pouvez cibler des zones où la pénétration est faible, mais les caractéristiques de la population sont similaires à celles des zones où vous vous débrouillez bien. Ces zones sont susceptibles d'avoir des prospects qui sont très susceptibles d'utiliser vos produits ou services. Vous pouvez utiliser le profilage de quartier (également appelé segmentation démographique) pour affiner votre analyse.


Le manuel d'archéologie numérique ouverte

Une carte Web est une visualisation géographique prise en charge par des infrastructures informatiques. Cette forme de cartographie est fondamentalement alimenté par le Web Axismap, 2018. Il n'est pas surprenant que l'omniprésence des cartes Web soit en corrélation avec le développement du Web 2.0, une transformation marquée de la manière dont nous interagissons avec Internet (Aced 2013) .

Comme le remarquait Darcy DiNucci en 1999, le chargement de contenu dans un navigateur en tant que « écrans statiques n'est qu'un embryon du Web à venir » (DiNucci 1999) . Le Web 2.0 se caractérise donc par une « interactivité », une « communication bidirectionnelle » souvent via des appareils « compatibles avec Internet » et une plus grande sensibilisation des développeurs à « l'expérience utilisateur » et à « l'interface ». Ces intérêts sont corrélés à la diversification des tailles d'écran sur les appareils portables tels que les téléphones intelligents, les tablettes et les ordinateurs portables, qui nécessitent tous une réactivité, une mise à l'échelle appropriée pour la taille et une interaction principalement via le toucher et le glissement. Alors que la première itération du Web nécessitait une formation avancée pour créer un site Web, le Web 2.0, comme on le prétend souvent, nécessite peu ou pas de connaissances spécialisées pour créer une « chose » prête pour le Web, comme un site Web, un blog ou un wiki. C'est dans ce contexte que la cartographie Web, c'est-à-dire la visualisation Web des informations géographiques, s'est popularisée.

On peut affirmer que les cartes Web réduisent la distance entre les cartographes professionnels et les non-spécialistes, mais certains chercheurs ont exprimé des inquiétudes quant à la qualité des données géographiques qui sont maintenant fréquemment et largement partagées sur le Web (M. van Exel 2010) . Les plates-formes collaboratives en ligne telles qu'OpenStreetMap, par exemple, ont attiré l'attention sur la dimension sociale de la connaissance, ce qui rend les informations téléchargées par un profane ou une communauté d'intérêt particulier ? Pouvons-nous prendre des décisions concrètes sur la base de ces données ? Begin et al. suggèrent que les informations géographiques fournies volontairement reflètent la motivation des contributeurs et les préférences individuelles dans la sélection des entités cartographiées et la délimitation des zones cartographiées, une situation qui peut permettre aux chercheurs d'examiner et d'évaluer la qualité de ces données (Daniel Bégin 2013) .

Pour les archéologues, les cartes Web et la publication d'informations géographiques présentent des défis et des opportunités. Les archéologues sont conscients que les données qu'ils recueillent au moyen d'études sur le terrain contiennent souvent des informations de localisation sensibles. Ces préoccupations sont parfois exacerbées dans des contextes de tensions entre les archéologues et les communautés locales ou les minorités ethniques et linguistiques qui pourraient être socialement, politiquement et économiquement marginalisées dans cette société. Les archéologues s'inquiètent souvent du fait que la publication d'informations de localisation sur des sites d'intérêt archéologique et historique puisse faciliter, voire entraîner, la destruction de ces sites par le pillage. Le pillage et le trafic illégal d'artefacts archéologiques et d'ossements humains est un problème observé dans de nombreux endroits (Neil Brodie 2001, Huffer et Graham (2017) ) .

Les développements récents de l'analyse géovisuelle qui exploitent la dimension spatiale des données suggèrent que les chercheurs peuvent travailler avec et analyser de manière significative ces données même lorsqu'elles contiennent des informations de localisation sensibles (G. Andrienko et al. 2007) . Cette situation ouvre d'énormes possibilités aux archéologues de développer des outils appropriés pour une analyse et une publication significatives des données archéologiques. Dans la section suivante, nous nous appuyons sur l'éthique de « l'ouverture » ​​et présentons un aperçu des services cartographiques, suivi d'un guide pour créer une carte Web interactive avec la bibliothèque Leaflet. Pour un exemple de carte Web Leaflet, consultez Open Context.

3.5.1 Présentation des services de carte

Le service de carte en mosaïque et le service de carte Web sont deux formes de cartographie Web. Un WMS est une interface qui nous permet (les clients) de demander des cartes spécifiques, c'est-à-dire des représentations visuelles d'informations géographiques à partir d'une base de données géospatiale. Le serveur WMS est appelé via une URL (Universal Resource Link) sur un SIG de bureau compatible Internet. Une demande se compose généralement de la couche géographique (par exemple, le thème) et de la zone géographique d'intérêt. La réponse à une demande entraîne images de carte géo-enregistrées qui sont affichés et interrogés dans un navigateur. Étant donné que la carte est dessinée dynamiquement sur demande et que le serveur utilise généralement les informations les plus récentes de plusieurs couches de la base de données géospatiale, les cartes WMS ont tendance à se charger lentement. Toporama est un exemple de serveur WMS pour les thèmes topographiques canadiens. (ajouter une image pour l'architecture WMS ?)

Les services de carte en mosaïque tels que TillMill Project, OpenStreetMap, CartoDB et Stamen utilisent tous une ou plusieurs couches vectorielles qui ont été pixellisées en une image. Cette image rastérisée est divisée en 256 x 256 images de pixels adjacents ou « tuiles ». Il s'agit généralement de la couche de base d'une carte Web.

Chaque vignette est une image sur le Web, ce qui signifie que vous pouvez y accéder. Par exemple, l'URL suivante pointe vers une vignette spécifique sur le Web :

Les trois éléments de l'URL sont : 1. tile.openstreetmap.org , le nom du serveur de tuiles 2. 7 , le niveau de zoom ou la valeur z de la tuile et enfin 3. 63/42 , les valeurs x et y dans la grille où la tuile vit

La valeur z est comprise entre 0 et 21, où 21 renvoie une tuile avec le plus de détails (et la plus petite tuile de taille).

Une fois généré, l'ensemble de tuiles est stocké sur disque, prêt à être distribué rapidement à un grand nombre de requêtes simultanées. Les cartes en mosaïque se chargent rapidement précisément parce qu'elles sont pré-générées. Ils portent l'attention sur l'esthétique de la carte et la fluidité de la navigation sur la carte, en échangeant des fonctionnalités telles que l'ordre des couches, l'échelle de la carte et la projection. Alex Urquhart maintient une liste de services de tuiles.

Les couches de données sont généralement ajoutées au-dessus de la couche de base. Les couches de données peuvent être des points, des lignes et des polygones. Ces couches de données sont enregistrées au format GeoJSON, un format conçu pour représenter sur le Web des entités géographiques avec leurs attributs non spatiaux.

3.5.2 Créer une carte Web avec Leaflet

Leaflet est une bibliothèque JavaScript développée par Vladimir Agafonkin pour une utilisation avec des cartes en mosaïque. Lancé en 2008, Leaflet est devenu largement utilisé dans la cartographie Web de tuiles en raison de la personnalisation et de l'interactivité à faible barrière de la bibliothèque avec les éléments de la carte, et en raison de sa configuration simplifiée par rapport à une carte desservie par WMS. De plus, la compatibilité de Leaflet avec d'autres technologies Web 2.0 et plateformes de partage de code telles que GitHub a encouragé une communauté active de « makers ».

Conformément à l'éthique d'« ouverture » ​​de ce livre électronique et avec une motivation pour encourager la cartographie Web à faible coût et à faible obstacle, vous trouverez ci-dessous un aperçu pour commencer notre propre carte Web interactive avec Leaflet. Nous aurons besoin:

  1. quelques données ponctuelles, idéalement des données géocodées (lat/long) enregistrées au format CSV
  2. un éditeur de texte installé sur la machine locale, comme Atom
  3. un service d'hébergement, tel que GitHub (compte public)
  4. un service de carte en tuiles, comme OpenStreetMap, MapBox (compte gratuit) ou autre
  5. un curieux toi

3.5.3 Exercices

Faire une « chose numérique » peut être excitant et intimidant, et pourtant, voir sa création sur le Web peut être gratifiant. Il est important de réaliser qu'une grande partie du travail pour que cela se produise a lieu sur une machine locale. Par conséquent, la mise en place d'un environnement local avec les outils dont nous avons besoin est fortement encouragée. Nous vous recommandons d'installer un serveur Web local tel que MAMP pour Mac ou WampServer pour Windows pour une utilisation régulière.

Pour cet exercice, nous utiliserons Prepros, une application de préprocesseur temporaire qui recharge notre navigateur local lorsque nous apportons des modifications à notre fichier HTML et nous permet de voir ce qui se passe sans installer de serveur Web dédié.

3.5.3.1 Une simple carte Web Leaflet

  1. Téléchargez la carte Web et décompressez-la à un emplacement connu. Quels fichiers et dossiers voyez-vous ? Il est utile de voir les fichiers et sous-dossiers dans leur structure hiérarchique avant de commencer à les éditer. Apportez le dossier de la carte Web dans Atom. Nous le faisons en « Ajouter un dossier de projet ».

  1. Localisez le fichier nommé index.html et ouvrez-le. Que voyez-vous dans le fichier ? La première ligne nous dit que ce document écrit en html, un langage pour créer des pages Web.

Allez-y et changez le titre

  1. Nous voulons maintenant jeter un œil à notre page Web sur un navigateur local. Démarrons Prepros (cela peut prendre quelques minutes) pour obtenir un aperçu. Ajoutez le dossier de cartes Web en tant que projet, soit par glisser-déposer, soit en utilisant le + en bas à gauche de la fenêtre Prepros.

Faites un clic droit sur le dossier pour « Activer l'aperçu en direct ». Cliquez ensuite sur l'icône globe pour voir la page Web dans le navigateur.

  1. Sur le fichier index.html , recherchez les balises <head> et <body> . Dans l'anatomie d'une page Web, ces sections sont les plus importantes pour créer et charger du contenu.

Dans notre section <head>, nous avons ajouté deux balises, <link> et <script> à la bibliothèque Leaflet. Vous remarquerez que l'URL pointe vers le CDN ou un réseau de diffusion de contenu. Ce sont des serveurs qui hébergent du contenu Web en fonction de notre situation géographique. Dans ce cas, nous demandons une feuille de style CSS ou en cascade hébergée spécifique pour Leaflet et le script Leaflet qui ajoute de l'interactivité à la carte Web.

Le CSS nous donne des styles et des éléments prédéfinis pour formater le contenu d'une page Web, c'est-à-dire que nous obtenons l'apparence d'une carte Leaflet. Il comprend les polices, la taille, la couleur, l'espacement des lignes et des éléments de dépliant comme la carte, ainsi qu'une icône de zoom.

Il est essentiel que CSS se charge avant le script et que les deux soient dans les balises <head></head>.

Votre fichier devrait se lire de cette façon à ce stade :

  1. Ensuite, dans la section <body> de notre page Web, nous ajoutons un élément <div> qui contiendra un élément appelé map .

Nous appelons ensuite le <script> et initialisons notre carte en utilisant L.map .

.setView centre notre carte Web sur des coordonnées spécifiques et à un niveau de zoom particulier. Changez les coordonnées et appuyez sur Enregistrer. Jetez un œil à l'aperçu en direct. Que vois-tu?

Ce code nous dit ce qui suit : 1. https://.tile.openstreetmap.org , le serveur de tuiles que nous voulons, 2. 19 , le niveau de zoom maximum, et 3. '&copy <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>' l'attribution pour ce fournisseur de tuiles

Prenez note de .addTo(map) qui ajoute réellement la couche à notre carte Web, et le </script> ferme ce script particulier. To load additional layers or attribute data, we would add our code within the tags <script></script> which we outline in the next subsection.

At this stage your html reads like this:

Toutes nos félicitations! We have our first Leaflet map. Examine the map in the Prepros preview window.

3.5.3.2 Loading point data onto a Leaflet map

Now that we have a base map set up, we want to load some feature data i.e. points, lines, polygons, onto it. We have a few different ways to add feature data. They can be loaded as a Common Separated Value (CSV) file or a GeoJSON.

In this exercise, we will work with a GeoJSON, a small file (point-data.geojson) with about 20 potential excavation sites. The original CSV had four fields, all of which were converted into GeoJSON using an online tool here.

Fire up a text editor and examine the contents of point-data.geojson . Que vois-tu? Take note of taper, géométrie, et Propriétés. How many properties or attributes are there, what are they?

Next, open index.html . We will now add several lines of code that enable us to grab our GeoJSON data, load them and represent them as markers.

Locate the <head> tag, and the script for loading Leaflet. Below it, add a script called jQuery. This Javascript library is widely used to enable interactivity, animations, plug-ins and widgets. We load jQuery on our web page using the following code after Leaflet.js :

  1. We are now ready to add a few lines to get our GeoJSON (point-data.geojson). In the <body> section, let’s add the following code below your tile layer:

Save the file and preview it in the browser. Toutes nos félicitations! We’ve added our own point feature data to a Leaflet map.

It would be great to have interaction beyond panning and zooming on our web map. One way is to add pop-ups to each of our markers that we can click on.

Locate pointToLayer which we called passed a function. We will create a variable called marker and bind a pop-up to each marker:

At this stage, your html will look similar to this:

  1. C'est ça! We’ve created a web map with our own point data, and we have markers with pop-ups to click on.

3.5.4 Resources

Below are examples in archaeology that use Leaflet that you can try out, and that have repositories that you can fork for your own projects:

  1. The Digital Atlas of Ancient Egypt developed at the Department of Anthropology, Michigan State University: https://msu-anthropology.github.io/daea/

Les références

Aced, Cristina. 2013. “Web 2.0: The Origin of the Word That Has Changed the Way We Understand Public Relations.” International PR 2013 Conference. Images of Public Relations. https://www.researchgate.net/publication/266672416_Web_20_the_origin_of_the_word_that_has_changed_the_way_we_understand_public_relations.

M. van Exel, S. Fruijtier, E. Dias. 2010. “The Impact of Crowdsourcing on Spatial Data Quality Indicators.” Dans Proceedings of Giscience 2011, Zurich, Switzerland, 14–17 September 2010. https://www.researchgate.net/publication/267398729_The_impact_of_crowdsourcing_on_spatial_data_quality_indicators.

Daniel Bégin, Stéphane Roche, Rodolphe Devillers. 2013. “Assessing Volunteered Geographic Information (Vgi) Quality Based on Contributors’ Mapping Behaviours.” International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences. https://www.int-arch-photogramm-remote-sens-spatial-inf-sci.net/XL-2-W1/149/2013/isprsarchives-XL-2-W1-149-2013.pdf.

Neil Brodie, Colin Renfrew, Jennifer Doole, ed. 2001. Trade in Illicit Antiquities: The Destruction of the World’s Archaeological Heritage. Cambridge: McDonald Institute for Archaeological Research.

Huffer, Damien, and Shawn Graham. 2017. “The Insta-Dead: The Rhetoric of the Human Remains Trade on Instagram.” Internet Archaeology. doi:https://doi.org/10.11141/ia.45.5.

Andrienko, Gennady, Natalia Andrienko, Piotr Jankowski, Menno-Jan Kraak, Daniel A. Keim, Alan MacEachren, and Stefan Wrobel. 2007. “Geovisual Analytics for Spatial Decision Support: Setting the Research Agenda.” Revue internationale des sciences de l'information géographique 21 (8): 839–57.


Painting tiles with NumPy and PyPNG

While researching on creating PNG files from Python code, I came across an elegant package: PyPNG. This package can convert NumPy arrays into PNG files, which seems like a great idea. Here is how you create a NumPy array that represents a 256x256 RGBA image, encodable as PNG:

Painting a tile is a simple matter of setting the individual pixel values to the appropriate color. The next function uses the list of pixels, the color gradient, and the suitable zoom range to paint a tile.

Each color value from the gradient list is a NumPy vector with four dimensions, one for each channel component, so setting a pixel is a simple assignment. The function that generates the gradient list also sets the alpha channel value to 50%.

Saving the tile to a PNG formatted file is straightforward with the PyPNG package. The code below illustrates the process. Note the required array reshape before saving.

Finally, the API can serve the tile file by creating a response object around it.


Mapping in R just got a whole lot easier

Would you like to make a color-coded choropleth map in R? Until recently, working with geospatial objects was a bit more complex than with many other types of data. That's because R "Spatial Polygons Data Frames" objects were structured something like this if you ran an R str() command to see their structure:

Screen shot of an R object structure

Structure of a Spatial Polygons Data Frame in R, without simple features

The non-spatial data -- things like unemployment rates that you might want to map by county -- resided in special @data slots, which were unfamiliar to many R users. Slots weren't ce tough to deal with, but they were Yet Another Thing To Learn.

Thanks to the Simple Features for R project, though, it's possible to represent geospatial data in what looks very much like a conventional data frame.

Here's what the same data looks like as a simple features object:

Screen shot of an R object structure

The more human-readable structure of a simple features R object.

The data is now in what appears to be a "regular" R data frame the geospatial data is tucked into a special list column containing geographies. This makes it easy to merge data sets like employment or median wages with a shapefile containing geographies.

I'll show you one way to do this using R simple features, creating a map of median wages for IT managers by state. As is appropriate for pretty much any real-world analysis and visualization, most of the project involves acquiring and cleaning the data. Once the data is in the right format, mapping itself will be a breeze. If you want to skip to the mapping section, head straight to step 4.

First, though, make sure to install and load two mapping packages with:

1. Download geography file of U.S. states and import it into R. (There are several popular geospatial file formats to choose from. For this tutorial, I'll use shapefiles.)

The easiest way to do this is Kyle E. Walker's tigris package.

For this project, you'll need the development version of tigris from GitHub, not the older version available on CRAN, because the CRAN version doesn't yet support simple features. If you've already got the devtools R package on your system, you can install newer tigris with devtools::install_github('walkerke/tigris') . If you don't have devtools, you can either install devtools first, or a lighter-weight GitHub-installation package called remotes. I suggest opting for remotes you can install that on your system with install.packages("remotes") . Next, install tigris with remotes::install_github('walkerke/tigris') and load it with library("tigris") .

To import a shapefile of U.S. states into R with tigris as a simple features object, just run the command:

Note that states() sans pour autant class = "sf" will return a Spatial Polygons Data Frame and not a simple features object.

There's more information about the tigris package's capabilities at the tigris GitHub website.

If you have problems with this, as I occasionally had due to issues with the Census Bureau's API this week, you can download a shape file manually from the bureau's TIGER Cartographic Boundary Shapefiles site here: https://www.census.gov/geo/maps-data/data/cbf/cbf_state.html. Choose the cb_2015_us_state_20m.zip file, download and unzip it.

Or, download and unzip the file within R using the code:

(Assuming the file downloaded into your working directory. If not, make sure to include the full path to your zip file ).

Then read the geographic information into an R object called us_geo with

2. Import the data you want to map. I went to the U.S. Bureau of Labor Statistics Occupational Employment Statistics query page, chose "One occupation for multiple geographical areas," and then picked "Computer and Information Systems Managers" by geographic type State, "All states in this list," "Annual median wage" as the data type, and Excel as the output.

If you open the file, you'll see there are 3 rows of meta data at the top (R will count merged rows 2, 3 and 4 as a single row) and 4 rows at the bottom. I moved the footnotes to a separate tab and skipped the first 3 rows when importing (there's no easy way to skip rows at the end).

I like the rio package for reading in data. If you don't have it, you can install it with install.packages("rio") .

The spreadsheet's column names are somewhat R-unfriendly -- both have spaces in them -- so I'll change them with

More importantly, the wage column imports as character strings, not numbers, I'm guessing because of extra spaces in the data. I trimmed white space and then converted Median.Wages into numbers with

Unfortunately, state names in this data look like "Alabama(0100000)" instead of "Alabama."

There are several ways of getting rid of the (01000000) and similar text in the state names. The most robust way is with a regular expression -- delete anything that's not an alpha character. This code does so:

But if you're not yet ready for regular expressions in R, you could simply count the number of characters in the (#######) portion of each state name -- there are 9 -- and remove that number of characters at the end of each state name. The format for subsetting a string is substr(thestring, startIndex, stopIndex) . Here, we want just the part of the string that starts with the first character and ends with the last character - 9:

Now, data in the wages State column in wages matches state names in the us_geo NAME column.

Finally, get rid of any rows where Median.Wages are unavailable:

Or, if you use the dplyr package (my preference):

3. Merge (join) the geospatial and data files. This is easy with the tmaptools package's append_data() function:

4. Finally, Create your map. This part is incredibly easy with tmap's qtm() (quick theme map) function:

Or with the more robust tmap() function:

The id = "NAME" portion isn't actually necessary for this map, but it's useful for the next step.

For this map, it's a little tough to see the contiguous 48 states because the map is zoomed out to include all of Alaska and Hawaii.

Screen shot of map in R created with tmap package

Static map with all 50 states is a bit difficult to view.

There are a couple of ways to deal with this. For static maps, you can temporarily zoom in by removing Alaska, Hawaii and Puerto Rico (which is what happens if you zoom in to the contiguous 48), with:

and then mapping the contig_48:

Screen shot of static thematic map created in R

Static map of median U.S. wages for computer and IS managers created with the R tmap package.

But the best option for data exploration and Web publication:

5. Create an interactive map with two simple lines of code.

Plot the original version of 50 states plus Puerto Rico again:

To make this interactive, you just need to switch tmap's mode from "plot," which is static, to "view", which is interactive, using the tmap_mode() function:

Then, to re-draw the last map, run last_map() . C'est ça! You should have a zoomable interactive map, where clicking on a state gives data details.

The leaflet R mapping package has many more ways to customize an interactive map than tmap's interactive mode offers. In addition, the leaflet package lets you save interactive maps as stand-alone HTML files. The good news: It's easy to turn a tmap interactive map into a leaflet map object, and then run any additional leaflet functions on it. Save the tmap map to a variable

and then turn it into a leaflet object with the tmap_leaflet() function

With the htmlwidgets package, save the map with saveWidget(my_interactive_map, "mymap.html") . You can see a version of the map below, which I centered and zoomed using leaflet's setView() function after loading the leaflet package:

Interactive map created with tmap and leaflet R packages.

For more on tmap, check out the tmap in a nutshell vignette. For leaflet capabilities, see the leaflet package website.

Sharon Machlis is Executive Editor, Data & Analytics at IDG, where she works on data analysis and in-house editor tools in addition to writing and editing. Her book Practical R for Mass Communication and Journalism was published in December 2018.


An astute observer will notice that the stroke lines (outlines) are not being rendered in these maps. In RStudio the lines appear (see image below). I experimented with opacity, width, color and even within the Chrome developer tools. I tried to save from the RStudio plot window and I tried saveWidget. If you have ideas please let me know.

Rarely is the solution to an issue like this so simple. Thanks to Bob Rudis for pointing out that I should be using the hex codes for colors rather than using named colors so that they can be recognized in a web setting. I’ve made the changes above and it worked perfectly.


Voir la vidéo: Kohteen tallentaminen.