Mehr

Konvertieren von JSON in GeoJSON oder CSV?

Konvertieren von JSON in GeoJSON oder CSV?


Wie konvertiert man eine JSON-Datei in eine GeoJSON-Datei oder CSV. Ich habe eine JSON-Datei mit lateinischen Informationen, aber wie kann ich diese Datei in GeoJSON oder CSV konvertieren. Ich habe einige Online-Tools gefunden, um es in csv zu konvertieren, aber ich möchte es in einer Batchdatei verwenden, daher brauche ich ein Tool.

Die JSON-Datei sieht so aus:

[ {"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":"Falsch"}, {"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"} ]

Hoffe jemand kann helfen


Sehen Sie sich die Beispiele auf der Spezifikationsseite an. Du musst ein Skript in der Sprache deiner Wahl schreiben, das dich weiterbringt

[ {"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":"Falsch"}, {"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"} ]

zu

{ "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" } ] }

In Python habe ich zum Beispiel Folgendes getan:

def convert_json(items): import json return json.dumps({ "type": "FeatureCollection", "features": [ {"type": "Feature", "geometry": { "type": "Point", " Koordinaten": [ feature['lon'], feature['lat']]}, "properties": { key: Wert für Schlüssel, Wert in feature.items() wenn Schlüssel nicht in ('lat', 'lon' ) } } für die Funktion in json.loads(items) ] })

Dies kann über die Befehlszeile erfolgen, ohne dass Code mit zwei Node-Bibliotheken benötigt wird.

Installieren Sie sie mit:

npm install -g json2csv csv2geojson

Dann einfach:

cat file.json | json2csv | csv2geojson > file.geojson

Sie können es versuchenogr2ogr(von GDAL) und jq, die zumindest auf Linux-Derivaten ziemlich allgegenwärtig sind.

1/ von json in csv konvertieren mitvjq:

cat 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","depth","last","lat","lon","mag","place","time","type" "2014- 09-25","3.0","True","53.269","6.935","1.5","Meedhuizen","20:49:09","GH" "2014-09-24","3.0 ","Falsch","53.351","6.693","1.0","Huizinge","23:49:36","GH" "2014-09-23","3.0","Falsch"," 53.242","6.728","1.0","Lageland","17:34:48","GH"

2/ Erstellen Sie eine virtuelle Datei (VRT) für Ihre CSV

  input.csv wkbPoint WGS84 

3/ Konvertieren Sie Ihre VRT in GeoJSON

ogr2ogr -f GeoJSON-Ausgabe.geosjon-Eingabe.vrt-Eingabe

Beginnen mitgdal2.1, Sie können direkt von Json zu Geojson konvertieren (nicht getestet)


Benötigen Sie Beratung bei der Auswahl des Tools? Fragen Sie die StackShare-Community!

GeoJSON: Ein Format zum Codieren einer Vielzahl von geografischen Datenstrukturen. Es ist ein offenes Standardformat, das für die Darstellung einfacher geografischer Merkmale zusammen mit ihren nicht-räumlichen Attributen entwickelt wurde. Es basiert auf JSON, der JavaScript Object Notation. Zu den Funktionen gehören Punkte, Linienfolgen, Polygone und mehrteilige Sammlungen dieser Typen JSON: Ein leichtes Datenaustauschformat. JavaScript Object Notation ist ein leichtgewichtiges Datenaustauschformat. Es ist für den Menschen leicht zu lesen und zu schreiben. Es ist für Maschinen einfach zu analysieren und zu generieren. Es basiert auf einer Teilmenge der Programmiersprache JavaScript.

GeoJSON und JSON gehören zu "Sprachen" Kategorie des Tech-Stack.

Hallo. Derzeit habe ich eine Anforderung, bei der ich eine neue JSON-Datei basierend auf der CSV-Eingabedatei erstellen, die generierte JSON-Datei validieren und die JSON-Datei mithilfe der API in die Anwendung (die in AWS ausgeführt wird) hochladen muss. Bitte schlagen Sie die beste Sprache vor, die die oben genannten Anforderungen erfüllen kann. Ich glaube, Python wird besser sein, aber ich bin mir nicht sicher, warum Python. Können Sie Ihre Ansichten dazu mitteilen?

Python ist sehr flexibel und definitiv den Job gewachsen (obwohl in Wirklichkeit jede Sprache in der Lage ist, diese Aufgabe zu bewältigen!). Python hat einige gute eingebaute Bibliotheken und auch einige Bibliotheken von Drittanbietern, die hier helfen. 1. Konvertieren von CSV -> JSON 2. Validieren anhand eines Schemas 3. Bereitstellen in AWS

  1. Zu den Builtins gehören Json- und CSV-Bibliotheken, und je nach Komplexität der CSV-Datei ist die Konvertierung ziemlich einfach:

Der Validierungsteil wird von dieser Bibliothek gut gehandhabt: https://pypi.org/project/jsonschema/ Sie ermöglicht es Ihnen, ein Schema zu erstellen und zu überprüfen, ob das, was Sie erstellt haben, für das funktioniert, was Sie tun möchten. Es basiert auf dem Json-Schemastandard und ermöglicht die Annotation und Validierung von JSON

