Suite

Convertir JSON en GeoJSON ou CSV ?


Comment convertir un fichier JSON en fichier GeoJSON ou csv. J'ai un fichier JSON avec des informations lat lon, mais comment puis-je convertir ce fichier en GeoJSON ou csv. J'ai trouvé des outils en ligne pour le convertir en csv, mais je souhaite l'utiliser dans un fichier batch, j'ai donc besoin d'un outil.

Le fichier JSON ressemble à ceci :

[ {"date":"2014-09-25","time":"20:49:09","lat":"53.269","lon":"6.935","depth":"3.0", "place":"Meedhuizen","mag":"1.5","type":"GH","last":"True"}, {"date":"2014-09-24","time": "23:49:36","lat":"53.351","lon":"6.693","depth":"3.0","place":"Huizinge","mag":"1.0","type ":"GH","last":"False"}, {"date":"2014-09-23","time":"17:34:48","lat":"53.242","lon ":"6.728","depth":"3.0","place":"Lageland","mag":"1.0","type":"GH","last":"False"} ]

J'espère que quelqu'un pourra aider


Regardez les échantillons sur le site de spécification. Vous devrez écrire un script dans la langue de votre choix qui vous permettra de

[ {"date":"2014-09-25","time":"20:49:09","lat":"53.269","lon":"6.935","depth":"3.0", "place":"Meedhuizen","mag":"1.5","type":"GH","last":"True"}, {"date":"2014-09-24","time": "23:49:36","lat":"53.351","lon":"6.693","depth":"3.0","place":"Huizinge","mag":"1.0","type ":"GH","last":"False"}, {"date":"2014-09-23","time":"17:34:48","lat":"53.242","lon ":"6.728","depth":"3.0","place":"Lageland","mag":"1.0","type":"GH","last":"False"} ]

à

{ "type": "FeatureCollection", "features": [ { "properties": { "last": "True", "place": "Meedhuizen" "time": "20:49:09", "depth" : "3.0", "mag": "1.5", "date": "2014-09-25", "type": "GH" }, "geometry": { "coordinates": [ "6.935", "53.269 " ], "type": "Point" }, "type": "Feature" }, { "properties": { "last": "False", "place": "Huizinge", "time": "23 : 49:36", "depth": "3.0", "mag": "1.0", "date": "2014-09-24", "type": "GH" }, "geometry": { "coordinates" : [ "6.693", "53.351" ], "type": "Point" }, "type": "Feature" }, { "properties": { "last": "False", "place": "Lageland" , "time": "17:34:48", "depth": "3.0", "mag": "1.0", "date": "2014-09-23", "type": "GH" }, "geometry": { "coordinates": [ "6.728", "53.242" ], "type": "Point" }, "type": "Feature" } ] }

en Python, par exemple, j'ai fait ceci :