Es ist eine AWS-Bibliothek, um das Hochladen zu automatisieren – oder tatsächlich so ziemlich alles mit AWS zu tun – aus Ihrer Codebasis: https://aws.amazon.com/sdk-for-python/ Dies übernimmt die Authentifizierung bei AWS und das Hochladen / Bereitstellung der Datei an einem beliebigen Ort.

Vieles hängt von den letzten beiden Teilen ab, aber das Konvertieren selbst ist wirklich ziemlich ordentlich.


Erforderliche Pakete

Zusätzlich zu Altair, das ich Ihnen empfehle, die Installationsanweisungen hier zu befolgen, verwenden wir die folgenden Pakete für diese Demonstration.

Anfragen - Um das geopolitische GeoJSON des DC von der Open Data DC-Website abzurufen.

Pandas - Um die bereinigten DC-Populationsdaten einzulesen, die wir als Choroplethenschicht auf unserer Karte hinzufügen werden

Geopandas - Um die DC-Population und GeoJSON-Daten zusammenzuführen

JSON - Um den Geopandas-Datenrahmen in einen JSON zu konvertieren, der von Altair benötigt wird. Mehr Kontext zur Inkompatibilität von Altair Geopandas finden Sie hier.

Eine vollständige Anforderungsdatei befindet sich hier auf meinem GitHub.


Konvertieren von CSV in GeoJSON mit 2 Koordinatensätzen in jeder Zeile

Hallo zusammen, ich habe Divvy Bikeshare-Daten, die einige Kollegen und ich planen, eine Heatmap basierend auf der Aktivität pro Stunde an jeder Fahrradstation zu erstellen.

Jede Fahrt hat ein "to_lat" "to_long" und "from_lat" "from_long"

Wenn jemand Tipps, Tools oder Konverter hat, die mir einfach fehlen, lassen Sie es mich bitte wissen. CSV-zu-GeoJSON-Tools scheinen nur zu funktionieren, wenn ein Koordinatensatz vorhanden ist

GeoJSON ist ein wirklich einfach zu schreibendes Format.

Schreiben Sie mir eine DM, wenn Sie Python nicht verwenden, und ich werde es für Sie konvertieren.

Suchen Sie in Google nach JSON Unflattening (flattened ist das, was Sie als CSV haben)

Jetzt könnte ein guter Zeitpunkt sein, um Python zu lernen und zu sehen, ob Sie In-Memory-Sammlungen der Stationen, Radtouren usw. erstellen können.

Die IMO-Programmierung ist ein unglaublich nützliches Werkzeug, wenn Sie mit einigen Daten 'schnell arbeiten möchten und keine Fehler aufgrund von Wiederholungen usw. machen möchten.

Es erfordert Übung, aber je besser Sie darin werden, desto schneller können Sie die Dinge mit weniger Fehlern erledigen.

Sie müssen keinen Code schreiben. Verwenden Sie Radian/Manifold Future. Oder verwenden Sie den kostenlosen Viewer völlig kostenlos (wird dasselbe tun).

Mit einer kurzen SQL-Zeile ist es ein Schritt, aber wenn Sie SQL nicht kennen oder einfach nur Point-and-Click-Dialoge mit dem Point-and-Click-Transformationsfeld bevorzugen, sind es zwei Klicks:

Erstellen Sie ein Geometriefeld aus der CSV-Datei. Trivial und Schritt für Schritt in der Dokumentation bebildert.


Wie öffne ich diese .json-Datei?

Hallo, habe versucht, über hinzuzufügen Datenquellen-Manager->Vektor->-Protokoll aber ich empfange Fehler wegen ungültiger Datenquelle
Ich habe auch versucht, die Datei .json auf meinen Computer herunterzuladen und hinzuzufügen, aber ich erhalte die gleiche Fehlermeldung

Gibt es eine Möglichkeit, es zu lösen?

Obwohl dort Standortinformationen enthalten sind, handelt es sich um eine einfache .json-Datei, die jedoch nicht als Geojson formatiert ist, sodass QGIS nicht weiß, wie sie gelesen werden soll. Ich weiß nicht, wie ich es in Geojson konvertieren soll, aber ich würde die Konvertierung über Python und Pandas / Geopandas durchführen. Wenn Sie Python nicht kennen, ist dies ein ziemlich einfaches Projekt für den Anfang!

Danke für die Erklärung, ich kenne ein bisschen Python, aber nicht genug für das, was Sie vorschlagen. Außerdem benötige ich diese Dateien für meine Diplomarbeit, also benötige ich sie so schnell wie möglich Kennen Sie einen bereits kompilierten Python-Code zum Konvertieren von Json-Dateien?

Diese Site kann in eine CSV-Datei konvertiert werden. Es erstellt Daten wie diese.

Sie können diese Daten in einem Tabellenkalkulationsprogramm öffnen und ein Feld für den Breiten- und Längengrad aus der Datendatei hinzufügen ("cityLatitude":"1.366667000","cityLongitude":"103.916667000"). Sie müssen es jeder Zeile hinzufügen. Speichern Sie die CSV-Datei mit allen Daten und Sie können diese als "getrennte Textebene" zu QGIS hinzufügen.


Konvertieren von JSON in GeoJSON oder CSV? - Geografisches Informationssystem

/! ACHTUNG: Seules des données officielles doivent êtres utilisées pour la navigation aérienne. /! WARNUNG: Für die Flugnavigation dürfen nur offizielle Daten verwendet werden

Programm d'extraction et de formatage des données issue du standard AIXM (Aeronautical Information Exchange Modele) Les fichiers actuellements générées sont les suivants:

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

    für die erste Version des Parsers aixm2geojson zum vollständigen modularen Rewriting von aixmPaser. Zur Integration von: OpenAir-Parser und referenzielle geschätzte Geländehöhe
  • die vielen Open-Source-Bibliotheken, Projekte und Datenquellen, die von dieser Software verwendet werden (zeigen Sie den Dateiinhalt von 'requirements.txt' für vollständige Komponentendetails)

.gdbtable-Dateityp, wie GIS es liest und wie es stapelweise in eine CSV-Datei konvertiert wird?

Verwenden von QGIS 3.14 . Ich habe einen Datentyp, mit dem ich nicht vertraut bin, eine GDB-Tabelle, die angezeigt wird. Der genaue Datensatz, mit dem ich arbeite, ist ein Verzeichnis, das verschiedene Dateien enthält, die wie a0000000b.gdbtable aussehen, also für mich unleserlich sind, aber wenn ich das gesamte Verzeichnis in QGIS ziehe, werden alle Daten perfekt importiert. Nun, ich bin kein QGIS oder gar ein GIS-Mitarbeiter, also möchte ich, dass diese Daten in Python gespeichert und verarbeitet werden, aber ich habe keine Ahnung, wie ich überhaupt anfangen soll, und ich konnte keine Bibliothek oder irgendetwas finden, mit dem ich arbeiten könnte. Ich habe diesen Beitrag gefunden, aber er ist veraltet und auch für .gdb-Dateien, die nicht identisch sind (oder?). Jetzt konnte ich die Attributtabelle öffnen und als CSV exportieren, aber zwei Probleme damit:

Ich benötige diesen Prozess automatisch (d. h. mit einer GIS-API oder Python), sodass er nicht von der GIS-Software abhängt, da dies mehrmals pro Woche mit dem Herunterladen neuer Daten durchgeführt werden muss

Die Attributtabelle scheint keine Informationen zum Zeichnen der Ebene zu enthalten, und das möchte ich natürlich beibehalten. Weitere folgen:

Für den Kontext handelt es sich bei den Daten um Öl- und Gaspipelines, sodass jede Zeile in der Attributtabelle eine separate Pipeline ist. Dies sind jedoch die Kopfzeilen der Attributtabelle:

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

Also scheinbar keine Standortinformationen, aber QGIS weiß genau, wo sich jede Pipeline befindet und zeigt sie auf der Karte an. Woher weiß es, wo die Standortdaten gespeichert sind und welche Art von Daten hier genau sind? Ein Shapefile? Vieleck? Mehrere verkettete Zeilen? Liste der Punkte für jede Rohrleitung, die dann verbunden gezeichnet werden? Ich bin mir nicht sicher, ob Sie dies sagen können, ohne tatsächlich Zugriff auf die Daten zu haben, die ich bei Bedarf als Beispiel zur Verfügung stellen könnte.

Ich kann alles aufklären, was keinen Sinn ergibt, ich bin neu in GIS und diesem Datentyp (deshalb versuche ich, dies in Python zu tun).

Eine Antwort

Ich würde empfehlen, dafür GeoPandas zu verwenden, wo Sie Esri-Geodatabases (und viele, viele andere Formate) als GeoDataframe lesen können. Wenn Sie mit Pandas vertraut sind, ist der Dataframe eine sehr nützliche tabellarische Datenstruktur für die Analyse. Geopandas baut darauf auf, indem es der tabellarischen Datenstruktur eine GeoSeries hinzufügt.

So lesen Sie eine Feature-Class aus einer Geodatabase und konvertieren sie in das CSV- oder GeoJSON-Format:


Praktische Datenvisualisierung

Wie GeoJson.io ist Mapshaper ein kostenloser Open-Source-Editor, der Geodaten konvertieren, Attributdaten bearbeiten, Funktionen filtern und auflösen, Grenzen vereinfachen kann, um Dateien zu verkleinern und vieles mehr. Die Edit- und Join-Befehle von Mapshaper sind viel leistungsfähiger als das GeoJson.io-Tool. Im Gegensatz zu GeoJson.io verfügt Mapshaper nicht über Zeichenwerkzeuge, sodass Sie keine Geodatendateien von Grund auf erstellen können.

Mapshaper wird von Matthew Bloch auf GitHub entwickelt und gepflegt. Dieses einfach zu erlernende Web-Tool hat ersetzt viele unserer Kartenvorbereitungsaufgaben, die zuvor teure und schwer zu erlernende ArcGIS-Software erforderten, oder seinen kostenlosen, aber immer noch schwierig zu erlernenden Cousin QGIS. Sogar fortgeschrittene GIS-Benutzer werden feststellen, dass Mapshaper eine schnelle Alternative für einige häufige, aber zeitaufwändige Aufgaben sein kann.

Importieren, Konvertieren und Exportieren von Kartenbegrenzungsdateien