def convert_json(items): import json return json.dumps({ "type": "FeatureCollection", "features": [ {"type": "Feature", "geometry": { "type": "Point", " coordonnées": [ feature['lon'], feature['lat']]}, "properties": { clé : valeur pour la clé, valeur dans feature.items() si la clé n'est pas dans ('lat', 'lon' ) } } pour la fonctionnalité dans json.loads(items) ] })

Cela peut être fait sur la ligne de commande sans avoir besoin de code en utilisant deux bibliothèques Node.

Installez-les avec :

npm install -g json2csv csv2geojson

Alors simplement :

fichier de chat.json | json2csv | csv2geojson > fichier.geojson

Vous pouvez essayerogr2ogr(de GDAL) et jq, qui sont assez omniprésents, du moins sur les dérivés de Linux.

1/ convertir de json en csv en utilisantjq:

chat input.json | jq -r '(map(keys) | add | unique) as $cols | map(. as $row | $cols | map($row[.])) as $rows | $cols, $rows[] | @csv' > input.csv $ cat input.csv "date","profondeur","dernier","lat","lon","mag","lieu","heure","type" "2014- 09-25","3.0","True","53.269","6.935","1.5","Meedhuizen","20:49:09","GH" "2014-09-24","3.0 ","Faux","53.351","6.693","1.0","Huizinge","23:49:36","GH" "2014-09-23","3.0","Faux"," 53.242","6.728","1.0","Lageland","17:34:48","GH"

2/ Créez un fichier virtuel (VRT) pour votre CSV

  entrée.csv wkbPoint WGS84 

3/ Convertissez votre VRT en GeoJSON

ogr2ogr -f GeoJSON output.geosjon input.vrt input

Commençant pargdal2.1, vous pouvez convertir directement de json en geojson (non testé)


Besoin de conseils sur l'outil à choisir ? Demandez à la communauté StackShare !

GeoJSON : Un format pour coder une variété de structures de données géographiques. Il s'agit d'un format standard ouvert conçu pour représenter des entités géographiques simples, ainsi que leurs attributs non spatiaux. Il est basé sur JSON, la notation d'objet JavaScript. Les caractéristiques comprennent des points, des chaînes de lignes, des polygones et des collections en plusieurs parties de ces types JSON : Un format d'échange de données léger. JavaScript Object Notation est un format d'échange de données léger. Il est facile pour les humains de lire et d'écrire. Il est facile pour les machines d'analyser et de générer. Il est basé sur un sous-ensemble du langage de programmation JavaScript.

GeoJSON et JSON appartiennent à "Langues" catégorie de la pile technologique.

Salut. Actuellement, je dois créer un nouveau fichier JSON basé sur le fichier CSV d'entrée, valider le fichier JSON généré et télécharger le fichier JSON dans l'application (qui s'exécute dans AWS) à l'aide de l'API. Veuillez suggérer la meilleure langue pouvant répondre à l'exigence ci-dessus. Je pense que Python sera meilleur, mais je ne suis pas sûr de la justification du pourquoi python. Pouvez-vous donner votre avis à ce sujet ?

Python est très flexible et fait définitivement le job (même si, en réalité, n'importe quel langage sera capable de faire face à cette tâche !). Python a de bonnes bibliothèques intégrées, ainsi que des bibliothèques tierces qui vous aideront ici. 1. Convertir CSV -> JSON 2. Valider par rapport à un schéma 3. Déployer sur AWS

  1. Les éléments intégrés incluent les bibliothèques json et csv et, selon la complexité du fichier csv, il est assez simple à convertir :

La partie validation est bien gérée par cette bibliothèque : https://pypi.org/project/jsonschema/ Elle vous permet de créer un schéma et de vérifier si ce que vous avez créé fonctionne pour ce que vous voulez faire. Il est basé sur la norme de schéma json, permettant l'annotation et la validation de n'importe quel json

Il s'agit d'une bibliothèque AWS pour automatiser le téléchargement - ou en fait faire à peu près n'importe quoi avec AWS - à partir de votre base de code : https://aws.amazon.com/sdk-for-python/ Cela gérera l'authentification auprès d'AWS et le téléchargement / déployer le fichier là où il doit aller.

Cela dépend beaucoup des deux dernières pièces, mais la conversion elle-même est vraiment très soignée.


Forfaits requis

En plus d'Altair, que je vous recommande de suivre les instructions d'installation ici, nous utiliserons les packages ci-dessous pour cette démonstration.

Demandes - Afin d'extraire le GeoJSON géopolitique DC du site Web Open Data DC.

Pandas - Afin de lire les données de population DC nettoyées que nous ajouterons en tant que couche choroplèthe sur notre carte

Geopandas - Afin de joindre la population DC et les données GeoJSON ensemble

JSON - Afin de convertir la trame de données Geopandas en JSON, ce qui est requis par Altair. Plus de contexte sur l'incompatibilité d'Altair Geopandas peut être trouvé ici.

Un fichier d'exigences complet se trouve sur mon GitHub ici.


Conversion de CSV en GeoJSON avec 2 jeux de coordonnées dans chaque ligne

Salut tout le monde, j'ai des données Divvy Bikeshare avec lesquelles certains collègues et moi prévoyons de générer une carte thermique basée sur l'activité par heure à chaque station de vélo.

Chaque trajet a un "to_lat" "to_long" et "from_lat" "from_long"

Si quelqu'un a des astuces, des outils ou des convertisseurs qui me manquent, faites-le moi savoir. Les outils CSV vers GeoJSON semblent fonctionner uniquement lorsqu'il existe un seul ensemble de coordonnées

GeoJSON est un format vraiment facile à écrire.

DM moi si vous ne faites pas Python et je le convertirai pour vous.

recherchez sur google un aplatissement JSON (aplati est ce que vous avez en tant que csv)

C'est peut-être le bon moment pour apprendre le python et voir si vous pouvez créer des collections en mémoire des stations, des balades à vélo, etc.

La programmation IMO est un outil incroyablement utile lorsque vous souhaitez travailler "rapidement" avec certaines données et ne pas commettre d'erreurs dues à la répétition, etc.

Cela demande de la pratique, mais mieux vous y arriverez, plus vite vous pourrez faire avancer les choses, avec moins d'erreurs.

Pas besoin d'écrire de code. Utilisez Radian/Manifold Future. Ou, totalement gratuitement, utilisez la visionneuse gratuite (fait la même chose).

Avec une courte ligne de SQL, c'est une étape, mais si vous ne connaissez pas SQL ou préférez simplement les boîtes de dialogue pointer-cliquer à l'aide du panneau de transformation pointer-cliquer, c'est deux clics :

créer un champ géométrique à partir du fichier CSV. Trivial, et illustré pas à pas dans la documentation.


Comment ouvrir ce fichier .json ?

Salut essayé d'ajouter via Gestionnaire de sources de données->Vector-> Protocole mais je reçois Erreur de source de données non valide
J'ai également essayé de télécharger le fichier .json sur mon ordinateur et de l'ajouter mais je reçois la même erreur

Y a-t-il un moyen de le résoudre?

Ainsi, bien qu'il y ait des informations de localisation, il s'agit d'un fichier .json simple, il n'est pas formaté en tant que geojson, donc QGIS ne sait pas comment le lire. Je ne sais pas comment procéder pour le convertir en geojson, mais ce que je ferais, c'est faire la conversion via python et pandas/geopandas. Si vous ne connaissez pas Python, c'est un projet assez simple pour commencer !

Merci pour l'explication je connais un peu le python mais pas assez pour ce que vous proposez. De plus j'ai besoin de ces fichiers pour ma thèse, j'en ai donc besoin au plus vite Connaissez-vous un code python déjà compilé pour convertir des fichiers json ?

Ce site peut être converti en CSV. Il crée des données comme celle-ci.

Vous pouvez ouvrir ces données dans un tableur et ajouter un champ pour la latitude et la longitude à partir du fichier de données (""cityLatitude":"1.366667000","cityLongitude":"103.916667000"). Vous devrez l'ajouter à chaque ligne. Enregistrez le fichier CSV avec toutes les données et vous pouvez l'ajouter à QGIS en tant que "Couche de texte délimitée".


Convertir JSON en GeoJSON ou CSV ? - Systèmes d'information géographique

/! ATTENTION : Seules les données officielles doivent être utilisées pour la navigation aérienne. /! ATTENTION : Seules les données officielles doivent être utilisées pour la navigation aérienne

Program d'extraction et de formatage des données issues du standard AIXM (Aeronautical Information Exchange Modele)

Selon le choix des options de génération le programme produira un journal et les fichiers dans le dossier ./out/ Les options d'utilisations s'auto avec l'aide en ligne "aixmParser -h":

    pour la première version de l'analyseur aixm2geojson pour une réécriture modulaire complète d'aixmPaser. Pour l'intégration de : Parseur OpenAir et Hauteur de terrain estimée référentielle
  • les nombreuses bibliothèques open source, projets et sources de données utilisées par ce logiciel (afficher le contenu du fichier 'requirements.txt' pour le détail complet des composants)

Type de fichier .gdbtable, comment le SIG le lit et comment le convertir par lots en CSV ?

Utilisation de QGIS 3.14 . J'ai un type de données que je ne connais pas, une table GDB apparaît. L'ensemble de données exact avec lequel je travaille est un répertoire qui contient divers fichiers qui ressemblent à a0000000b.gdbtable si illisibles pour moi, mais lorsque je fais glisser tout le répertoire dans QGIS, toutes les données sont parfaitement importées. Maintenant, je ne suis pas un QGIS ou même une personne SIG, donc je veux que ces données soient stockées et gérées en Python, mais je ne sais même pas comment commencer et je n'ai pas pu trouver de bibliothèque ou quoi que ce soit avec lequel travailler. J'ai trouvé ce post mais il est obsolète et aussi pour les fichiers .gdb qui ne sont pas les mêmes (n'est-ce pas ?). Maintenant, je pourrais ouvrir la table attributaire et exporter au format CSV mais deux problèmes avec cela :

J'ai besoin que ce processus soit automatique (c'est-à-dire en utilisant une API SIG ou Python) de sorte qu'il ne dépende pas du logiciel SIG car cela doit être fait plusieurs fois par semaine avec de nouvelles données téléchargées

La table attributaire ne semble pas avoir d'informations sur la façon de dessiner la couche, et bien sûr, c'est quelque chose que je veux conserver. Plus à venir:

Pour le contexte, les données sont des oléoducs et des gazoducs, donc chaque ligne de la table attributaire est un pipeline distinct, mais voici les en-têtes de la table attributaire :

[OBJECTID, PipelineID, Country, CountryISO, Region, Basin, OnOffshore, Environment, Status, Contents, UpdatedDate, CreatedDate, Symbol, SHAPE_Length]

Donc apparemment aucune information de localisation, mais QGIS sait exactement où se trouve chaque pipeline et l'affiche sur la carte. Comment sait-il où sont stockées les données de localisation et quel est exactement le type de données ici ? Un shapefile ? Polygone? Plusieurs lignes concaténées ? Liste des points pour chaque pipeline qui sont ensuite dessinés connectés? Je ne sais pas si vous pouviez le dire sans avoir réellement accès aux données, dont je pourrais fournir un échantillon si nécessaire.

Je peux éclaircir tout ce qui n'a pas de sens, je suis nouveau dans le SIG et ce type de données (c'est pourquoi j'essaie de le faire en Python).

Une réponse

Je recommanderais d'utiliser GeoPandas pour cela, où vous pouvez lire les géodatabases Esri (et de nombreux autres formats) en tant que GeoDataframe. Si vous connaissez Pandas, le cadre de données est une structure de données tabulaire très utile pour l'analyse. Geopandas s'appuie sur cela en ajoutant une GeoSeries à la structure de données tabulaire.

Voici comment lire une classe d'entités à partir d'une géodatabase et la convertir au format CSV ou GeoJSON :


Visualisation pratique des données

Comme GeoJson.io, Mapshaper est un éditeur open source gratuit qui peut convertir des fichiers géospatiaux, modifier des données d'attributs, filtrer et dissoudre des entités, simplifier les limites pour réduire la taille des fichiers, et bien d'autres. Les commandes d'édition et de jointure de Mapshaper sont beaucoup plus puissantes que l'outil GeoJson.io. Contrairement à GeoJson.io, Mapshaper n'a pas d'outils de dessin, vous ne pourrez donc pas créer de fichiers géospatiaux à partir de zéro.

Mapshaper est développé et maintenu par Matthew Bloch sur GitHub. Cet outil Web facile à apprendre a remplacé beaucoup de nos tâches de préparation de cartes qui nécessitaient auparavant un logiciel ArcGIS coûteux et difficile à apprendre, ou son cousin gratuit mais toujours difficile à apprendre, QGIS. Même les utilisateurs SIG avancés peuvent découvrir que Mapshaper peut être une alternative rapide pour certaines tâches courantes mais chronophages.

Importer, convertir et exporter des fichiers de limites de carte

Vous pouvez utiliser Mapshaper pour convertir entre les formats de fichiers géospatiaux. Contrairement à GeoJson.io, Mapshaper vous permet également de télécharger des fichiers Esri Shape, afin que vous puissiez facilement les convertir au format GeoJSON convivial pour le Web. Dans les étapes suivantes, nous allons convertir un fichier géospatial en l'important dans Mapshaper, puis en l'exportant sous un type de fichier différent.

Accédez à Mapshaper.org. La page de démarrage est constituée de deux grandes zones de glisser-déposer que vous pouvez utiliser pour importer votre fichier. La plus petite zone en bas, Importation rapide, utilise les paramètres d'importation par défaut et constitue une bonne façon de commencer.

Faites glisser et déposez votre fichier géospatial dans le Importation rapide surface. Pour cet exercice, vous pouvez télécharger nos fichiers de formes des États américains au format .zip, qui est une archive compressée contenant quatre fichiers de formes.

Remarque : si vous souhaitez importer un dossier de fichiers de formes, vous devez soit sélectionner tous les fichiers contenus dans ce dossier et les déposer tous ensemble dans la zone d'importation, soit les télécharger tous dans une archive compressée .zip.

Chaque fichier importé devient un calque et est accessible à partir du menu déroulant en haut au milieu de la fenêtre du navigateur. Là, vous pouvez voir le nombre d'entités de chaque couche, basculer leur visibilité ou les supprimer.

Pour exporter, allez sur Exportation dans le coin supérieur droit et sélectionnez le format de fichier souhaité. Le choix des formats d'exportation est illustré à la Figure 13.8. Actuellement, les formats disponibles sont Shapefile, GeoJSON, TopoJSON (similaire à GeoJSON, mais avec des données topographiques), les enregistrements JSON, CSV ou SVG (Scalable Vector Graphics, pour le Web et l'impression). Si vous exportez plusieurs couches à la fois, Mapshaper les archivera d'abord et vous téléchargerez un fichier output.zip contenant toutes les couches exportées.

Figure 13.8 : Vous pouvez utiliser Mapshaper pour convertir rapidement entre les formats de fichiers géospatiaux.

Astuce : Mapshaper ne fonctionne pas avec les fichiers KML ou KMZ, mais vous pouvez utiliser GeoJson.io pour les convertir d'abord au format GeoJSON, puis les télécharger sur Mapshaper.

Modifier les données pour des polygones spécifiques

Vous pouvez modifier les données attributaires de polygones individuels (ainsi que des points et des lignes) dans Mapshaper, comme illustré à la Figure 13.9.

Importez le fichier dont vous souhaitez modifier les attributs de polygone.

Sous l'outil curseur, sélectionnez modifier les attributs.

Cliquez sur le polygone que vous souhaitez modifier. Une fenêtre contextuelle apparaîtra dans le coin supérieur gauche répertoriant tous les attributs et valeurs du polygone.

Cliquez sur n'importe quelle valeur (soulignée, en bleu) et modifiez-la.

Lorsque vous avez terminé, exportez votre fichier géospatial en cliquant sur Exportation et en choisissant le format de fichier souhaité.

Figure 13.9 : Utilisation modifier les attributs (sous l'outil Curseur) pour modifier les attributs des polygones, des lignes et des points.

Renommer les champs de données

Les outils les plus puissants de Mapshaper sont disponibles via le Console en haut, qui ouvre une fenêtre dans laquelle vous pouvez taper des commandes pour les tâches courantes d'édition de carte.

Parfois, les entités cartographiques (telles que les points, les polylignes et les polygones) contiennent les attributs (champs ou colonnes de données) avec des noms longs ou déroutants. Dans le Mapshaper Console, vous pouvez facilement modifier les noms de champ en entrant la commande rename dans ce format générique :

Tout d'abord, sélectionnez le inspecter les caractéristiques symbole de flèche dans Mapshaper et faites glisser votre curseur sur les entités de la carte pour afficher leurs noms de champ, puis cliquez sur ouvrir le Console fenêtres, comme illustré à la Figure 13.10. Dans cet exemple, pour remplacer le nom de champ plus long ( STATE_TITLE ) par un nom plus court ( name ), entrez cette commande dans la console :

Figure 13.10 : Sélectionnez le inspecter les caractéristiques flèche pour afficher les noms de champ et renommez-les à l'aide de la commande -rename-fields dans la console.

Supprimer les champs de données indésirables

Parfois, les entités cartographiques contiennent des attributs indésirables (champs de données ou colonnes) que vous souhaitez supprimer, ce que vous pouvez facilement faire avec la commande -filter-fields dans la console Mapshaper.

Par exemple, cette commande supprime tous les champs sauf ville:

Si vous souhaitez laisser plusieurs champs, séparez-les par une virgule, mais sans espaces, comme ceci :

Attention : si vous laissez un espace après une virgule, vous obtiendrez un La commande attend une valeur unique Erreur.

Simplifier les limites de la carte pour réduire la taille du fichier

Lorsque vous trouvez des cartes GeoJSON sur le Web, elles peuvent contenir des limites détaillées (en particulier autour des côtes) qui augmentent la taille du fichier, ce qui peut ralentir les performances de vos cartes Web en ligne. Étant donné que vous n'avez pas toujours besoin de limites très détaillées pour les projets de visualisation de données avec des zones géographiques réduites, envisagez d'utiliser Mapshaper pour simplifier les limites de votre carte. Le résultat sera moins précis, mais plus rapide à charger dans les navigateurs des utilisateurs.

Pour comprendre comment simplifier les limites des cartes, considérons deux cartes des États américains contigus (également appelées les 48 inférieurs, le terme que le co-auteur Ilya a appris en 2018 lors d'un voyage en Alaska), comme le montre la figure 13.11. La carte de la figure 13.11a est plus détaillée et fait environ 230 kilo-octets, mais la carte de la figure 13.11b n'est que de 37 kilo-octets, soit six fois plus petite ! Cependant, veillez à ne pas simplifier les limites au point de supprimer des fonctionnalités importantes.

Figure 13.11 : Pensez à simplifier les géométries avec Mapshaper pour rendre vos cartes Web plus rapides.

Pour simplifier les limites de la carte dans Mapshaper, suivez les étapes ci-dessous.

Importez votre fichier de géodonnées dans Mapshaper. Vous pouvez utiliser les exemples d'États américains contigus au format GeoJSON.

Clique le Simplifier bouton dans le coin supérieur droit. Le menu Simplification apparaîtra, où vous pouvez choisir l'une des trois méthodes. Nous vous recommandons de vérifier empêcher la suppression de forme, et en laissant la valeur par défaut Visvalingam / zone pondérée. Cliquez sur Appliquer.

Vous verrez un curseur avec 100% apparaître en haut (Figure 13.12), remplaçant la liste déroulante de sélection de calque. Déplacez le curseur vers la droite et voyez la carte simplifier sa forme au fur et à mesure. Arrêtez-vous lorsque vous pensez que la carte semble appropriée (lorsque les formes sont encore reconnaissables).

Mapshaper peut suggérer de réparer les intersections de lignes dans le coin supérieur gauche. Cliquez sur réparation.

Vous pouvez maintenant exporter votre fichier en utilisant le Exportation fonctionnalité.

Figure 13.12 : Utilisez les outils Simplify & Repair dans Mapshaper.

Conseil : lorsque vous chargez un fichier géographique sur Mapshaper, vous devrez peut-être modifier sa projection pour l'aligner sur vos outils de visualisation ou les géodonnées associées. Cliquez pour ouvrir le Console et tapez -proj wgs84 (ou -proj EPSG:4326 ) pour changer la projection en World Geodetic System 84 (wgs84), le format utilisé par le Global Positioning System (GPS) pour afficher les coordonnées géographiques dans le monde.

Dissoudre les polygones internes pour créer une carte muette

Une tâche d'édition de carte courante consiste à créer une carte muette en supprimant les limites internes. Par exemple, vous pouvez dissoudre les frontières des États de la carte des États-Unis dans l'exercice précédent pour obtenir le contour du pays, comme le montre la figure 13.13.

Figure 13.13 : Mapshaper vous permet de dissoudre les limites pour créer une forme de contour.

Cliquer sur Console, qui ouvre une fenêtre pour saisir des commandes. Entrer le dissoudre commande exactement comme indiqué ci-dessous, puis appuyez sur la Revenir ou alors Entrer clé.

Vous verrez que les limites internes sont devenues plus claires, et c'est la façon dont Mapshaper de dire qu'elles n'existent plus. Vous pouvez maintenant exporter votre forme de contour.

Découper une carte pour qu'elle corresponde à un calque de contour

Une autre tâche courante d'édition de carte consiste à « découper » une petite partie d'une carte plus grande pour n'obtenir que la zone dont vous avez besoin. Par exemple, l'État du Connecticut se compose de 8 comtés, eux-mêmes divisés en un total de 169 villes. Imaginez que l'on vous donne un fichier des limites des 169 villes et le contour du comté de Hartford. Vous devez « découper » la carte des villes d'origine pour n'inclure que les villes qui se trouvent dans une partie spécifique du Connecticut : le comté de Hartford.

Mapshaper vous permet de faire exactement cela en utilisant une simple commande -clip.

Importez deux fichiers de limites dans Mapshaper. L'un est le plus gros qui est coupé (si vous utilisez des exemples de fichiers, ct-villes), et l'un est la forme finale souhaitée (hartfordcounty-contour). Cette dernière est ce qu'ArcGIS appelle l'« entité de découpage ».

Assurez-vous que votre couche active est définie sur la carte que vous découpez (ct-villes).

Dans le Console, tapez -clip suivi du nom de votre calque de clip, comme ceci :

  1. Vous devriez voir votre calque actif tronqué. Parfois, vous vous retrouvez avec de minuscules « éclats » de zones coupées qui restent le long des bordures. Si tel est le cas, utilisez une commande associée pour les supprimer, comme ceci :

-clip hartfordcounty-outline -filtre-éclats

  1. L'état de votre Mapshaper doit ressembler à celui illustré à la Figure 13.14. Vous pouvez maintenant enregistrer le fichier sur votre ordinateur en utilisant le Exportation bouton.

Figure 13.14 : Lors du découpage, assurez-vous que votre calque actif est celui qui est découpé (avec de nombreuses entités), et non l'entité de découpage elle-même.

Joindre des données de feuille de calcul avec une carte polygonale

La combinaison de données de feuille de calcul avec des limites géographiques est une tâche courante dans la visualisation de données. Dans cet exercice, vous allez télécharger cette carte des limites de la ville du Connecticut au format GeoJson, et également télécharger ces données de population de la ville du Connecticut au format CSV, et les joindre afin de créer une carte choroplèthe.

Mapshaper fournit une puissante commande -join pour connecter ces fichiers. N'oubliez pas que vous avez besoin de clés communes dans les deux ensembles de données (comme nom de la ville, ou alors Etat, ou alors de campagne) afin de joindre les deux fichiers. Sans un champ commun, Mapshaper n'a aucun moyen de savoir quels nombres appartiennent à quels polygones.

Importez à la fois le fichier GeoJSON et le fichier CSV que vous avez téléchargé ci-dessus dans Mapshaper à l'aide de sa boîte d'importation rapide.

Assurez-vous que les deux fichiers apparaissent dans la liste déroulante des calques. Vos données CSV ressembleront à un tableau. Utilisez le Curseur > inspecter les fonctions outil pour vous assurer que les données sont importées correctement. Si vous utilisez les exemples de données du Connecticut, notez que le ct-villes la couche a Nom attribut avec le nom de la ville, et ct-villes-popdensité a des noms de ville dans le ville colonne.

Faites votre couche géospatiale (ct-villes) le calque actif.

Ouvrez le Console et entrez la commande -join, comme ceci :

-join ct-towns-popdensity keys=nom, ville

Dans cette commande, ct-towns-popdensity est la couche CSV avec laquelle vous fusionnez, et les clés sont les attributs qui contiennent les valeurs à joindre. Pour nos exemples de données, il s'agirait des noms de villes qui sont stockés dans l'attribut name du fichier de carte et la colonne town du fichier CSV.

Vous verrez un message dans la console vous informant si la jointure a été effectuée avec succès ou si Mapshaper a rencontré des erreurs.

Utilisez le Curseur > inspecter les fonctions outil pour vous assurer que vous voyez les colonnes CSV comme des champs de vos polygones, comme le montre la Figure 13.15.

Vous pouvez maintenant enregistrer le fichier sur votre ordinateur en cliquant sur le bouton Exportation bouton.

Figure 13.15 : Dans Mapshaper, joignez les fichiers spatiaux et CSV à l'aide de clés communes, telles que les noms de ville.

Astuce : Pour éviter toute confusion, envisagez d'utiliser la commande -rename-fields sur vos données CSV qui contiennent des valeurs clés, afin de faire correspondre le nom d'attribut clé de votre carte. Dans notre exemple, vous devez d'abord -rename-fields name=town dans votre fichier CSV. Renommer ce champ CSV en nom évite toute confusion dans la deuxième étape, car votre commande de jointure se terminerait par keys=name,name .

Compter des points dans des polygones avec Mapshaper

Mapshaper vous permet de compter les points dans les polygones et d'enregistrer ce nombre dans les attributs de polygone à l'aide de la commande -join.

Téléchargez deux exemples de fichiers GeoJSON sur votre ordinateur : les points que vous souhaitez agréger, tels que les points hospitaliers aux États-Unis, et les limites de polygones, telles que les limites des États américains. Importez les deux dans Mapshaper.

Assurez-vous de choisir des « polygones » (pas des points) pour le calque actif en le sélectionnant dans le menu déroulant.

Dans le Console, exécutez une commande -join à l'aide d'une fonction count(), comme ceci :

-join hospital-points calc='hospitals = count()' fields=

Cette commande indique à Mapshaper de compter les points à l'intérieur du points-hôpitaux couche et enregistrez-les comme hôpitaux attribut des polygones. La partie fields= indique à Mapshaper de ne copier aucun champ à partir des points, car dans notre cas, nous effectuons une correspondance plusieurs-à-un, ce qui signifie de nombreux hôpitaux par état.

Utilisez le Curseur > inspecter les fonctions outil pour s'assurer que les polygones ont obtenu un nouveau champ avec le nombre de points enregistré, comme le montre la figure 13.16.

Enregistrez le nouveau fichier en utilisant le Exportation et choisissez le format de sortie souhaité. Dans la section ci-dessous, nous parlerons de ce qui arrive aux objets qui ne se joignent pas.

Figure 13.16 : Mapshaper -rejoindre La commande peut compter des points dans des polygones.

En savoir plus sur les jointures

Dans la section ci-dessus sur « Compter les points dans les polygones », vous n'aviez pas besoin de spécifier clés pour joindre des emplacements entre deux couches géographiques : des points et des polygones. Mais si l'un des fichiers que vous souhaitez joindre est un ensemble de données CSV, vous devez clés.

Si vous ne disposez pas d'un jeu de données CSV correspondant aux colonnes de vos données de carte des limites, vous pouvez facilement en créer un. Téléchargez la carte des limites sur Mapshaper et exportez-la au format CSV. Ouvrez le fichier CSV téléchargé dans n'importe quel tableur. Pour faire correspondre les colonnes de données dans la feuille de calcul CSV, utilisez la fonction RECHERCHEV.

Dans la vraie vie, vous aurez rarement des fichiers parfaits avec des correspondances un-à-un, vous voudrez donc peut-être avoir plus d'informations sur les fonctionnalités qui n'ont pas été mises en correspondance afin que vous puissiez corriger vos données. Mapshaper vous aide à garder une trace des données qui ne sont pas correctement jointes ou mises en correspondance. Par exemple, si la carte polygonale contient 169 entités (une pour chaque ville du Connecticut), mais que la table CSV ne contient que 168 lignes de données, Mapshaper rejoindra toutes celles dont les clés correspondent, puis affichera ce message :

Pour obtenir plus de détails sur les valeurs qui n'ont pas été jointes, ajoutez des indicateurs -info non joints sans correspondance à votre commande de jointure, comme ceci :

-join ct-towns-popdensity keys=nom, ville non jointe sans correspondance -info

L'indicateur non joint enregistre une copie de chaque enregistrement non joint de la table source dans une autre couche nommée détaché. L'indicateur sans correspondance enregistre une copie de chaque enregistrement sans correspondance de la table cible dans une nouvelle couche nommée incomparable. Enfin, l'indicateur -info fournit des informations supplémentaires sur la procédure de jointure à la console.

Fusionner les polygones sélectionnés avec les commandes de jointure et de dissolution

Dans Mapshaper, vous pouvez fusionner des polygones sélectionnés en clusters plus grands à l'aide des commandes -join et -dissolve. Imaginez que vous êtes employé par le département de santé publique de CT et que votre tâche consiste à diviser 169 villes en 20 districts de santé publique et à produire un nouveau fichier géospatial.

Vous devriez commencer par créer un passage clouté des villes et de leurs districts de santé, ce qui signifie un moyen de faire correspondre deux ensembles de données, tels que les codes postaux et les villes où ils se trouvent. Dans notre cas, le passage pour piétons peut être aussi simple qu'une liste CSV à deux colonnes d'une ville et de son quartier, chacun sur une nouvelle ligne. Parce que votre patron ne vous a pas donné une liste de villes sous forme de feuille de calcul, mais plutôt un fichier GeoJSON avec les limites des villes, extrayons-en une liste de villes.

Importez ct-towns.geojson dans Mapshaper à l'aide de la boîte d'importation rapide.

Utilisez le Curseur > inspecter les fonctions outil pour voir que chaque polygone a un Nom attribut avec le nom de la ville.

Enregistrez les données d'attribut dans un fichier CSV à l'aide de Exportation bouton. Ouvrez le fichier dans n'importe quel tableur. Vous verrez que vos données sont un fichier à une colonne avec un Nom colonne qui répertorie 169 villes.

Dans votre feuille de calcul, créez une deuxième colonne intitulée fusionné et copier-coller les valeurs du premier Nom colonne. À ce stade, votre feuille de calcul contient deux colonnes avec les mêmes valeurs.

Choisissez quelques villes, comme West Hartford et Bloomfield, et attribuer « Bloomfield-West Hartford » à leur fusionné colonne, comme le montre la figure 13.17. Vous pouvez vous arrêter ici et passer à l'étape suivante, ou continuer à attribuer des noms de quartier à quelques autres villes voisines.

Figure 13.17 : Créez un tableau de concordance à deux colonnes des noms de villes et de leurs districts de santé fusionnés.

Enregistrez ce nouveau fichier de feuille de calcul sous ct-villes-fusionnées.csv, et faites-le glisser vers Mapshaper au-dessus de votre ct-villes couche. Cliquez sur Importer.

Dans Mapshaper, cette nouvelle couche CSV, nommée ct-villes-fusionnées, apparaîtra sous la forme d'une série de cellules de tableau. Dans le menu déroulant, sélectionnez ct-villes pour revenir à votre carte.

Vous êtes maintenant prêt à fusionner certaines villes en quartiers en fonction de votre fichier CSV téléchargé. Ouvrez le Console, et tapez :

-join ct-towns-merged keys=nom,nom

pour joindre la couche CSV avec la couche de limites que vous voyez à l'écran.

pour dissoudre des polygones de villes selon le fusionné colonne du fichier CSV.

Dans notre exemple, seuls Bloomfield et West Hartford sont dissous dans un district sanitaire régional combiné « Bloomfield-West Hartford », la ligne de démarcation partagée entre ces villes devenant grisée et tous les autres polygones restent les mêmes. La figure 13.18 montre le résultat final.

Figure 13.18 : Fusionner des polygones en fonction d'un passage pour piétons prédéfini.

Vous pouvez inspecter les données attributaires des polygones en utilisant Curseur > inspecter les fonctions et enregistrez le fichier résultant à l'aide de l'outil Exportation bouton.

Dans l'ensemble, Mapshaper est un puissant outil d'édition de géodonnées avec de nombreuses autres commandes qui méritent d'être explorées. Certains d'entre eux incluent la modification des projections, le filtrage des caractéristiques à l'aide d'expressions JavaScript, l'attribution de couleurs aux polygones en fonction de valeurs, etc. Explorez le Wiki MapShaper sur GitHub pour en savoir plus sur les commandes et voir plus d'exemples.

Achetez le livre imprimé sur Amazon - Barnes & Noble - Librairie - Powell's - ou votre librairie locale.
Ou commencez un essai gratuit de 30 jours pour tous les livres et contenus numériques sur la plateforme d'apprentissage en ligne O'Reilly.
Partagez vos commentaires sur le livre en taguant @handsondataviz sur Twitter ou contactez les auteurs.


A propos de l'auteur

Julie Powell

Julie Powell est chef de produit principal, se concentrant sur l'API ArcGIS pour JavaScript et le système de conception d'Esri. Elle s'interface avec une large communauté d'utilisateurs pour maintenir la sensibilisation et la compréhension des besoins de la communauté SIG, tout en fournissant des commentaires aux équipes de développement afin de garantir que les utilisateurs peuvent réussir à créer des solutions de pointe et utiles à l'aide du logiciel ArcGIS. Julie présente les tendances technologiques SIG et les solutions innovantes lors du Sommet des développeurs Esri, de la Conférence internationale des utilisateurs d'Esri, de la Conférence des utilisateurs d'Amérique latine d'Esri et d'autres conférences régionales. Julie apporte 19 ans d'expérience de travail avec des leaders mondiaux tels que Hewlett-Packard et Esri, fournissant une variété de solutions logicielles pour les marchés des entreprises et des consommateurs. Julie a travaillé sur un large éventail de projets et d'activités de conseil, notamment en tant que responsable technique de solutions de cartographie Web pour des clients stratégiques.


Comment traiter les données météorologiques GRIB2 pour les applications agricoles (GeoJSON)

Écrit par
Elliott Wobler
Ingénieur de solutions techniques

This tutorial covers how to work with Spire Weather’s global forecast data in GRIB2 format using Python.

This tutorial uses GeoJSON input.

Aperçu

This tutorial covers how to work with Spire Weather’s global forecast data in GRIB2 format using Python.

If you have never worked with GRIB2 data before, it’s recommended to start with the getting started tutorial, since this current one will address slightly more advanced topics.

Specifically, this tutorial demonstrates how to retrieve soil moisture data at various depths within the bounds of a complex polygon (e.g. a nation’s border).

By the end of this tutorial, you will know how to:

  1. Load files containing GRIB2 messages into a Python program
  2. Inspect the GRIB2 data to understand which weather variables are included
  3. Filter the GRIB2 data to weather variables of interest at different depths
  4. Crop the GRIB2 data to the area defined by a GeoJSON file input
  5. Convert the transformed GRIB2 data into a CSV output file for further analysis and visualization

Downloading the Data

The first step is downloading data from Spire Weather’s File API.

This tutorial expects the GRIB2 messages to contain NWP data from Spire’s Agricultural data bundle.

For information on using Spire Weather’s File API endpoints, please see the API documentation and FAQ.

The FAQ also contains detailed examples covering how to download multiple forecast files at once using cURL.

For the purposes of this tutorial, it is assumed that the GRIB2 data has already been successfully downloaded, if not get a sample here.

Understanding filenames

Files downloaded from Spire Weather’s API products all share the same file naming convention.

Just from looking at the filename, we can determine:

  • the date and time that the forecast was issued
  • the date and time that the forecasted data is valid for
  • the horizontal resolution of the global forecast data
  • the weather data variables that are included in the file (see the full list of Spire Weather’s commercial data bundles)

For more detailed information on the above, please refer to our FAQ.

Python Requirements

The following Python packages are required for this tutorial.

Although using conda is not strictly required, it is the officially recommended method for installing PyNIO (see link below).

Once a conda environment has been created and activated, the following commands can be run directly:

Inspecting the Data

After downloading the data and setting up a Python environment with the required packages, the next step is inspecting the data contents in order to determine which weather variables are available to access. Data inspection can be done purely with PyNIO, but in this tutorial we will instead use PyNIO as the engine for xarray and load the data into an xarray dataset for transformation. Note that an explicit import of PyNIO is not required, so long as it’s installed properly in the active Python environment.

First, import the xarray package:

Next, open the GRIB2 data with xarray using PyNIO as its engine (note that the GRIB2 data should be from Spire’s Agricole data bundle):

ds = xr.open_dataset("path_to_agricultural_file.grib2", engine="pynio")

Finally, for each of the variables, print the lookup key, human-readable name, and units of measurement:

The output of the above should look something like this, giving a clear overview of the available data fields:

Since this tutorial covers working with GRIB2 data at different vertical levels, we should also inspect the level_type field:

The output of the above should look like this:

Notice that lv_DBLL0_l0 and lv_DBLL0_l1 are now absent from the output. This is because they are special fields containing data that describes the available depth ranges. We will come back to these two fields in the next section: Understanding Depth Values.

One other thing to point out here is that SOILW_P0_2L106_GLL0 and TSOIL_P0_2L106_GLL0 have the same level_type value. This means that the same exact methodology can be used to process soil moisture or soil temperature at different depths, though for the purpose of this tutorial we will stick to looking at just soil moisture.

Understanding depth values

To better understand available depth values, we can start by printing metadata for the soil moisture variable:
print(ds["SOILW_P0_2L106_GLL0"])
The output of the above should look something like this:

At the end of the first line, the list contains not only the lat_0 and lon_0 index names we would expect after the basic tutorial, but also a new one called lv_DBLL0 .
We know from our previous print statement that lv_DBLL0 refers to Depth below land surface , and the sixth line of the latest print output tells us that lv_DBLL0 is a dimension without coordinates. From this information, we can intuit that there is a third index for this data called lv_DBLL0 which indicates the depth level into the soil that the moisture data corresponds to.
We can print metadata on an index with the same method used to inspect variables:
print(ds["lv_DBLL0"])
The output of the above should look like this:

The first line of the output tells us that there are four possible values, expressed as (lv_DBLL0: 4) , and the second line tells us what those values are: [0, 1, 2, 3]
This means that for every unique pair of lat_0 and lon_0 coordinates, there are four distinct soil moisture values which can be retrieved by specifying a lv_DBLL0 value of 0 , 1 , 2 , or 3 .
In order to determine which depth ranges these index values actually correspond to, we need to investigate further by inspecting the related variables from our initial print output: lv_DBLL0_l0 and lv_DBLL0_l1
print(ds["lv_DBLL0_l0"])
The output of the above should look like this:

We can then do the same for the lv_DBLL0_l1 variable:
print(ds["lv_DBLL0_l1"])
The output of the above should look like this:

What this tells us is that:

a lv_DBLL0 value of 0 corresponds to a lv_DBLL0_l0 value of 0.0 meters and a lv_DBLL0_l1 value of 0.1 meters

a lv_DBLL0 value of 1 corresponds to a lv_DBLL0_l0 value of 0.1 meters and a lv_DBLL0_l1 value of 0.4 meters

a lv_DBLL0 value of 2 corresponds to a lv_DBLL0_l0 value of 0.4 meters and a lv_DBLL0_l1 value of 1.0 meters

a lv_DBLL0 value of 3 corresponds to a lv_DBLL0_l0 value of 1.0 meters and a lv_DBLL0_l1 value of 2.0 meters

a lv_DBLL0 value of 1 corresponds to a depth of 10 cm to 40 cm

a lv_DBLL0 value of 2 corresponds to a depth of 40 cm to 100 cm

a lv_DBLL0 value of 3 corresponds to a depth of 100 cm to 200 cm

Processing the Data

Now that we know which weather variables and vertical levels are included in the GRIB2 data, we can start processing our xarray dataset.

Filtering the xarray data to a specific variable

With xarray , filtering the dataset’s contents to a single variable of interest is very straightforward:

Selecting multiple variables is also possible by using an array of strings as the input: ds = ds.get([var1, var2])

It’s recommended to perform this step before converting the xarray dataset into a pandas DataFrame (rather than filtering the DataFrame later), since it minimizes the size of the data being converted and therefore reduces the overall runtime.

Converting the xarray data into a pandas.DataFrame

To convert the filtered xarray dataset into a pandas DataFrame, simply run the following:

Filtering the pandas.DataFrame to a specific depth range

Using the information gathered from the Understanding Depth Values section, we can now filter the DataFrame to a specific depth range.

The first thing we do is copy the depth index values into a new DataFrame column:

Next, we create the expression we will use to filter the DataFrame.

We know from our previous analysis that a lv_DBLL0 value of 0 corresponds to a depth of 0 cm to 10 cm.

Therefore, we can filter the soil moisture data to a depth range of 0-10cm with the following expression:

Finally, we apply the filter to the DataFrame:

Our DataFrame has now been filtered to only include soil moisture data at the depth range of 0-10cm.

Loading a GeoJSON file with the GDAL Python package

Although the package we installed with conda was named gdal , we import it into Python as osgeo . This is an abbreviation of the Open Source Geospatial Foundation, which GDAL/OGR (a Free and Open Source Software) is licensed through.

To load GeoJSON data into GDAL, we just use GDAL’s CreateGeometryFromJSON function:

The GeoJSON format is a common standard in the world of geographic information systems. Many pre-existing GeoJSON regions can be downloaded for free online (e.g. national borders, exclusive economic zones, etc.) and custom shapes can also be created in a variety of free software tools, such as geojson.io or geoman.io. For this tutorial we use the country of Italy as our complex polygon, but this could just as easily be the extent of a farm or some other subregional area.

When loading GeoJSON data into GDAL, only the geometry section of the Feature is needed. Here is a simple example of what the GeoJSON input file could contain:

The GeoJSON file can be loaded into Python using the standard json package, and should then be converted into a Python string:

Once we have loaded our GeoJSON definition into a Python string, we can create a GDAL geometry object like this:

Getting the bounding box that contains a GeoJSON area

Eventually we will crop the data to the precise area defined by the GeoJSON file, but this is a computationally expensive process so it’s best to limit the data size first. In theory we could skip the step of cropping to a simple box altogether, but in practice it’s worth doing so to reduce the overall runtime.

GDAL makes it easy to calculate the coarse bounding box that contains a complex GeoJSON area:

Coordinate values can then be accessed individually from the resulting array:

The order of geospatial coordinates is a common source of confusion, so take care to note that GDAL’s GetEnvelope function returns an array where the longitude values come before the latitude values.

Cropping the pandas.DataFrame to a geospatial bounding box

Now that the filtered data is converted into a pandas DataFrame and we have the bounds containing our area of interest, we can crop the data to a simple box.

The first step in this process is unpacking the latitude and longitude values from the DataFrame’s index , which can be accessed through the index names of lat_0 and lon_0 :

Although latitude values are already in the standard range of -90 degress to +90 degrees, longitude values are in the range of 0 à +360.

To make the data easier to work with, we convert longitude values into the standard range of -180 degrés à +180 degrees:

With latitude and longitude data now in the desired value ranges, we can store them as new columns in our existing DataFrame:

Then, we use the bounding box values from the previous section (the components of the bbox array) to construct the DataFrame filter expressions:

Finally, we apply the filters to our existing DataFrame:

The resulting DataFrame has been cropped to the bounds of the box that contains the complex GeoJSON area.

Cropping the pandas.DataFrame to the precise bounds of a GeoJSON area

In order to crop the DataFrame to the precise bounds of the complex GeoJSON area, we will need to check every coordinate pair in our data. Similar to the previous section where we remapped every longitude value, we will perform this action with a map expression.

To pass each coordinate pair into the map function, we create a new DataFrame column called point where each value is a tuple containing both latitude and longitude:

We can then pass each coordinate pair tuple value into the map function, along with the previously loaded GeoJSON area , and process them in a function called check_point_in_area which we will define below. The check_point_in_area function will return either True or False to indicate whether the provided coordinate pair is inside of the area or not. As a result, we will end up with a new DataFrame column of boolean values called inArea :

Once the inArea column is populated, we perform a simple filter to remove rows where the inArea value is False . This effectively removes data for all point locations that are not within the GeoJSON area:

Of course, the success of the above is dependent upon the logic inside of the check_point_in_area function, which we have not yet implemented. Since the GeoJSON area was loaded with GDAL, we can leverage a GDAL geometry method called Contains to quickly check if the area contains a specific point. In order to do this, the coordinate pair must first be converted into a wkbPoint geometry in GDAL:

Once we have our wkbPoint geometry, we simply pass it into the area.Contains method to check if the area contains the point:

Putting the pieces together, here is what we get for our final check_point_in_area function:

As you can see, the only variable returned by the check_point_in_area function is a boolean value indicating whether the specified point is in the area or not. These boolean values then populate the new inArea DataFrame column. This allows us to apply the filter from above and end up with the precisely cropped data we want:

Parsing the forecast time from the filename

Each individual file contains global weather forecast data for the same point in time.

Using our knowledge from the Understanding Filenames section of this tutorial, and assuming that the filename argument is in the expected format, we can write a function to parse the valid forecast time from the filename:

Then, we can create a new DataFrame column for time which stores this value as a string in every row:

Although it may seem unnecessary to store the same exact timestamp value in every row, this is an important step if we want to eventually concatenate our DataFrame with forecast data for other times (demonstrated below in Processing Multiple Data Files).

Saving the data to a CSV output file

Perform a final filter on our DataFrame to select only the columns that we want in our output, where variable is a string like "SOILW_P0_2L106_GLL0" :

Save the processed DataFrame to an output CSV file:

Setting the index=False parameter ensures that the DataFrame index columns are not included in the output. This way, we exclude the lat_0 , lon_0 , and lv_DBLL0 values since we already have columns for latitude and remapped longitude (and all remaining data is at the same depth after our filtering).

Please note that converting from GRIB2 to CSV can result in very large file sizes, especially if the data is not significantly cropped or filtered.

Processing Multiple Data Files

It is often desirable to process multiple data files at once, in order to combine the results into a single unified CSV output file.

For example, let’s say that we have just used the Spire Weather API to download a full forecast’s worth of GRIB2 data into a local directory called forecast_data/ . We can then read those filenames into a list and sort them alphabetically for good measure:

From here, we can iterate through the filenames and pass each one into a function that performs the steps outlined in the Processing the Data section of this tutorial.

Once all of our final DataFrames are ready, we can use pandas to concatenate them together like so (where final_dataframes is a list of DataFrames):

We end up with a combined DataFrame called output_df which we can save to an output CSV file like we did before:

Complete Code

Below is an operational Python script which uses the techniques described in this tutorial and also includes explanatory in-line comments.

The script takes four arguments:

The weather data variable of interest ( SOILW_P0_2L106_GLL0 or TSOIL_P0_2L106_GLL0 )

The local directory where the Agricultural Weather GRIB2 data is stored

The path to the GeoJSON file defining the area of interest

The depth range index value for filtering the data to a single vertical level ( 0 , 1 , 2 , or 3 )

For example, the script can be run like this:

python script.py --variable SOILW_P0_2L106_GLL0 --source-data grib_directory/ --geojson italy.json --depth 0

Here is the complete code:

Final Notes

Using the CSV data output from our final script, we can now easily visualize the processed data in a free tool such as kepler.gl. We can also set thresholds for alerts, generate statistics, or fuse with other datasets.

The visualization included below – originally featured in a Spire data story – was created with Kepler using the techniques covered in this tutorial. Spire Weather also offers pre-created visualizations through the Web Map Service (WMS) API which you can read more about here.

For additional code samples, check out Spire Weather’s public GitHub repository.