Sie können Mapshaper verwenden, um zwischen raumbezogenen Dateiformaten zu konvertieren. Im Gegensatz zu GeoJson.io können Sie mit Mapshaper auch Esri Shapefiles hochladen, sodass Sie diese problemlos in das webfreundliche GeoJSON-Format konvertieren können. In den folgenden Schritten konvertieren wir eine Geodatendatei, indem wir sie in Mapshaper importieren und dann als einen anderen Dateityp exportieren.

Navigieren Sie zu Mapshaper.org. Die Startseite besteht aus zwei großen Drag-and-Drop-Bereichen, über die Sie Ihre Datei importieren können. Der kleinere Bereich unten, Schnellimport, verwendet die Standardimporteinstellungen und ist ein guter Anfang.

Ziehen Sie Ihre Geodatendatei per Drag & Drop auf das Schnellimport Bereich. Für diese Übung können Sie unsere US-Bundesstaaten-Shapefiles im .zip-Format herunterladen, einem komprimierten Archiv, das vier Shapefiles enthält.

Hinweis: Wenn Sie einen Ordner mit Shapefiles importieren möchten, müssen Sie entweder alle Dateien in diesem Ordner auswählen und alle zusammen im Importbereich ablegen oder alle in ein komprimiertes ZIP-Archiv hochladen.

Jede importierte Datei wird zu einer Ebene und ist über das Dropdown-Menü oben in der Mitte des Browserfensters zugänglich. Dort können Sie sehen, wie viele Features jeder Layer hat, ihre Sichtbarkeit umschalten oder sie löschen.

Um zu exportieren, gehen Sie zu Export in der oberen rechten Ecke und wählen Sie das gewünschte Dateiformat aus. Die Auswahl der Exportformate ist in Abbildung 13.8 dargestellt. Derzeit verfügbare Formate sind Shapefile, GeoJSON, TopoJSON (ähnlich GeoJSON, aber mit topografischen Daten), JSON-Datensätze, CSV oder SVG (Scalable Vector Graphics, für Web und Print). Wenn Sie mehrere Layer gleichzeitig exportieren, archiviert Mapshaper diese zuerst und Sie laden eine output.zip herunter, die alle exportierten Layer enthält.

Abbildung 13.8: Mit Mapshaper können Sie schnell zwischen raumbezogenen Dateiformaten konvertieren.

Tipp: Mapshaper funktioniert nicht mit KML- oder KMZ-Dateien, aber Sie können GeoJson.io verwenden, um sie zuerst in das GeoJSON-Format zu konvertieren und dann in Mapshaper hochzuladen.

Daten für bestimmte Polygone bearbeiten

Sie können Attributdaten einzelner Polygone (und auch Punkte und Linien) in Mapshaper bearbeiten, wie in Abbildung 13.9 gezeigt.

Importieren Sie die Datei, deren Polygonattribute Sie bearbeiten möchten.

Wählen Sie unter dem Cursor-Werkzeug Attribute bearbeiten.

Klicken Sie auf das Polygon, das Sie bearbeiten möchten. In der oberen linken Ecke wird ein Popup angezeigt, das alle Attribute und Werte des Polygons auflistet.

Klicken Sie auf einen beliebigen Wert (unterstrichen, blau) und bearbeiten Sie ihn.

Wenn Sie fertig sind, exportieren Sie Ihre Geodatendatei, indem Sie auf klicken Export und wählen Sie das gewünschte Dateiformat.

Abbildung 13.9: Verwendung Attribute bearbeiten (unter Cursor-Werkzeug), um Attribute von Polygonen, Linien und Punkten zu bearbeiten.

Datenfelder umbenennen

Die leistungsstärksten Tools von Mapshaper sind über das Konsole Schaltfläche oben, die ein Fenster öffnet, in dem Sie Befehle für allgemeine Aufgaben zur Kartenbearbeitung eingeben können.

Manchmal enthalten Karten-Features (wie Punkte, Polylinien und Polygone) Attribute (Datenfelder oder Spalten) mit langen oder verwirrenden Namen. Im Mapshaper Konsole, können Sie Feldnamen einfach ändern, indem Sie den Umbenennungsbefehl in diesem generischen Format eingeben:

Wählen Sie zuerst die Funktionen prüfen Pfeilsymbol in Mapshaper und bewegen Sie den Cursor über die Kartenelemente, um deren Feldnamen anzuzeigen, und klicken Sie dann auf das Konsole Fenster, wie in Abbildung 13.10 gezeigt. Um in diesem Beispiel den längeren Feldnamen ( STATE_TITLE ) in einen kürzeren ( name ) zu ändern, geben Sie diesen Befehl in die Konsole ein:

Abbildung 13.10: Wählen Sie die Funktionen prüfen Pfeil, um Feldnamen anzuzeigen, und benennen Sie sie mit dem Befehl -rename-fields in der Konsole um.

Entfernen Sie unerwünschte Datenfelder

Manchmal enthalten Kartenelemente unerwünschte Attribute (Datenfelder oder Spalten), die Sie entfernen möchten. Dies können Sie ganz einfach mit dem Befehl -filter-fields in der Mapshaper-Konsole tun.

Dieser Befehl entfernt beispielsweise alle Felder außer Stadt, Dorf:

Wenn Sie mehr als ein Feld belassen möchten, trennen Sie sie durch ein Komma, jedoch ohne Leerzeichen, wie folgt:

Achtung: Wenn Sie nach einem Komma ein Leerzeichen lassen, erhalten Sie ein Befehl erwartet einen einzelnen Wert Error.

Vereinfachen Sie Kartengrenzen, um die Dateigröße zu reduzieren

Wenn Sie GeoJSON-Karten im Web finden, können diese detaillierte Grenzen (insbesondere um Küstenlinien) enthalten, die die Dateigröße erhöhen, was die Leistung Ihrer Online-Webkarten verlangsamen kann. Da Sie für Datenvisualisierungsprojekte mit verkleinerten Geografien nicht immer sehr detaillierte Grenzen benötigen, sollten Sie Mapshaper verwenden, um Ihre Kartengrenzen zu vereinfachen. Das Ergebnis ist weniger präzise, ​​aber schneller in den Browsern des Benutzers zu laden.

Um zu verstehen, wie Kartengrenzen vereinfacht werden können, betrachten Sie zwei Karten der angrenzenden US-Bundesstaaten (auch bekannt als die unteren 48, den Begriff, den Co-Autor Ilya 2018 auf Reisen in Alaska gelernt hat), wie in Abbildung 13.11 dargestellt. Die Karte in Abbildung 13.11a ist detaillierter und umfasst etwa 230 Kilobyte, aber die Karte in Abbildung 13.11b ist nur 37 Kilobyte groß oder sechsmal kleiner! Achten Sie jedoch darauf, die Grenzen nicht so stark zu vereinfachen, dass Sie wichtige Funktionen entfernen.

Abbildung 13.11: Ziehen Sie in Betracht, Geometrien mit Mapshaper zu vereinfachen, um Ihre Webkarten schneller zu machen.

Führen Sie die folgenden Schritte aus, um Kartengrenzen in Mapshaper zu vereinfachen.

Importieren Sie Ihre Geodatendatei in Mapshaper. Sie können die Beispiele zusammenhängender US-Bundesstaaten im GeoJSON-Format verwenden.

Drücke den Vereinfachen Schaltfläche in der oberen rechten Ecke. Das Vereinfachungsmenü wird angezeigt, in dem Sie eine von drei Methoden auswählen können. Wir empfehlen die Überprüfung Formentfernung verhindern, und belassen Sie die Standardeinstellung Visvalingam / gewichteter Bereich. Klicken Anwenden.

Oben wird ein Schieberegler mit 100 % angezeigt (Abbildung 13.12), der die Dropdown-Liste für die Ebenenauswahl ersetzt. Bewegen Sie den Schieberegler nach rechts und sehen Sie, wie die Karte ihre Form vereinfacht. Stoppen Sie, wenn Sie der Meinung sind, dass die Karte angemessen aussieht (wenn die Formen noch erkennbar sind).

Mapshaper schlägt möglicherweise vor, Linienkreuzungen in der oberen linken Ecke zu reparieren. Klicken Reparatur.

Sie können Ihre Datei jetzt mit dem Export darstellen.

Abbildung 13.12: Verwenden Sie die Werkzeuge zum Vereinfachen und Reparieren in Mapshaper.

Tipp: Wenn Sie eine geografische Datei in Mapshaper hochladen, müssen Sie möglicherweise ihre Projektion ändern, um sie an Ihren Visualisierungswerkzeugen oder zugehörigen Geodaten auszurichten. Klicken Sie hier, um die . zu öffnen Konsole und geben Sie -proj wgs84 (oder -proj EPSG:4326 ) ein, um die Projektion in World Geodetic System 84 (wgs84) zu ändern, das Format, das vom Global Positioning System (GPS) verwendet wird, um Geokoordinaten auf der ganzen Welt anzuzeigen.

Lösen Sie interne Polygone auf, um eine Umrisskarte zu erstellen

Eine häufige Aufgabe der Kartenbearbeitung besteht darin, eine Umrisskarte zu erstellen, indem die internen Grenzen entfernt werden. Sie können beispielsweise in der vorherigen Übung die Staatsgrenzen der US-Karte auflösen, um den Umriss des Landes zu erhalten, wie in Abbildung 13.13 gezeigt.

Abbildung 13.13: Mapshaper lässt Sie Grenzen auflösen, um eine Umrissform zu erstellen.

Klicke auf Konsole, das ein Fenster zum Eingeben von Befehlen öffnet. Geben Sie die sich auflösen Befehl genau wie unten gezeigt, und drücken Sie dann die Zurückkehren oder Eintreten Schlüssel.

Sie werden sehen, dass interne Grenzen heller geworden sind, und so sagt Mapshaper, dass sie nicht mehr existieren. Sie können jetzt Ihre Umrissform exportieren.

Beschneiden Sie eine Karte, um sie an eine Umrissebene anzupassen

Eine weitere häufige Aufgabe beim Bearbeiten von Karten besteht darin, einen kleineren Teil einer größeren Karte auszuschneiden, um nur den benötigten Bereich zu erhalten. Der Bundesstaat Connecticut besteht beispielsweise aus 8 Countys, die wiederum in insgesamt 169 Städte unterteilt sind. Stellen Sie sich vor, Sie erhalten eine Grenzdatei aller 169 Städte und die Umrisse von Hartford County. Sie müssen die ursprüngliche Städtekarte „ausschneiden“, um nur die Städte aufzunehmen, die in einen bestimmten Teil von Connecticut fallen: Hartford County.

Mapshaper ermöglicht Ihnen genau das mit einem einfachen -clip-Befehl.

Importieren Sie zwei Boundary-Dateien in Mapshaper. Einer ist der größere, der abgeschnitten wird (wenn Sie Beispieldateien verwenden, ct-städte), und einer ist die gewünschte endgültige Form (hartfordcounty-umriss). Letzteres nennt ArcGIS das „Clip-Feature“.

Stellen Sie sicher, dass Ihr aktiver Layer auf die Karte eingestellt ist, die Sie ausschneiden (ct-städte).

Im Konsole, geben Sie -clip gefolgt vom Namen Ihrer Clip-Ebene ein, wie folgt:

  1. Sie sollten sehen, dass Ihre aktive Ebene abgeschnitten wurde. Manchmal haben Sie am Ende winzige „Splitter“ von abgeschnittenen Bereichen, die neben den Rändern verbleiben. Wenn dies der Fall ist, verwenden Sie einen verwandten Befehl, um sie wie folgt zu entfernen:

-clip hartfordcounty-outline -filter-slivers

  1. Ihr Mapshaper-Zustand sollte wie in Abbildung 13.14 dargestellt aussehen. Sie können die Datei jetzt auf Ihrem Computer speichern, indem Sie die Export Taste.

Abbildung 13.14: Stellen Sie beim Beschneiden sicher, dass Ihre aktive Ebene diejenige ist, die beschnitten wird (mit vielen Features), nicht die Clipping-Funktion selbst.

Tabellendaten mit Polygonkarte verbinden

Das Kombinieren von Tabellenkalkulationsdaten mit geografischen Grenzen ist eine häufige Aufgabe bei der Datenvisualisierung. In dieser Übung werden Sie diese Karte der Stadtgrenzen von Connecticut im GeoJson-Format herunterladen und auch diese Bevölkerungsdaten der Stadt Connecticut im CSV-Format herunterladen und die beiden zusammenfügen, um eine Choroplethenkarte zu erstellen.

Mapshaper bietet einen leistungsstarken -join-Befehl, um diese Dateidateien zu verbinden. Denken Sie daran, dass Sie in beiden Datensätzen einige gemeinsame Schlüssel benötigen (z Stadtname, oder Zustand, oder Land), um die beiden Dateien zu verbinden. Ohne ein gemeinsames Feld kann Mapshaper nicht wissen, welche Zahlen zu welchen Polygonen gehören.

Importieren Sie sowohl die GeoJSON-Datei als auch die CSV-Datei, die Sie oben heruntergeladen haben, in Mapshaper, indem Sie das Schnellimport-Feld verwenden.

Stellen Sie sicher, dass beide Dateien in der Dropdown-Liste der Ebenen angezeigt werden. Ihre CSV-Daten ähneln einer Tabelle. Verwenden Sie die Cursor > Funktionen prüfen Tool, um sicherzustellen, dass die Daten korrekt importiert werden. Wenn Sie die Connecticut-Beispieldaten verwenden, beachten Sie, dass die ct-städte Schicht hat Name Attribut mit dem Namen der Stadt und ct-Städte-Popdichte hat Städtenamen in der Stadt, Dorf Säule.

Erstellen Sie Ihre Geodatenschicht (ct-städte) die aktive Ebene.

Öffne das Konsole und geben Sie den Befehl -join wie folgt ein:

-join ct-towns-popdensity keys=name,town

In diesem Befehl ist ct-towns-popdensity der CSV-Layer, mit dem Sie zusammenführen, und Schlüssel sind die Attribute, die Werte enthalten, mit denen verbunden werden soll. Für unsere Beispieldaten wären dies Städtenamen, die im Namensattribut der Kartendatei gespeichert sind, und die Städtespalte der CSV-Datei.

In der Konsole wird eine Meldung angezeigt, die Sie darüber informiert, ob der Beitritt erfolgreich durchgeführt wurde oder ob Mapshaper auf Fehler gestoßen ist.

Verwenden Sie die Cursor > Funktionen prüfen um sicherzustellen, dass Sie CSV-Spalten als Felder Ihrer Polygone sehen, wie in Abbildung 13.15 gezeigt.

Sie können die Datei jetzt auf Ihrem Computer speichern, indem Sie auf klicken Export Taste.

Abbildung 13.15: Verbinden Sie in Mapshaper räumliche und CSV-Dateien mithilfe gemeinsamer Schlüssel, z. B. Städtenamen.

Tipp: Um Verwirrung zu vermeiden, sollten Sie den Befehl -rename-fields für Ihre CSV-Daten verwenden, die Schlüsselwerte enthalten, um den Schlüsselattributnamen Ihrer Karte abzugleichen. In unserem Beispiel würden Sie zuerst -rename-fields name=town in Ihre CSV-Datei umbenennen. Das Umbenennen dieses CSV-Felds in name vermeidet Verwirrung im zweiten Schritt, da Ihr Join-Befehl mit keys=name,name enden würde.

Punkte in Polygonen zählen mit Mapshaper

Mit Mapshaper können Sie Punkte in Polygonen zählen und diese Zahl mit dem Befehl -join in Polygonattributen aufzeichnen.

Laden Sie zwei GeoJSON-Beispieldateien auf Ihren Computer herunter: die Punkte, die Sie aggregieren möchten, z. B. Krankenhauspunkte in den USA, und Polygongrenzen, z. B. US-Bundesstaatengrenzen. Importieren Sie beide in Mapshaper.

Stellen Sie sicher, dass Sie „Polygone“ (keine Punkte) für die aktive Ebene auswählen, indem Sie sie aus dem Dropdown-Menü auswählen.

Im Konsole, führen Sie einen -join-Befehl mit einer count()-Funktion aus, wie folgt:

-Krankenhäuser beitreten-Punkte calc='hospitals = count()' Felder=

Dieser Befehl weist Mapshaper an, Punkte innerhalb des Krankenhäuser-Punkte Schicht und zeichne sie als Krankenhäuser Attribut der Polygone. Der Teil fields= weist Mapshaper an, keine Felder aus den Punkten zu kopieren, da wir in unserem Fall einen Viele-zu-Eins-Abgleich durchführen, d. h. viele Krankenhäuser pro Bundesland.

Verwenden Sie die Cursor > Funktionen prüfen um sicherzustellen, dass Polygone ein neues Feld mit der aufgezeichneten Anzahl von Punkten erhalten, wie in Abbildung 13.16 gezeigt.

Speichern Sie die neue Datei mit dem Export und wählen Sie das gewünschte Ausgabeformat. Im folgenden Abschnitt werden wir darüber sprechen, was mit Objekten passiert, die sich nicht verbinden.

Abbildung 13.16: Mapshaper -beitreten Befehl kann Punkte in Polygonen zählen.

Mehr über Joins

Im obigen Abschnitt „Punkte in Polygonen zählen“ mussten Sie nichts angeben Schlüssel um Positionen zwischen zwei geografischen Layern zu verbinden: Punkte und Polygone. Wenn jedoch eine der Dateien, die Sie zusammenführen möchten, ein CSV-Datensatz ist, benötigen Sie Schlüssel.

Wenn Sie kein CSV-Dataset haben, das den Spalten in Ihren Grenzkartendaten entspricht, können Sie ganz einfach eines erstellen. Laden Sie die Grenzkarte in Mapshaper hoch und exportieren Sie sie im CSV-Format. Öffnen Sie die heruntergeladene CSV-Datei in einem beliebigen Tabellenkalkulationstool. Um Datenspalten in der CSV-Tabelle abzugleichen, verwenden Sie die SVERWEIS-Funktion.

Im wirklichen Leben werden Sie selten perfekte Dateien mit Eins-zu-Eins-Übereinstimmungen haben. Daher möchten Sie möglicherweise mehr Informationen darüber haben, welche Funktionen nicht übereinstimmen, damit Sie Ihre Daten korrigieren können. Mapshaper hilft Ihnen, den Überblick über Daten zu behalten, die nicht richtig verbunden oder abgeglichen wurden. Wenn die Polygonkarte beispielsweise 169 Features enthält (eines für jede Stadt in Connecticut), die CSV-Tabelle jedoch nur 168 Datenzeilen enthält, verbindet Mapshaper alle diese mit übereinstimmenden Schlüsseln und zeigt dann diese Meldung an:

Um weitere Details darüber zu erhalten, welche Werte nicht verbunden wurden, fügen Sie unjoined unmatched -info Flags zu Ihrem Join-Befehl hinzu, wie folgt:

-join ct-towns-popdensity keys=name,stadt unjoined unmatched -info

Das unjoined-Flag speichert eine Kopie jedes unjoined-Datensatzes aus der Quelltabelle in einem anderen Layer namens nicht verbunden. Das nicht übereinstimmende Flag speichert eine Kopie jedes nicht übereinstimmenden Datensatzes aus der Zieltabelle in einem neuen Layer namens unübertroffen. Schließlich gibt das Flag -info einige zusätzliche Informationen über die Beitrittsprozedur an die Konsole aus.

Ausgewählte Polygone mit Befehlen zum Verbinden und Auflösen zusammenführen

In Mapshaper können Sie ausgewählte Polygone mit den Befehlen -join und -dissolve zu größeren Clustern zusammenführen. Stellen Sie sich vor, Sie sind beim CT Department of Public Health angestellt und haben die Aufgabe, 169 Städte in 20 Gesundheitsbezirke aufzuteilen und eine neue Geodatendatei zu erstellen.

Sie sollten damit beginnen, a . zu erstellen Zebrastreifen von Städten und ihren Gesundheitsbezirken, was eine Möglichkeit bedeutet, zwei Datensätze wie Postleitzahlen und Städte, in denen sie sich befinden, abzugleichen. In unserem Fall kann der Zebrastreifen so einfach sein wie eine zweispaltige CSV-Liste einer Stadt und ihres Bezirks, jeweils in einer neuen Zeile. Da Ihr Chef Ihnen keine Städteliste in einem Tabellenkalkulationsformat, sondern eine GeoJSON-Datei mit Ortsgrenzen gegeben hat, extrahieren wir daraus eine Städteliste.

Importieren Sie ct-towns.geojson in Mapshaper mit der Schnellimportbox.

Verwenden Sie die Cursor > Funktionen prüfen Werkzeug, um zu sehen, dass jedes Polygon a . hat Name Attribut mit dem Namen der Stadt.

Speichern Sie Attributdaten als CSV-Datei mit Export Taste. Öffnen Sie die Datei in einem beliebigen Tabellenkalkulationstool. Sie werden sehen, dass Ihre Daten eine einspaltige Datei mit a sind Name Spalte, die 169 Städte auflistet.

Erstellen Sie in Ihrer Tabelle eine zweite Spalte mit dem Titel zusammengeführt und Werte aus dem ersten kopieren und einfügen Name Säule. Zu diesem Zeitpunkt enthält Ihre Tabelle zwei Spalten mit denselben Werten.

Wählen Sie ein paar Städte aus, wie zum Beispiel West Hartford und Bloomfield, und weisen ihnen „Bloomfield-West Hartford“ zu zusammengeführt Spalte, wie in Abbildung 13.17 gezeigt. Sie können hier anhalten und zum nächsten Schritt übergehen oder einigen anderen Nachbarstädten Bezirksnamen zuweisen.

Abbildung 13.17: Erstellen Sie einen zweispaltigen Zebrastreifen aus Städtenamen und ihren zusammengeführten Gesundheitsbezirken.

Speichern Sie diese neue Tabellenkalkulationsdatei unter ct-towns-merged.csv, und ziehen Sie es per Drag-and-Drop in Mapshaper auf Ihrem ct-städte Schicht. Klicken Importieren.

In Mapshaper wird diese neue CSV-Ebene mit dem Namen ct-städte-fusioniert, wird als eine Reihe von Tabellenzellen angezeigt. Wählen Sie aus dem Dropdown-Menü ct-städte um zu Ihrer Karte zurückzukehren.

Jetzt können Sie bestimmte Städte gemäß Ihrer hochgeladenen CSV-Datei zu Bezirken zusammenführen. Öffne das Konsole, und geben Sie ein:

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

, um den CSV-Layer mit dem auf dem Bildschirm angezeigten Begrenzungslayer zu verbinden.

um Polygone von Städten gemäß der aufzulösen zusammengeführt Spalte der CSV-Datei.

In unserem Beispiel werden nur Bloomfield und West Hartford in einen kombinierten regionalen Gesundheitsbezirk „Bloomfield-West Hartford“ aufgelöst, wobei die gemeinsame Grenzlinie zwischen diesen Städten ausgegraut wird und alle anderen Polygone gleich bleiben. Abbildung 13.18 zeigt das Endergebnis.

Abbildung 13.18: Zusammenführen von Polygonen basierend auf einem vordefinierten Zebrastreifen.

Sie können Attributdaten von Polygonen mit . überprüfen Cursor > Funktionen prüfen Werkzeug und speichern Sie die resultierende Datei mit dem Export Taste.

Insgesamt ist Mapshaper ein leistungsstarkes Werkzeug zum Bearbeiten von Geodaten mit vielen weiteren Befehlen, die es wert sind, erforscht zu werden. Dazu gehören das Ändern von Projektionen, das Filtern von Features mithilfe von JavaScript-Ausdrücken, das Zuweisen von Farben zu Polygonen basierend auf Werten und vieles mehr. Erkunden Sie das MapShaper-Wiki auf GitHub, um mehr über Befehle zu erfahren und weitere Beispiele zu sehen.

Kaufen Sie das gedruckte Buch bei Amazon - Barnes & Noble - Bookshop - Powell's - oder Ihrem örtlichen Buchladen.
Oder starten Sie eine kostenlose 30-Tage-Testversion für alle Bücher und digitalen Inhalte auf der Online-Lernplattform von O'Reilly.
Teilen Sie Ihr Feedback zum Buch, indem Sie @handsondataviz auf Twitter markieren oder kontaktieren Sie die Autoren.


Über den Autor

Julie Powell

Julie Powell ist Principal Product Manager mit Schwerpunkt auf ArcGIS API for JavaScript und dem Designsystem von Esri. Sie arbeitet mit einer breiten Benutzer-Community zusammen, um das Bewusstsein und die Einsicht in die Bedürfnisse der GIS-Community aufrechtzuerhalten, während sie gleichzeitig Feedback an die Entwicklungsteams liefert, um sicherzustellen, dass Benutzer erfolgreich hochmoderne, zielgerichtete Lösungen mit ArcGIS-Software entwickeln können. Julie präsentiert GIS-Technologietrends und innovative Lösungen auf dem Esri Developer Summit, der Esri International User Conference, der Esri Latin American User Conference und anderen regionalen Konferenzen. Julie bringt 19 Jahre Erfahrung in der Zusammenarbeit mit weltweit führenden Unternehmen wie Hewlett-Packard und Esri mit und liefert eine Vielzahl von Softwarelösungen sowohl für den Unternehmens- als auch den Verbrauchermarkt. Julie has worked on a wide range of projects and consulting endeavors, including serving as technical lead for web mapping solutions for strategic customers.


How to process GRIB2 weather data for agricultural applications (GeoJSON)

Written by
Elliott Wobler
Technical Solutions Engineer

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

This tutorial uses GeoJSON input.

Überblick

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 Agricultural 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 zu +360.

To make the data easier to work with, we convert longitude values into the standard range of -180 degrees to +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.